Merge pull request #1866 from xzyfer/bump-libsass

Bump LibSass to 3.5.0.beta.2

package.json

 {
   "name": "node-sass",
   "version": "4.3.0",
-  "libsass": "3.4.3",
+  "libsass": "3.5.0.beta.2",
   "description": "Wrapper around libsass",
   "license": "MIT",
   "bugs": "https://github.com/sass/node-sass/issues",

src/libsass.gyp

@@ -12,6 +12,7 @@
       ],
       'sources': [
         'libsass/src/ast.cpp',
+        'libsass/src/ast_fwd_decl.cpp',
         'libsass/src/base64vlq.cpp',
         'libsass/src/bind.cpp',
         'libsass/src/cencode.c',

src/libsass/.travis.yml

 language: cpp
 sudo: false
 
-os:
-  - linux
-  - osx
-
-compiler:
-  - gcc
-  - clang
 
 # don't create redundant code coverage reports
 # - AUTOTOOLS=yes COVERAGE=yes BUILD=static
@@ -19,27 +12,53 @@ compiler:
 # this will still catch all coding errors!
 # - AUTOTOOLS=yes COVERAGE=no BUILD=static
 
-env:
-  - AUTOTOOLS=no COVERAGE=no BUILD=shared
-  - AUTOTOOLS=no COVERAGE=yes BUILD=static
-  - AUTOTOOLS=yes COVERAGE=no BUILD=shared
-
 # currenty there are various issues when
 # built with coverage, clang and autotools
 # - AUTOTOOLS=yes COVERAGE=yes BUILD=shared
 
 matrix:
-  exclude:
-    - compiler: clang
-      env: AUTOTOOLS=yes COVERAGE=yes BUILD=static
+  include :
+    - os: linux
+      compiler: gcc
+      env: AUTOTOOLS=no COVERAGE=yes BUILD=static
     - os: linux
+      compiler: g++-5
+      env: AUTOTOOLS=yes COVERAGE=no BUILD=shared
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+          packages:
+            - g++-5
+    - os: linux
+      compiler: clang++-3.7
+      env: AUTOTOOLS=no COVERAGE=yes BUILD=static
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.7
+          packages:
+            - clang-3.7
+    - os: linux
+      compiler: clang
+      env: AUTOTOOLS=yes COVERAGE=no BUILD=shared
+    - os: osx
+      compiler: clang
       env: AUTOTOOLS=no COVERAGE=no BUILD=shared
     - os: osx
-      compiler: gcc
+      compiler: clang
+      env: AUTOTOOLS=no COVERAGE=yes BUILD=static
     - os: osx
-      env: AUTOTOOLS=no BUILD=static
+      compiler: clang
+      env: AUTOTOOLS=yes COVERAGE=no BUILD=shared
 
-script: ./script/ci-build-libsass
+script:
+  - ./script/ci-build-libsass
+  - ./script/ci-build-plugin math
+  - ./script/ci-build-plugin glob
+  - ./script/ci-build-plugin digest
+  - ./script/ci-build-plugin tests
 before_install: ./script/ci-install-deps
 install: ./script/ci-install-compiler
 after_success: ./script/ci-report-coverage

src/libsass/GNUmakefile.am

@@ -4,7 +4,7 @@ AM_COPT = -Wall -O2
 AM_COVLDFLAGS =
 
 if ENABLE_COVERAGE
-	AM_COPT = -O0 --coverage
+	AM_COPT = -Wall -O1 -fno-omit-frame-pointer --coverage
 	AM_COVLDFLAGS += -lgcov
 endif
 
@@ -57,7 +57,7 @@ TESTS = \
 	$(SASS_SPEC_PATH)/spec/scss-tests \
 	$(SASS_SPEC_PATH)/spec/types
 
-SASS_TEST_FLAGS = -V 3.4 --impl libsass
+SASS_TEST_FLAGS = -V 3.5 --impl libsass
 LOG_DRIVER = env AM_TAP_AWK='$(AWK)' $(SHELL) ./script/tap-driver
 AM_LOG_FLAGS = -c ./tester $(LOG_FLAGS)
 if USE_TAP

src/libsass/Makefile

@@ -15,10 +15,14 @@ INSTALL  ?= install
 CFLAGS   ?= -Wall
 CXXFLAGS ?= -Wall
 LDFLAGS  ?= -Wall
-ifneq "$(COVERAGE)" "yes"
+ifeq "x$(COVERAGE)" "x"
   CFLAGS   += -O2
   CXXFLAGS += -O2
   LDFLAGS  += -O2
+else
+  CFLAGS   += -O1 -fno-omit-frame-pointer
+  CXXFLAGS += -O1 -fno-omit-frame-pointer
+  LDFLAGS  += -O1 -fno-omit-frame-pointer
 endif
 LDFLAGS  += -Wl,-undefined,error
 CAT      ?= $(if $(filter $(OS),Windows_NT),type,cat)
@@ -305,16 +309,16 @@ version: $(SASSC_BIN)
 	$(SASSC_BIN) -v
 
 test: $(SASSC_BIN)
-	$(RUBY_BIN) $(SASS_SPEC_PATH)/sass-spec.rb -V 3.4 -c $(SASSC_BIN) --impl libsass $(LOG_FLAGS) $(SASS_SPEC_PATH)/$(SASS_SPEC_SPEC_DIR)
+	$(RUBY_BIN) $(SASS_SPEC_PATH)/sass-spec.rb -V 3.5 -c $(SASSC_BIN) --impl libsass $(LOG_FLAGS) $(SASS_SPEC_PATH)/$(SASS_SPEC_SPEC_DIR)
 
 test_build: $(SASSC_BIN)
-	$(RUBY_BIN) $(SASS_SPEC_PATH)/sass-spec.rb -V 3.4 -c $(SASSC_BIN) --impl libsass $(LOG_FLAGS) $(SASS_SPEC_PATH)/$(SASS_SPEC_SPEC_DIR)
+	$(RUBY_BIN) $(SASS_SPEC_PATH)/sass-spec.rb -V 3.5 -c $(SASSC_BIN) --impl libsass $(LOG_FLAGS) $(SASS_SPEC_PATH)/$(SASS_SPEC_SPEC_DIR)
 
 test_full: $(SASSC_BIN)
-	$(RUBY_BIN) $(SASS_SPEC_PATH)/sass-spec.rb -V 3.4 -c $(SASSC_BIN) --impl libsass --run-todo $(LOG_FLAGS) $(SASS_SPEC_PATH)/$(SASS_SPEC_SPEC_DIR)
+	$(RUBY_BIN) $(SASS_SPEC_PATH)/sass-spec.rb -V 3.5 -c $(SASSC_BIN) --impl libsass --run-todo $(LOG_FLAGS) $(SASS_SPEC_PATH)/$(SASS_SPEC_SPEC_DIR)
 
 test_probe: $(SASSC_BIN)
-	$(RUBY_BIN) $(SASS_SPEC_PATH)/sass-spec.rb -V 3.4 -c $(SASSC_BIN) --impl libsass --probe-todo $(LOG_FLAGS) $(SASS_SPEC_PATH)/$(SASS_SPEC_SPEC_DIR)
+	$(RUBY_BIN) $(SASS_SPEC_PATH)/sass-spec.rb -V 3.5 -c $(SASSC_BIN) --impl libsass --probe-todo $(LOG_FLAGS) $(SASS_SPEC_PATH)/$(SASS_SPEC_SPEC_DIR)
 
 clean-objects: lib
 	-$(RM) lib/*.a lib/*.so lib/*.dll lib/*.la

src/libsass/Makefile.conf

@@ -13,6 +13,7 @@ SOURCES = \
 	functions.cpp \
 	color_maps.cpp \
 	environment.cpp \
+	ast_fwd_decl.cpp \
 	bind.cpp \
 	file.cpp \
 	util.cpp \

src/libsass/appveyor.yml

@@ -65,7 +65,7 @@ test_script:
       }
       $env:TargetPath = Join-Path $pwd.Path $env:TargetPath
       If (Test-Path "$env:TargetPath") {
-        ruby sass-spec/sass-spec.rb -V 3.4 --probe-todo --impl libsass -c $env:TargetPath -s sass-spec/spec
+        ruby sass-spec/sass-spec.rb -V 3.5 --probe-todo --impl libsass -c $env:TargetPath -s sass-spec/spec
         if(-not($?)) {
           echo "sass-spec tests failed"
           exit 1

src/libsass/configure.ac

@@ -121,8 +121,8 @@ if test "x$enable_cov" = "xyes"; then
 
     # Remove all optimization flags from C[XX]FLAGS
     changequote({,})
-    CFLAGS=`echo "$CFLAGS" | $SED -e 's/-O[0-9]*//g'`
-    CXXFLAGS=`echo "$CXXFLAGS" | $SED -e 's/-O[0-9]*//g'`
+    CFLAGS=`echo "$CFLAGS -O1 -fno-omit-frame-pointer" | $SED -e 's/-O[0-9]*//g'`
+    CXXFLAGS=`echo "$CXXFLAGS -O1 -fno-omit-frame-pointer" | $SED -e 's/-O[0-9]*//g'`
     changequote([,])
 
     AC_SUBST(GCOV)

src/libsass/docs/api-context-internal.md

@@ -7,26 +7,35 @@ enum Sass_Input_Style {
   SASS_CONTEXT_FOLDER
 };
 
-// simple linked list
-struct string_list {
-  string_list* next;
-  char* string;
-};
-
 // sass config options structure
-struct Sass_Options {
-
-  // Precision for fractional numbers
-  int precision;
+struct Sass_Inspect_Options {
 
   // Output style for the generated css code
   // A value from above SASS_STYLE_* constants
   enum Sass_Output_Style output_style;
 
+  // Precision for fractional numbers
+  int precision;
+
+};
+
+// sass config options structure
+struct Sass_Output_Options : Sass_Inspect_Options {
+
+  // String to be used for indentation
+  const char* indent;
+  // String to be used to for line feeds
+  const char* linefeed;
+
   // Emit comments in the generated CSS indicating
   // the corresponding source line.
   bool source_comments;
 
+};
+
+// sass config options structure
+struct Sass_Options : Sass_Output_Options {
+
   // embed sourceMappingUrl as data uri
   bool source_map_embed;
 
@@ -56,15 +65,9 @@ struct Sass_Options {
   // information in source-maps etc.
   char* output_path;
 
-  // String to be used for indentation
-  const char* indent;
-  // String to be used to for line feeds
-  const char* linefeed;
-
   // Colon-separated list of paths
   // Semicolon-separated on Windows
-  // Note: It may be better to use
-  // array interface instead
+  // Maybe use array interface instead?
   char* include_path;
   char* plugin_path;
 
@@ -82,10 +85,13 @@ struct Sass_Options {
   char* source_map_root;
 
   // Custom functions that can be called from sccs code
-  Sass_C_Function_List c_functions;
+  Sass_Function_List c_functions;
 
   // Callback to overload imports
-  Sass_C_Import_Callback importer;
+  Sass_Importer_List c_importers;
+
+  // List of custom headers
+  Sass_Importer_List c_headers;
 
 };
 
@@ -111,6 +117,7 @@ struct Sass_Context : Sass_Options
   char* error_file;
   size_t error_line;
   size_t error_column;
+  const char* error_src;
 
   // report imported files
   char** included_files;
@@ -130,6 +137,7 @@ struct Sass_Data_Context : Sass_Context {
 
   // provided source string
   char* source_string;
+  char* srcmap_string;
 
 };
 
@@ -147,9 +155,9 @@ struct Sass_Compiler {
   // original c context
   Sass_Context* c_ctx;
   // Sass::Context
-  void* cpp_ctx;
+  Sass::Context* cpp_ctx;
   // Sass::Block
-  void* root;
+  Sass::Block_Obj root;
 };
 ```
 

src/libsass/docs/api-context.md

@@ -207,6 +207,15 @@ size_t sass_context_get_error_column (struct Sass_Context* ctx);
 const char* sass_context_get_source_map_string (struct Sass_Context* ctx);
 char** sass_context_get_included_files (struct Sass_Context* ctx);
 
+// Getters for Sass_Compiler options (query import stack)
+size_t sass_compiler_get_import_stack_size(struct Sass_Compiler* compiler);
+Sass_Import_Entry sass_compiler_get_last_import(struct Sass_Compiler* compiler);
+Sass_Import_Entry sass_compiler_get_import_entry(struct Sass_Compiler* compiler, size_t idx);
+// Getters for Sass_Compiler options (query function stack)
+size_t sass_compiler_get_callee_stack_size(struct Sass_Compiler* compiler);
+Sass_Callee_Entry sass_compiler_get_last_callee(struct Sass_Compiler* compiler);
+Sass_Callee_Entry sass_compiler_get_callee_entry(struct Sass_Compiler* compiler, size_t idx);
+
 // Take ownership of memory (value on context is set to 0)
 char* sass_context_take_error_json (struct Sass_Context* ctx);
 char* sass_context_take_error_text (struct Sass_Context* ctx);
@@ -214,10 +223,6 @@ char* sass_context_take_error_message (struct Sass_Context* ctx);
 char* sass_context_take_error_file (struct Sass_Context* ctx);
 char* sass_context_take_output_string (struct Sass_Context* ctx);
 char* sass_context_take_source_map_string (struct Sass_Context* ctx);
-
-// Push function for plugin/include paths (no manipulation support for now)
-void sass_option_push_plugin_path (struct Sass_Options* options, const char* path);
-void sass_option_push_include_path (struct Sass_Options* options, const char* path);
 ```
 
 ### Sass Options API
@@ -236,13 +241,18 @@ const char* sass_option_get_indent (struct Sass_Options* options);
 const char* sass_option_get_linefeed (struct Sass_Options* options);
 const char* sass_option_get_input_path (struct Sass_Options* options);
 const char* sass_option_get_output_path (struct Sass_Options* options);
-const char* sass_option_get_plugin_path (struct Sass_Options* options);
-const char* sass_option_get_include_path (struct Sass_Options* options);
 const char* sass_option_get_source_map_file (struct Sass_Options* options);
 const char* sass_option_get_source_map_root (struct Sass_Options* options);
 Sass_C_Function_List sass_option_get_c_functions (struct Sass_Options* options);
 Sass_C_Import_Callback sass_option_get_importer (struct Sass_Options* options);
 
+// Getters for Context_Option include path array
+size_t sass_option_get_include_path_size(struct Sass_Options* options);
+const char* sass_option_get_include_path(struct Sass_Options* options, size_t i);
+// Plugin paths to load dynamic libraries work the same
+size_t sass_option_get_plugin_path_size(struct Sass_Options* options);
+const char* sass_option_get_plugin_path(struct Sass_Options* options, size_t i);
+
 // Setters for Context_Option values
 void sass_option_set_precision (struct Sass_Options* options, int precision);
 void sass_option_set_output_style (struct Sass_Options* options, enum Sass_Output_Style output_style);
@@ -266,6 +276,16 @@ void sass_option_set_importer (struct Sass_Options* options, Sass_C_Import_Callb
 // Push function for paths (no manipulation support for now)
 void sass_option_push_plugin_path (struct Sass_Options* options, const char* path);
 void sass_option_push_include_path (struct Sass_Options* options, const char* path);
+
+// Resolve a file via the given include paths in the sass option struct
+// find_file looks for the exact file name while find_include does a regular sass include
+char* sass_find_file (const char* path, struct Sass_Options* opt);
+char* sass_find_include (const char* path, struct Sass_Options* opt);
+
+// Resolve a file relative to last import or include paths in the sass option struct
+// find_file looks for the exact file name while find_include does a regular sass include
+char* sass_compiler_find_file (const char* path, struct Sass_Compiler* compiler);
+char* sass_compiler_find_include (const char* path, struct Sass_Compiler* compiler);
 ```
 
 ### More links

src/libsass/docs/api-doc.md

 ## Introduction
 
-LibSass wouldn't be much good without a way to interface with it. These interface documentations describe the various functions and data structures available to implementers. They are split up over three major components, which have all their own source files (plus some common functionality).
+LibSass wouldn't be much good without a way to interface with it. These
+interface documentations describe the various functions and data structures
+available to implementers. They are split up over three major components, which
+have all their own source files (plus some common functionality).
 
 - [Sass Context](api-context.md) - Trigger and handle the main Sass compilation
 - [Sass Value](api-value.md) - Exchange values and its format with LibSass
@@ -41,7 +44,12 @@ gcc -Wall version.c -lsass -o version && ./version
 
 ## Compiling your code
 
-The most important is your sass file (or string of sass code).  With this, you will want to start a LibSass compiler.  Here is some pseudocode describing the process.  The compiler has two different modes: direct input as a string with `Sass_Data_Context` or LibSass will do file reading for you by using `Sass_File_Context`.  See the code for a list of options available [Sass_Options](https://github.com/sass/libsass/blob/36feef0/include/sass/interface.h#L18)
+The most important is your sass file (or string of sass code). With this, you
+will want to start a LibSass compiler. Here is some pseudocode describing the
+process. The compiler has two different modes: direct input as a string with
+`Sass_Data_Context` or LibSass will do file reading for you by using
+`Sass_File_Context`. See the code for a list of options available
+[Sass_Options](https://github.com/sass/libsass/blob/36feef0/include/sass/interface.h#L18)
 
 **Building a file compiler**
 
@@ -97,7 +105,9 @@ struct Sass_Data_context : Sass_Context;
 
 This mirrors very well how `libsass` uses these structures.
 
-- `Sass_Options` holds everything you feed in before the compilation. It also hosts `input_path` and `output_path` options, because they are used to generate/calculate relative links in source-maps. The `input_path` is shared with `Sass_File_Context`.
+- `Sass_Options` holds everything you feed in before the compilation. It also hosts
+`input_path` and `output_path` options, because they are used to generate/calculate
+relative links in source-maps. The `input_path` is shared with `Sass_File_Context`.
 - `Sass_Context` holds all the data returned by the compilation step.
 - `Sass_File_Context` is a specific implementation that requires no additional fields
 - `Sass_Data_Context` is a specific implementation that adds the `input_source` field
@@ -106,8 +116,11 @@ Structs can be down-casted to access `context` or `options`!
 
 ## Memory handling and life-cycles
 
-We keep memory around for as long as the main [context](api-context.md) object is not destroyed (`sass_delete_context`). LibSass will create copies of most inputs/options beside the main sass code.
-You need to allocate and fill that buffer before passing it to LibSass. You may also overtake memory management from libsass for certain return values (i.e. `sass_context_take_output_string`).
+We keep memory around for as long as the main [context](api-context.md) object
+is not destroyed (`sass_delete_context`). LibSass will create copies of most
+inputs/options beside the main sass code. You need to allocate and fill that
+buffer before passing it to LibSass. You may also overtake memory management
+from libsass for certain return values (i.e. `sass_context_take_output_string`).
 
 ```C
 // to allocate buffer to be filled
@@ -125,9 +138,6 @@ void sass_free_memory(void* ptr);
 char* sass_string_unquote (const char* str);
 char* sass_string_quote (const char* str, const char quote_mark);
 
-// Resolve a file via the given include paths in the include char* array
-char* sass_resolve_file (const char* path, const char* incs[]);
-
 // Get compiled libsass version
 const char* libsass_version(void);
 
@@ -140,15 +150,25 @@ const char* libsass_language_version(void);
 
 **input_path**
 
-The `input_path` is part of `Sass_Options`, but it also is the main option for `Sass_File_Context`. It is also used to generate relative file links in source-maps. Therefore it is pretty usefull to pass this information if you have a `Sass_Data_Context` and know the original path.
+The `input_path` is part of `Sass_Options`, but it also is the main option for
+`Sass_File_Context`. It is also used to generate relative file links in source-
+maps. Therefore it is pretty usefull to pass this information if you have a
+`Sass_Data_Context` and know the original path.
 
 **output_path**
 
-Be aware that `libsass` does not write the output file itself. This option merely exists to give `libsass` the proper information to generate links in source-maps. The file has to be written to the disk by the binding/implementation. If the `output_path` is omitted, `libsass` tries to extrapolate one from the `input_path` by replacing (or adding) the file ending with `.css`.
+Be aware that `libsass` does not write the output file itself. This option
+merely exists to give `libsass` the proper information to generate links in
+source-maps. The file has to be written to the disk by the
+binding/implementation. If the `output_path` is omitted, `libsass` tries to
+extrapolate one from the `input_path` by replacing (or adding) the file ending
+with `.css`.
 
 ## Error Codes
 
-The `error_code` is integer value which indicates the type of error that occurred inside the LibSass process. Following is the list of error codes along with the short description:
+The `error_code` is integer value which indicates the type of error that
+occurred inside the LibSass process. Following is the list of error codes along
+with the short description:
 
 * 1: normal errors like parsing or `eval` errors
 * 2: bad allocation error (memory error)
@@ -156,11 +176,15 @@ The `error_code` is integer value which indicates the type of error that occurre
 * 4: legacy string exceptions ( `throw const char*` or `std::string` )
 * 5: Some other unknown exception
 
-Although for the API consumer, error codes do not offer much value except indicating whether *any* error occurred during the compilation, it helps debugging the LibSass internal code paths.
+Although for the API consumer, error codes do not offer much value except
+indicating whether *any* error occurred during the compilation, it helps
+debugging the LibSass internal code paths.
 
 ## Real-World Implementations
 
-The proof is in the pudding, so we have highlighted a few implementations that should be on par with the latest LibSass interface version. Some of them may not have all features implemented!
+The proof is in the pudding, so we have highlighted a few implementations that
+should be on par with the latest LibSass interface version. Some of them may not
+have all features implemented!
 
 1. [Perl Example](https://github.com/sass/perl-libsass/blob/master/lib/CSS/Sass.xs)
 2. [Go Example](http://godoc.org/github.com/wellington/go-libsass#example-Context-Compile)
@@ -168,11 +192,20 @@ The proof is in the pudding, so we have highlighted a few implementations that s
 
 ## ABI forward compatibility
 
-We use a functional API to make dynamic linking more robust and future compatible. The API is not yet 100% stable, so we do not yet guarantee [ABI](https://gcc.gnu.org/onlinedocs/libstdc++/manual/abi.html) forward compatibility. We will do so, once we increase the shared library version above 1.0.
+We use a functional API to make dynamic linking more robust and future
+compatible. The API is not yet 100% stable, so we do not yet guarantee
+[ABI](https://gcc.gnu.org/onlinedocs/libstdc++/manual/abi.html) forward
+compatibility.
 
 ## Plugins (experimental)
 
-LibSass can load plugins from directories. Just define `plugin_path` on context options to load all plugins from the given directories. To implement plugins, please consult the [[Wiki-Page for plugins|API-Plugins]].
+LibSass can load plugins from directories. Just define `plugin_path` on context
+options to load all plugins from the directories. To implement plugins, please
+consult the following example implementations.
+
+- https://github.com/mgreter/libsass-glob
+- https://github.com/mgreter/libsass-math
+- https://github.com/mgreter/libsass-digest
 
 ## Internal Structs
 

src/libsass/docs/api-function-example.md

@@ -11,7 +11,7 @@ union Sass_Value* call_fn_foo(const union Sass_Value* s_args, Sass_Function_Entr
   struct Sass_Context* ctx = sass_compiler_get_context(comp);
   struct Sass_Options* opts = sass_compiler_get_options(comp);
   // get information about previous importer entry from the stack
-  struct Sass_Import* import = sass_compiler_get_last_import(comp);
+  Sass_Import_Entry import = sass_compiler_get_last_import(comp);
   const char* prev_abs_path = sass_import_get_abs_path(import);
   const char* prev_imp_path = sass_import_get_imp_path(import);
   // get the cookie from function descriptor

src/libsass/docs/api-function.md

@@ -30,17 +30,41 @@ typedef union Sass_Value* (*Sass_Function_Fn)
   (const union Sass_Value*, Sass_Function_Entry cb, struct Sass_Compiler* compiler);
 
 // Creators for sass function list and function descriptors
-ADDAPI Sass_Function_List ADDCALL sass_make_function_list (size_t length);
-ADDAPI Sass_Function_Entry ADDCALL sass_make_function (const char* signature, Sass_Function_Fn cb, void* cookie);
+Sass_Function_List sass_make_function_list (size_t length);
+Sass_Function_Entry sass_make_function (const char* signature, Sass_Function_Fn cb, void* cookie);
+// In case you need to free them yourself
+void sass_delete_function (Sass_Function_Entry entry);
+void sass_delete_function_list (Sass_Function_List list);
 
 // Setters and getters for callbacks on function lists
-ADDAPI Sass_Function_Entry ADDCALL sass_function_get_list_entry(Sass_Function_List list, size_t pos);
-ADDAPI void ADDCALL sass_function_set_list_entry(Sass_Function_List list, size_t pos, Sass_Function_Entry cb);
+Sass_Function_Entry sass_function_get_list_entry(Sass_Function_List list, size_t pos);
+void sass_function_set_list_entry(Sass_Function_List list, size_t pos, Sass_Function_Entry cb);
+
+// Setters to insert an entry into the import list (you may also use [] access directly)
+// Since we are dealing with pointers they should have a guaranteed and fixed size
+void sass_import_set_list_entry (Sass_Import_List list, size_t idx, Sass_Import_Entry entry);
+Sass_Import_Entry sass_import_get_list_entry (Sass_Import_List list, size_t idx);
 
 // Getters for custom function descriptors
-ADDAPI const char* ADDCALL sass_function_get_signature (Sass_Function_Entry cb);
-ADDAPI Sass_Function_Fn ADDCALL sass_function_get_function (Sass_Function_Entry cb);
-ADDAPI void* ADDCALL sass_function_get_cookie (Sass_Function_Entry cb);
+const char* sass_function_get_signature (Sass_Function_Entry cb);
+Sass_Function_Fn sass_function_get_function (Sass_Function_Entry cb);
+void* sass_function_get_cookie (Sass_Function_Entry cb);
+
+// Getters for callee entry
+const char* sass_callee_get_name (Sass_Callee_Entry);
+const char* sass_callee_get_path (Sass_Callee_Entry);
+size_t sass_callee_get_line (Sass_Callee_Entry);
+size_t sass_callee_get_column (Sass_Callee_Entry);
+enum Sass_Callee_Type sass_callee_get_type (Sass_Callee_Entry);
+Sass_Env_Frame sass_callee_get_env (Sass_Callee_Entry);
+
+// Getters and Setters for environments (lexical, local and global)
+union Sass_Value* sass_env_get_lexical (Sass_Env_Frame, const char*);
+void sass_env_set_lexical (Sass_Env_Frame, const char*, union Sass_Value*);
+union Sass_Value* sass_env_get_local (Sass_Env_Frame, const char*);
+void sass_env_set_local (Sass_Env_Frame, const char*, union Sass_Value*);
+union Sass_Value* sass_env_get_global (Sass_Env_Frame, const char*);
+void sass_env_set_global (Sass_Env_Frame, const char*, union Sass_Value*);
 ```
 
 ### More links

src/libsass/docs/api-importer.md

@@ -5,7 +5,7 @@ By using custom importers, Sass stylesheets can be implemented in any possible w
 You actually have to return a list of imports, since some importers may want to import multiple files from one import statement (ie. a glob/star importer).  The memory you pass with source and srcmap is taken over by LibSass and freed automatically when the import is done. You are also allowed to return `0` instead of a list, which will tell LibSass to handle the import by itself (as if no custom importer was in use).
 
 ```C
-struct Sass_Import** rv = sass_make_import_list(1);
+Sass_Import_Entry* rv = sass_make_import_list(1);
 rv[0] = sass_make_import(rel, abs, source, srcmap);
 ```
 
@@ -31,7 +31,7 @@ struct Sass_C_Import_Descriptor;
 // Typedef defining the custom importer callback
 typedef struct Sass_C_Import_Descriptor (*Sass_C_Import_Callback);
 // Typedef defining the importer c function prototype
-typedef struct Sass_Import** (*Sass_C_Import_Fn) (const char* url, const char* prev, void* cookie);
+typedef Sass_Import_Entry* (*Sass_C_Import_Fn) (const char* url, const char* prev, void* cookie);
 
 // Creators for custom importer callback (with some additional pointer)
 // The pointer is mostly used to store the callback into the actual function
@@ -45,38 +45,38 @@ void* sass_import_get_cookie (Sass_C_Import_Callback fn);
 void sass_delete_importer (Sass_C_Import_Callback fn);
 
 // Creator for sass custom importer return argument list
-struct Sass_Import** sass_make_import_list (size_t length);
+Sass_Import_Entry* sass_make_import_list (size_t length);
 // Creator for a single import entry returned by the custom importer inside the list
-struct Sass_Import* sass_make_import_entry (const char* path, char* source, char* srcmap);
-struct Sass_Import* sass_make_import (const char* rel, const char* abs, char* source, char* srcmap);
+Sass_Import_Entry sass_make_import_entry (const char* path, char* source, char* srcmap);
+Sass_Import_Entry sass_make_import (const char* rel, const char* abs, char* source, char* srcmap);
 
 // set error message to abort import and to print out a message (path from existing object is used in output)
-struct Sass_Import* sass_import_set_error(struct Sass_Import* import, const char* message, size_t line, size_t col);
+Sass_Import_Entry sass_import_set_error(Sass_Import_Entry import, const char* message, size_t line, size_t col);
 
 // Setters to insert an entry into the import list (you may also use [] access directly)
 // Since we are dealing with pointers they should have a guaranteed and fixed size
-void sass_import_set_list_entry (struct Sass_Import** list, size_t idx, struct Sass_Import* entry);
-struct Sass_Import* sass_import_get_list_entry (struct Sass_Import** list, size_t idx);
+void sass_import_set_list_entry (Sass_Import_Entry* list, size_t idx, Sass_Import_Entry entry);
+Sass_Import_Entry sass_import_get_list_entry (Sass_Import_Entry* list, size_t idx);
 
 // Getters for import entry
-const char* sass_import_get_rel_path (struct Sass_Import*);
-const char* sass_import_get_abs_path (struct Sass_Import*);
-const char* sass_import_get_source (struct Sass_Import*);
-const char* sass_import_get_srcmap (struct Sass_Import*);
+const char* sass_import_get_imp_path (Sass_Import_Entry);
+const char* sass_import_get_abs_path (Sass_Import_Entry);
+const char* sass_import_get_source (Sass_Import_Entry);
+const char* sass_import_get_srcmap (Sass_Import_Entry);
 // Explicit functions to take ownership of these items
 // The property on our struct will be reset to NULL
-char* sass_import_take_source (struct Sass_Import*);
-char* sass_import_take_srcmap (struct Sass_Import*);
+char* sass_import_take_source (Sass_Import_Entry);
+char* sass_import_take_srcmap (Sass_Import_Entry);
 
 // Getters for import error entries
-size_t sass_import_get_error_line (struct Sass_Import*);
-size_t sass_import_get_error_column (struct Sass_Import*);
-const char* sass_import_get_error_message (struct Sass_Import*);
+size_t sass_import_get_error_line (Sass_Import_Entry);
+size_t sass_import_get_error_column (Sass_Import_Entry);
+const char* sass_import_get_error_message (Sass_Import_Entry);
 
 // Deallocator for associated memory (incl. entries)
-void sass_delete_import_list (struct Sass_Import**);
+void sass_delete_import_list (Sass_Import_Entry*);
 // Just in case we have some stray import structs
-void sass_delete_import (struct Sass_Import*);
+void sass_delete_import (Sass_Import_Entry);
 ```
 
 ### More links

src/libsass/docs/api-value.md

@@ -58,7 +58,7 @@ union Sass_Value* sass_make_string  (const char* val);
 union Sass_Value* sass_make_qstring (const char* val);
 union Sass_Value* sass_make_number  (double val, const char* unit);
 union Sass_Value* sass_make_color   (double r, double g, double b, double a);
-union Sass_Value* sass_make_list    (size_t len, enum Sass_Separator sep);
+union Sass_Value* sass_make_list    (size_t len, enum Sass_Separator sep, bool is_bracketed);
 union Sass_Value* sass_make_map     (size_t len);
 union Sass_Value* sass_make_error   (const char* msg);
 union Sass_Value* sass_make_warning (const char* msg);
@@ -124,6 +124,8 @@ size_t sass_list_get_length (const union Sass_Value* v);
 // Getters and setters for Sass_List
 enum Sass_Separator sass_list_get_separator (const union Sass_Value* v);
 void sass_list_set_separator (union Sass_Value* v, enum Sass_Separator value);
+bool sass_list_get_is_bracketed (const union Sass_Value* v);
+void sass_list_set_is_bracketed (union Sass_Value* v, bool value);
 // Getters and setters for Sass_List values
 union Sass_Value* sass_list_get_value (const union Sass_Value* v, size_t i);
 void sass_list_set_value (union Sass_Value* v, size_t i, union Sass_Value* value);

src/libsass/docs/build-on-windows.md

@@ -130,7 +130,7 @@ cd libsass
 REM set PATH=%PATH%;%PROGRAMFILES%\MSBuild\12.0\Bin
 msbuild /m:4 /p:Configuration=Release win\libsass.sln
 REM running the spec test-suite manually (needs ruby and minitest gem)
-ruby sass-spec\sass-spec.rb -V 3.4 -c win\bin\sassc.exe -s --impl libsass sass-spec/spec
+ruby sass-spec\sass-spec.rb -V 3.5 -c win\bin\sassc.exe -s --impl libsass sass-spec/spec
 cd ..
 ```
 

src/libsass/docs/custom-functions-internal.md

@@ -45,14 +45,16 @@ The cookie can hold any pointer you want. In the `perl-libsass` implementation i
 
 ```C
 // allocate memory (copies passed strings)
-union Sass_Value* make_sass_boolean (int val);
-union Sass_Value* make_sass_number  (double val, const char* unit);
-union Sass_Value* make_sass_color   (double r, double g, double b, double a);
-union Sass_Value* make_sass_string  (const char* val);
-union Sass_Value* make_sass_list    (size_t len, enum Sass_Separator sep);
-union Sass_Value* make_sass_map     (size_t len);
-union Sass_Value* make_sass_null    ();
-union Sass_Value* make_sass_error   (const char* msg);
+union Sass_Value* sass_make_null    (void);
+union Sass_Value* sass_make_boolean (bool val);
+union Sass_Value* sass_make_string  (const char* val);
+union Sass_Value* sass_make_qstring (const char* val);
+union Sass_Value* sass_make_number  (double val, const char* unit);
+union Sass_Value* sass_make_color   (double r, double g, double b, double a);
+union Sass_Value* sass_make_list    (size_t len, enum Sass_Separator sep, bool is_bracketed);
+union Sass_Value* sass_make_map     (size_t len);
+union Sass_Value* sass_make_error   (const char* msg);
+union Sass_Value* sass_make_warning (const char* msg);
 
 // Make a deep cloned copy of the given sass value
 union Sass_Value* sass_clone_value (const union Sass_Value* val);

src/libsass/include/sass/base.h

@@ -75,9 +75,6 @@ ADDAPI void ADDCALL sass_free_memory(void* ptr);
 ADDAPI char* ADDCALL sass_string_quote (const char* str, const char quote_mark);
 ADDAPI char* ADDCALL sass_string_unquote (const char* str);
 
-// Resolve a file via the given include paths in the include char* array
-ADDAPI char* ADDCALL sass_resolve_file (const char* path, const char* incs[]);
-
 // Implemented sass language version
 // Hardcoded version 3.4 for time being
 ADDAPI const char* ADDCALL libsass_version(void);

src/libsass/include/sass/context.h

@@ -81,8 +81,6 @@ ADDAPI const char* ADDCALL sass_option_get_indent (struct Sass_Options* options)
 ADDAPI const char* ADDCALL sass_option_get_linefeed (struct Sass_Options* options);
 ADDAPI const char* ADDCALL sass_option_get_input_path (struct Sass_Options* options);
 ADDAPI const char* ADDCALL sass_option_get_output_path (struct Sass_Options* options);
-ADDAPI const char* ADDCALL sass_option_get_plugin_path (struct Sass_Options* options);
-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_Importer_List ADDCALL sass_option_get_c_headers (struct Sass_Options* options);
@@ -124,6 +122,10 @@ ADDAPI size_t ADDCALL sass_context_get_error_column (struct Sass_Context* ctx);
 ADDAPI const char* ADDCALL sass_context_get_source_map_string (struct Sass_Context* ctx);
 ADDAPI char** ADDCALL sass_context_get_included_files (struct Sass_Context* ctx);
 
+// Getters for options include path array
+ADDAPI size_t ADDCALL sass_option_get_include_path_size(struct Sass_Options* options);
+ADDAPI const char* ADDCALL sass_option_get_include_path(struct Sass_Options* options, size_t i);
+
 // Calculate the size of the stored null terminated array
 ADDAPI size_t ADDCALL sass_context_get_included_files_size (struct Sass_Context* ctx);
 
@@ -143,11 +145,24 @@ ADDAPI struct Sass_Options* ADDCALL sass_compiler_get_options(struct Sass_Compil
 ADDAPI size_t ADDCALL sass_compiler_get_import_stack_size(struct Sass_Compiler* compiler);
 ADDAPI Sass_Import_Entry ADDCALL sass_compiler_get_last_import(struct Sass_Compiler* compiler);
 ADDAPI Sass_Import_Entry ADDCALL sass_compiler_get_import_entry(struct Sass_Compiler* compiler, size_t idx);
+ADDAPI size_t ADDCALL sass_compiler_get_callee_stack_size(struct Sass_Compiler* compiler);
+ADDAPI Sass_Callee_Entry ADDCALL sass_compiler_get_last_callee(struct Sass_Compiler* compiler);
+ADDAPI Sass_Callee_Entry ADDCALL sass_compiler_get_callee_entry(struct Sass_Compiler* compiler, size_t idx);
 
 // Push function for paths (no manipulation support for now)
 ADDAPI void ADDCALL sass_option_push_plugin_path (struct Sass_Options* options, const char* path);
 ADDAPI void ADDCALL sass_option_push_include_path (struct Sass_Options* options, const char* path);
 
+// Resolve a file via the given include paths in the sass option struct
+// find_file looks for the exact file name while find_include does a regular sass include
+ADDAPI char* ADDCALL sass_find_file (const char* path, struct Sass_Options* opt);
+ADDAPI char* ADDCALL sass_find_include (const char* path, struct Sass_Options* opt);
+
+// Resolve a file relative to last import or include paths in the sass option struct
+// find_file looks for the exact file name while find_include does a regular sass include
+ADDAPI char* ADDCALL sass_compiler_find_file (const char* path, struct Sass_Compiler* compiler);
+ADDAPI char* ADDCALL sass_compiler_find_include (const char* path, struct Sass_Compiler* compiler);
+
 #ifdef __cplusplus
 } // __cplusplus defined.
 #endif

src/libsass/include/sass/functions.h

@@ -11,12 +11,18 @@ extern "C" {
 
 
 // Forward declaration
+struct Sass_Env;
+struct Sass_Callee;
 struct Sass_Import;
 struct Sass_Options;
 struct Sass_Compiler;
 struct Sass_Importer;
 struct Sass_Function;
 
+// Typedef helpers for callee lists
+typedef struct Sass_Env (*Sass_Env_Frame);
+// Typedef helpers for callee lists
+typedef struct Sass_Callee (*Sass_Callee_Entry);
 // Typedef helpers for import lists
 typedef struct Sass_Import (*Sass_Import_Entry);
 typedef struct Sass_Import* (*Sass_Import_List);
@@ -34,11 +40,18 @@ typedef struct Sass_Function* (*Sass_Function_List);
 typedef union Sass_Value* (*Sass_Function_Fn)
   (const union Sass_Value*, Sass_Function_Entry cb, struct Sass_Compiler* compiler);
 
+// Type of function calls
+enum Sass_Callee_Type {
+  SASS_CALLEE_MIXIN,
+  SASS_CALLEE_FUNCTION,
+  SASS_CALLEE_C_FUNCTION,
+};
 
 // Creator for sass custom importer return argument list
 ADDAPI Sass_Importer_List ADDCALL sass_make_importer_list (size_t length);
 ADDAPI Sass_Importer_Entry ADDCALL sass_importer_get_list_entry (Sass_Importer_List list, size_t idx);
 ADDAPI void ADDCALL sass_importer_set_list_entry (Sass_Importer_List list, size_t idx, Sass_Importer_Entry entry);
+ADDAPI void ADDCALL sass_delete_importer_list (Sass_Importer_List list);
 
 
 // Creators for custom importer callback (with some additional pointer)
@@ -66,6 +79,22 @@ ADDAPI Sass_Import_Entry ADDCALL sass_import_set_error(Sass_Import_Entry import,
 ADDAPI void ADDCALL sass_import_set_list_entry (Sass_Import_List list, size_t idx, Sass_Import_Entry entry);
 ADDAPI Sass_Import_Entry ADDCALL sass_import_get_list_entry (Sass_Import_List list, size_t idx);
 
+// Getters for callee entry
+ADDAPI const char* ADDCALL sass_callee_get_name (Sass_Callee_Entry);
+ADDAPI const char* ADDCALL sass_callee_get_path (Sass_Callee_Entry);
+ADDAPI size_t ADDCALL sass_callee_get_line (Sass_Callee_Entry);
+ADDAPI size_t ADDCALL sass_callee_get_column (Sass_Callee_Entry);
+ADDAPI enum Sass_Callee_Type ADDCALL sass_callee_get_type (Sass_Callee_Entry);
+ADDAPI Sass_Env_Frame ADDCALL sass_callee_get_env (Sass_Callee_Entry);
+
+// Getters and Setters for environments (lexical, local and global)
+ADDAPI union Sass_Value* ADDCALL sass_env_get_lexical (Sass_Env_Frame, const char*);
+ADDAPI void ADDCALL sass_env_set_lexical (Sass_Env_Frame, const char*, union Sass_Value*);
+ADDAPI union Sass_Value* ADDCALL sass_env_get_local (Sass_Env_Frame, const char*);
+ADDAPI void ADDCALL sass_env_set_local (Sass_Env_Frame, const char*, union Sass_Value*);
+ADDAPI union Sass_Value* ADDCALL sass_env_get_global (Sass_Env_Frame, const char*);
+ADDAPI void ADDCALL sass_env_set_global (Sass_Env_Frame, const char*, union Sass_Value*);
+
 // Getters for import entry
 ADDAPI const char* ADDCALL sass_import_get_imp_path (Sass_Import_Entry);
 ADDAPI const char* ADDCALL sass_import_get_abs_path (Sass_Import_Entry);
@@ -90,6 +119,8 @@ ADDAPI void ADDCALL sass_delete_import (Sass_Import_Entry);
 // Creators for sass function list and function descriptors
 ADDAPI Sass_Function_List ADDCALL sass_make_function_list (size_t length);
 ADDAPI Sass_Function_Entry ADDCALL sass_make_function (const char* signature, Sass_Function_Fn cb, void* cookie);
+ADDAPI void ADDCALL sass_delete_function (Sass_Function_Entry entry);
+ADDAPI void ADDCALL sass_delete_function_list (Sass_Function_List list);
 
 // Setters and getters for callbacks on function lists
 ADDAPI Sass_Function_Entry ADDCALL sass_function_get_list_entry(Sass_Function_List list, size_t pos);

src/libsass/include/sass/values.h

@@ -50,7 +50,7 @@ ADDAPI union Sass_Value* ADDCALL sass_make_string  (const char* val);
 ADDAPI union Sass_Value* ADDCALL sass_make_qstring (const char* val);
 ADDAPI union Sass_Value* ADDCALL sass_make_number  (double val, const char* unit);
 ADDAPI union Sass_Value* ADDCALL sass_make_color   (double r, double g, double b, double a);
-ADDAPI union Sass_Value* ADDCALL sass_make_list    (size_t len, enum Sass_Separator sep);
+ADDAPI union Sass_Value* ADDCALL sass_make_list    (size_t len, enum Sass_Separator sep, bool is_bracketed);
 ADDAPI union Sass_Value* ADDCALL sass_make_map     (size_t len);
 ADDAPI union Sass_Value* ADDCALL sass_make_error   (const char* msg);
 ADDAPI union Sass_Value* ADDCALL sass_make_warning (const char* msg);
@@ -116,6 +116,8 @@ ADDAPI size_t ADDCALL sass_list_get_length (const union Sass_Value* v);
 // Getters and setters for Sass_List
 ADDAPI enum Sass_Separator ADDCALL sass_list_get_separator (const union Sass_Value* v);
 ADDAPI void ADDCALL sass_list_set_separator (union Sass_Value* v, enum Sass_Separator value);
+ADDAPI bool ADDCALL sass_list_get_is_bracketed (const union Sass_Value* v);
+ADDAPI void ADDCALL sass_list_set_is_bracketed (union Sass_Value* v, bool value);
 // Getters and setters for Sass_List values
 ADDAPI union Sass_Value* ADDCALL sass_list_get_value (const union Sass_Value* v, size_t i);
 ADDAPI void ADDCALL sass_list_set_value (union Sass_Value* v, size_t i, union Sass_Value* value);

src/libsass/include/sass/version.h

@@ -6,7 +6,7 @@
 #endif
 
 #ifndef LIBSASS_LANGUAGE_VERSION
-#define LIBSASS_LANGUAGE_VERSION "3.4"
+#define LIBSASS_LANGUAGE_VERSION "3.5"
 #endif
 
 #endif

src/libsass/include/sass/version.h.in

@@ -6,7 +6,7 @@
 #endif
 
 #ifndef LIBSASS_LANGUAGE_VERSION
-#define LIBSASS_LANGUAGE_VERSION "3.4"
+#define LIBSASS_LANGUAGE_VERSION "3.5"
 #endif
 
 #endif

src/libsass/script/ci-build-libsass

@@ -18,9 +18,14 @@ if [ "x$TRAVIS_OS_NAME" == "x" ]; then export TRAVIS_OS_NAME=`uname -s | perl -n
 
 if [ "x$COVERAGE" == "xyes" ]; then
   COVERAGE_OPT="--enable-coverage"
-  export EXTRA_CFLAGS="--coverage"
-  export EXTRA_CXXFLAGS="--coverage"
+  export EXTRA_CFLAGS="-fprofile-arcs -ftest-coverage"
+  export EXTRA_CXXFLAGS="-fprofile-arcs -ftest-coverage"
+  if [ "$TRAVIS_OS_NAME" == "osx" ]; then
+    # osx doesn't seem to know gcov lib?
     export EXTRA_LDFLAGS="--coverage"
+  else
+    export EXTRA_LDFLAGS="-lgcov --coverage"
+  fi
 else
   COVERAGE_OPT="--disable-coverage"
 fi
@@ -37,7 +42,7 @@ fi
 if [ "$(expr substr $(uname -s) 1 10)" == "MINGW32_NT" ]; then
   MAKE_OPTS="$MAKE_OPTS -j1 V=1"
 else
-  MAKE_OPTS="$MAKE_OPTS -j3 V=1"
+  MAKE_OPTS="$MAKE_OPTS -j5 V=1"
 fi
 
 if [ "x$PREFIX" == "x" ]; then

src/libsass/script/ci-build-plugin

+#!/bin/bash
+
+PLUGIN=$1
+RUBY_BIN=ruby
+SASS_SPEC_PATH=sass-spec
+SASSC_BIN=sassc/bin/sassc
+SASS_SPEC_SPEC_DIR=plugins/libsass-${PLUGIN}/test
+
+if [ -e ./tester ] ; then
+  SASSC_BIN=./tester
+fi
+
+if [ -d ./build/lib ] ; then
+  cp -a build/lib lib
+fi
+
+if [ "x$1" == "x" ] ; then
+  echo "No plugin name given"
+  exit 1
+fi
+
+if [ "x$COVERAGE" == "0" ] ; then
+  unset COVERAGE
+fi
+
+export EXTRA_CFLAGS=""
+export EXTRA_CXXFLAGS=""
+if [ "$TRAVIS_OS_NAME" == "osx" ]; then
+  # osx doesn't seem to know gcov lib?
+  export EXTRA_LDFLAGS="--coverage"
+else
+  export EXTRA_LDFLAGS="-lgcov --coverage"
+fi
+
+mkdir -p plugins
+if [ ! -d plugins/libsass-${PLUGIN} ] ; then
+  git clone https://github.com/mgreter/libsass-${PLUGIN} plugins/libsass-${PLUGIN}
+fi
+if [ ! -d plugins/libsass-${PLUGIN}/build ] ; then
+  mkdir plugins/libsass-${PLUGIN}/build
+fi
+RETVAL=$?; if [ "$RETVAL" != "0" ]; then exit $RETVAL; fi
+
+cd plugins/libsass-${PLUGIN}/build
+cmake -G "Unix Makefiles" -D LIBSASS_DIR="../../.." ..
+RETVAL=$?; if [ "$RETVAL" != "0" ]; then exit $RETVAL; fi
+make VERBOSE=1 -j2
+RETVAL=$?; if [ "$RETVAL" != "0" ]; then exit $RETVAL; fi
+cd ../../..
+
+# glob only works on paths relative to imports
+if [ "x$PLUGIN" == "xglob" ]; then
+  ${SASSC_BIN} --plugin-path plugins/libsass-${PLUGIN}/build ${SASS_SPEC_SPEC_DIR}/basic/input.scss > ${SASS_SPEC_SPEC_DIR}/basic/result.css
+  ${SASSC_BIN} --plugin-path plugins/libsass-${PLUGIN}/build ${SASS_SPEC_SPEC_DIR}/basic/input.scss --sourcemap > /dev/null
+else
+  cat ${SASS_SPEC_SPEC_DIR}/basic/input.scss | ${SASSC_BIN} --plugin-path plugins/libsass-${PLUGIN}/build -I ${SASS_SPEC_SPEC_DIR}/basic > ${SASS_SPEC_SPEC_DIR}/basic/result.css
+  cat ${SASS_SPEC_SPEC_DIR}/basic/input.scss | ${SASSC_BIN} --plugin-path plugins/libsass-${PLUGIN}/build -I ${SASS_SPEC_SPEC_DIR}/basic --sourcemap > /dev/null
+fi
+RETVAL=$?; if [ "$RETVAL" != "0" ]; then exit $RETVAL; fi
+
+diff ${SASS_SPEC_SPEC_DIR}/basic/expected_output.css ${SASS_SPEC_SPEC_DIR}/basic/result.css
+RETVAL=$?; if [ "$RETVAL" != "0" ]; then exit $RETVAL; fi

src/libsass/script/ci-report-coverage

@@ -2,6 +2,12 @@
 
 if [ "x$COVERAGE" = "xyes" ]; then
 
+  # find / -name "gcovr"
+  # find / -name "coveralls"
+  # this is only needed for mac os x builds!
+  PATH=$PATH:/Users/travis/Library/Python/2.7/bin/
+
+
   # exclude some directories from profiling (.libs is from autotools)
   export EXCLUDE_COVERAGE="--exclude plugins
                            --exclude sassc/sassc.c
@@ -21,10 +27,14 @@ if [ "x$COVERAGE" = "xyes" ]; then
                            --exclude src/test
                            --exclude src/posix
                            --exclude src/debugger.hpp"
-  # debug via gcovr
+  # debug used gcov version
+  # option not available on mac
+  if [ "$TRAVIS_OS_NAME" != "osx" ]; then
     gcov -v
+  fi
+  # create summarized report
   gcovr -r .
-  # generate and submit report to coveralls.io
+  # submit report to coveralls.io
   coveralls $EXCLUDE_COVERAGE --gcov-options '\-lp'
 
 else

src/libsass/src/GNUmakefile.am

@@ -34,7 +34,7 @@ include $(top_srcdir)/Makefile.conf
 
 libsass_la_SOURCES = ${CSOURCES} ${SOURCES}
 
-libsass_la_LDFLAGS = $(AM_LDFLAGS) -no-undefined -version-info 0:9:0
+libsass_la_LDFLAGS = $(AM_LDFLAGS) -no-undefined -version-info 1:0:0
 
 if ENABLE_TESTS
 if ENABLE_COVERAGE

src/libsass/src/ast_def_macros.hpp

@@ -44,7 +44,7 @@ public:\
   type name(type name##__) { return name##_ = name##__; }\
 private:
 
-#define ADD_HASHED(type, name)\
+#define HASH_PROPERTY(type, name)\
 protected:\
   type name##_;\
 public:\
@@ -52,4 +52,20 @@ public:\
   type name(type name##__) { hash_ = 0; return name##_ = name##__; }\
 private:
 
+#define ADD_CONSTREF(type, name) \
+protected: \
+  type name##_; \
+public: \
+  const type& name() const { return name##_; } \
+  void name(type name##__) { name##_ = name##__; } \
+private:
+
+#define HASH_CONSTREF(type, name) \
+protected: \
+  type name##_; \
+public: \
+  const type& name() const { return name##_; } \
+  void name(type name##__) { hash_ = 0; name##_ = name##__; } \
+private:
+
 #endif

src/libsass/src/ast_fwd_decl.cpp

+#include "ast.hpp"
+
+namespace Sass {
+
+  #define IMPLEMENT_BASE_CAST(T) \
+  template<> \
+  T* Cast(AST_Node* ptr) { \
+    return dynamic_cast<T*>(ptr); \
+  }; \
+  \
+  template<> \
+  const T* Cast(const AST_Node* ptr) { \
+    return dynamic_cast<const T*>(ptr); \
+  }; \
+
+  IMPLEMENT_BASE_CAST(AST_Node)
+  IMPLEMENT_BASE_CAST(Expression)
+  IMPLEMENT_BASE_CAST(Statement)
+  IMPLEMENT_BASE_CAST(Has_Block)
+  IMPLEMENT_BASE_CAST(PreValue)
+  IMPLEMENT_BASE_CAST(Value)
+  IMPLEMENT_BASE_CAST(List)
+  IMPLEMENT_BASE_CAST(String)
+  IMPLEMENT_BASE_CAST(String_Constant)
+  IMPLEMENT_BASE_CAST(Supports_Condition)
+  IMPLEMENT_BASE_CAST(Selector)
+  IMPLEMENT_BASE_CAST(Simple_Selector)
+
+}

src/libsass/src/ast_fwd_decl.hpp

 #ifndef SASS_AST_FWD_DECL_H
 #define SASS_AST_FWD_DECL_H
 
+#include <map>
+#include <set>
+#include <deque>
 #include <vector>
+#include <typeinfo>
 #include <iostream>
 #include <algorithm>
 #include <unordered_map>
@@ -353,37 +357,94 @@ namespace Sass {
   IMPL_MEM_OBJ(Complex_Selector);
   IMPL_MEM_OBJ(Selector_List);
 
+  // ###########################################################################
+  // Implement compare, order and hashing operations for AST Nodes
+  // ###########################################################################
 
-  struct HashExpression {
-    size_t operator() (Expression_Obj ex) const;
+  struct HashNodes {
+    template <class T>
+    size_t operator() (const T& ex) const {
+      return ex.isNull() ? 0 : ex->hash();
+    }
   };
-  struct CompareExpression {
-    bool operator()(const Expression_Obj& lhs, const Expression_Obj& rhs) const;
+  struct OrderNodes {
+    template <class T>
+    bool operator() (const T& lhs, const T& rhs) const {
+      return !lhs.isNull() && !rhs.isNull() && *lhs < *rhs;
+    }
   };
-
-  struct HashSimpleSelector {
-    size_t operator() (Simple_Selector_Obj ex) const;
+  struct CompareNodes {
+    template <class T>
+    bool operator() (const T& lhs, const T& rhs) const {
+      return !lhs.isNull() && !rhs.isNull() && *lhs == *rhs;
+    }
   };
 
-  struct CompareSimpleSelector {
-    bool operator()(Simple_Selector_Obj lhs, Simple_Selector_Obj rhs) const;
-  };
+  // ###########################################################################
+  // some often used typedefs
+  // ###########################################################################
 
   typedef std::unordered_map<
     Expression_Obj, // key
     Expression_Obj, // value
-    HashExpression, // hasher
-    CompareExpression // compare
+    HashNodes, // hasher
+    CompareNodes // compare
   > ExpressionMap;
   typedef std::unordered_set<
     Expression_Obj, // value
-    HashExpression, // hasher
-    CompareExpression // compare
+    HashNodes, // hasher
+    CompareNodes // compare
   > ExpressionSet;
 
-  typedef std::string Subset_Map_Key;
-  typedef std::vector<size_t> Subset_Map_Arr;
-  typedef std::pair<Complex_Selector_Obj, Compound_Selector_Obj> Subset_Map_Val;
+  typedef std::string SubSetMapKey;
+  typedef std::vector<std::string> SubSetMapKeys;
+
+  typedef std::pair<Complex_Selector_Obj, Compound_Selector_Obj> SubSetMapPair;
+  typedef std::pair<Compound_Selector_Obj, Complex_Selector_Obj> SubSetMapLookup;
+  typedef std::vector<SubSetMapPair> SubSetMapPairs;
+  typedef std::vector<SubSetMapLookup> SubSetMapLookups;
+
+  typedef std::pair<Complex_Selector_Obj, SubSetMapPairs> SubSetMapResult;
+  typedef std::vector<SubSetMapResult> SubSetMapResults;
+
+  typedef std::deque<Complex_Selector_Obj> ComplexSelectorDeque;
+  typedef std::set<Simple_Selector_Obj, OrderNodes> SimpleSelectorSet;
+  typedef std::set<Complex_Selector_Obj, OrderNodes> ComplexSelectorSet;
+  typedef std::unordered_set<Simple_Selector_Obj, HashNodes, CompareNodes> SimpleSelectorDict;
+
+  // ###########################################################################
+  // explicit type conversion functions
+  // ###########################################################################
+
+  template<class T>
+  T* Cast(AST_Node* ptr);
+
+  template<class T>
+  const T* Cast(const AST_Node* ptr);
+
+  // sometimes you know the class you want to cast to is final
+  // in this case a simple typeid check is faster and safe to use
+
+  #define DECLARE_BASE_CAST(T) \
+  template<> T* Cast(AST_Node* ptr); \
+  template<> const T* Cast(const AST_Node* ptr); \
+
+  // ###########################################################################
+  // implement specialization for final classes
+  // ###########################################################################
+
+  DECLARE_BASE_CAST(AST_Node)
+  DECLARE_BASE_CAST(Expression)
+  DECLARE_BASE_CAST(Statement)
+  DECLARE_BASE_CAST(Has_Block)
+  DECLARE_BASE_CAST(PreValue)
+  DECLARE_BASE_CAST(Value)
+  DECLARE_BASE_CAST(List)
+  DECLARE_BASE_CAST(String)
+  DECLARE_BASE_CAST(String_Constant)
+  DECLARE_BASE_CAST(Supports_Condition)
+  DECLARE_BASE_CAST(Selector)
+  DECLARE_BASE_CAST(Simple_Selector)
 
 }
 

src/libsass/src/backtrace.hpp

@@ -21,7 +21,7 @@ namespace Sass {
       caller(c)
     { }
 
-    std::string to_string(bool warning = false)
+    const std::string to_string(bool warning = false)
     {
       size_t i = -1;
       std::stringstream ss;

src/libsass/src/bind.cpp

@@ -16,7 +16,7 @@ namespace Sass {
     std::map<std::string, Parameter_Obj> param_map;
 
     for (size_t i = 0, L = as->length(); i < L; ++i) {
-      if (auto str = SASS_MEMORY_CAST(String_Quoted, (*as)[i]->value())) {
+      if (auto str = Cast<String_Quoted>((*as)[i]->value())) {
         // force optional quotes (only if needed)
         if (str->quote_mark()) {
           str->quote_mark('*');
@@ -42,7 +42,7 @@ namespace Sass {
       if (ip >= LP) {
         // skip empty rest arguments
         if (a->is_rest_argument()) {
-          if (List_Obj l = SASS_MEMORY_CAST(List, a->value())) {
+          if (List_Obj l = Cast<List>(a->value())) {
             if (l->length() == 0) {
               ++ ia; continue;
             }
@@ -61,7 +61,7 @@ namespace Sass {
         if (a->is_rest_argument()) {
 
           // We should always get a list for rest arguments
-          if (List_Obj rest = SASS_MEMORY_CAST(List, a->value())) {
+          if (List_Obj rest = Cast<List>(a->value())) {
               // create a new list object for wrapped items
               List_Ptr arglist = SASS_MEMORY_NEW(List,
                                               p->pstate(),
@@ -70,12 +70,12 @@ namespace Sass {
                                               true);
               // wrap each item from list as an argument
               for (Expression_Obj item : rest->elements()) {
-                if (Argument_Obj arg = SASS_MEMORY_CAST(Argument, item)) {
+                if (Argument_Obj arg = Cast<Argument>(item)) {
                   arglist->append(SASS_MEMORY_COPY(arg)); // copy
                 } else {
                   arglist->append(SASS_MEMORY_NEW(Argument,
                                                   item->pstate(),
-                                                  &item,
+                                                  item,
                                                   "",
                                                   false,
                                                   false));
@@ -93,9 +93,9 @@ namespace Sass {
           // expand keyword arguments into their parameters
           List_Ptr arglist = SASS_MEMORY_NEW(List, p->pstate(), 0, SASS_COMMA, true);
           env->local_frame()[p->name()] = arglist;
-          Map_Obj argmap = SASS_MEMORY_CAST(Map, a->value());
+          Map_Obj argmap = Cast<Map>(a->value());
           for (auto key : argmap->keys()) {
-            std::string name = unquote(SASS_MEMORY_CAST(String_Constant, key)->value());
+            std::string name = unquote(Cast<String_Constant>(key)->value());
             arglist->append(SASS_MEMORY_NEW(Argument,
                                             key->pstate(),
                                             argmap->at(key),
@@ -117,25 +117,25 @@ namespace Sass {
             // get and post inc
             a = (*as)[ia++];
             // maybe we have another list as argument
-            List_Obj ls = SASS_MEMORY_CAST(List, a->value());
+            List_Obj ls = Cast<List>(a->value());
             // skip any list completely if empty
             if (ls && ls->empty() && a->is_rest_argument()) continue;
 
             Expression_Obj value = a->value();
-            if (Argument_Obj arg = SASS_MEMORY_CAST(Argument, value)) {
-              arglist->append(&arg);
+            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 = SASS_MEMORY_CAST(List, a->value())) {
+              if (List_Obj rest = Cast<List>(a->value())) {
                 arglist->separator(rest->separator());
 
                 for (size_t i = 0, L = rest->size(); i < L; ++i) {
                   Expression_Obj obj = rest->at(i);
                   arglist->append(SASS_MEMORY_NEW(Argument,
                                                 obj->pstate(),
-                                                &obj,
+                                                obj,
                                                 "",
                                                 false,
                                                 false));
@@ -155,7 +155,7 @@ namespace Sass {
             }
           }
           // assign new arglist to environment
-          env->local_frame()[p->name()] = &arglist;
+          env->local_frame()[p->name()] = arglist;
         }
         // consumed parameter
         ++ip;
@@ -166,7 +166,7 @@ namespace Sass {
       // 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 = SASS_MEMORY_CAST(List, a->value());
+        List_Obj arglist = Cast<List>(a->value());
         // empty rest arg - treat all args as default values
         if (!arglist->length()) {
           break;
@@ -187,8 +187,8 @@ namespace Sass {
         }
         // otherwise move one of the rest args into the param, converting to argument if necessary
         Expression_Obj obj = arglist->at(0);
-        if (!(a = SASS_MEMORY_CAST(Argument, obj))) {
-          Expression_Ptr a_to_convert = &obj;
+        if (!(a = Cast<Argument>(obj))) {
+          Expression_Ptr a_to_convert = obj;
           a = SASS_MEMORY_NEW(Argument,
                               a_to_convert->pstate(),
                               a_to_convert,
@@ -202,17 +202,17 @@ namespace Sass {
         }
 
       } else if (a->is_keyword_argument()) {
-        Map_Obj argmap = SASS_MEMORY_CAST(Map, a->value());
+        Map_Obj argmap = Cast<Map>(a->value());
 
         for (auto key : argmap->keys()) {
-          std::string name = "$" + unquote(SASS_MEMORY_CAST(String_Constant, key)->value());
+          std::string name = "$" + unquote(Cast<String_Constant>(key)->value());
 
           if (!param_map.count(name)) {
             std::stringstream msg;
             msg << callee << " has no parameter named " << name;
             error(msg.str(), a->pstate());
           }
-          env->local_frame()[name] = &argmap->at(&key);
+          env->local_frame()[name] = argmap->at(key);
         }
         ++ia;
         continue;
@@ -228,7 +228,7 @@ namespace Sass {
           error(msg.str(), a->pstate());
         }
         // ordinal arg -- bind it to the next param
-        env->local_frame()[p->name()] = &a->value();
+        env->local_frame()[p->name()] = a->value();
         ++ip;
       }
       else {
@@ -250,7 +250,7 @@ namespace Sass {
               << "provided more than once in call to " << callee;
           error(msg.str(), a->pstate());
         }
-        env->local_frame()[a->name()] = &a->value();
+        env->local_frame()[a->name()] = a->value();
       }
     }
     // EO while ia

src/libsass/src/bind.hpp

@@ -6,7 +6,6 @@
 #include "ast_fwd_decl.hpp"
 
 namespace Sass {
-  typedef Environment<AST_Node_Obj> Env;
 
   void bind(std::string type, std::string name, Parameters_Obj, Arguments_Obj, Context*, Env*, Eval*);
 }

src/libsass/src/check_nesting.cpp

@@ -15,7 +15,7 @@ namespace Sass {
   {
     Statement_Ptr old_parent = this->parent;
 
-    if (At_Root_Block_Ptr root = SASS_MEMORY_CAST_PTR(At_Root_Block, parent)) {
+    if (At_Root_Block_Ptr root = Cast<At_Root_Block>(parent)) {
       std::vector<Statement_Ptr> old_parents = this->parents;
       std::vector<Statement_Ptr> new_parents;
 
@@ -39,8 +39,8 @@ namespace Sass {
         }
       }
 
-      At_Root_Block_Ptr ar = SASS_MEMORY_CAST_PTR(At_Root_Block, parent);
-      Statement_Ptr ret = this->visit_children(&ar->block());
+      At_Root_Block_Ptr ar = Cast<At_Root_Block>(parent);
+      Statement_Ptr ret = this->visit_children(ar->block());
 
       this->parent = old_parent;
       this->parents = old_parents;
@@ -54,11 +54,11 @@ namespace Sass {
 
     this->parents.push_back(parent);
 
-    Block_Ptr b = SASS_MEMORY_CAST_PTR(Block, parent);
+    Block_Ptr b = Cast<Block>(parent);
 
     if (!b) {
-      if (Has_Block_Ptr bb = SASS_MEMORY_CAST(Has_Block, *parent)) {
-        b = &bb->block();
+      if (Has_Block_Ptr bb = Cast<Has_Block>(parent)) {
+        b = bb->block();
       }
     }
 
@@ -99,8 +99,8 @@ namespace Sass {
 
   Statement_Ptr CheckNesting::fallback_impl(Statement_Ptr s)
   {
-    Block_Ptr b1 = SASS_MEMORY_CAST_PTR(Block, s);
-    Has_Block_Ptr b2 = SASS_MEMORY_CAST_PTR(Has_Block, s);
+    Block_Ptr b1 = Cast<Block>(s);
+    Has_Block_Ptr b2 = Cast<Has_Block>(s);
     return b1 || b2 ? visit_children(s) : s;
   }
 
@@ -108,16 +108,16 @@ namespace Sass {
   {
     if (!this->parent) return true;
 
-    if (SASS_MEMORY_CAST_PTR(Content, node))
+    if (Cast<Content>(node))
     { this->invalid_content_parent(this->parent); }
 
     if (is_charset(node))
     { this->invalid_charset_parent(this->parent); }
 
-    if (SASS_MEMORY_CAST_PTR(Extension, node))
+    if (Cast<Extension>(node))
     { this->invalid_extend_parent(this->parent); }
 
-    // if (SASS_MEMORY_CAST(Import, node))
+    // if (Cast<Import>(node))
     // { this->invalid_import_parent(this->parent); }
 
     if (this->is_mixin(node))
@@ -129,13 +129,13 @@ namespace Sass {
     if (this->is_function(this->parent))
     { this->invalid_function_child(node); }
 
-    if (SASS_MEMORY_CAST_PTR(Declaration, node))
+    if (Cast<Declaration>(node))
     { this->invalid_prop_parent(this->parent); }
 
-    if (SASS_MEMORY_CAST_PTR(Declaration, this->parent))
+    if (Cast<Declaration>(this->parent))
     { this->invalid_prop_child(node); }
 
-    if (SASS_MEMORY_CAST_PTR(Return, node))
+    if (Cast<Return>(node))
     { this->invalid_return_parent(this->parent); }
 
     return true;
@@ -166,8 +166,8 @@ namespace Sass {
   void CheckNesting::invalid_extend_parent(Statement_Ptr parent)
   {
     if (!(
-        SASS_MEMORY_CAST_PTR(Ruleset, parent) ||
-        SASS_MEMORY_CAST_PTR(Mixin_Call, parent) ||
+        Cast<Ruleset>(parent) ||
+        Cast<Mixin_Call>(parent) ||
         is_mixin(parent)
     )) {
       throw Exception::InvalidSass(
@@ -181,12 +181,12 @@ namespace Sass {
   // {
   //   for (auto pp : this->parents) {
   //     if (
-  //         SASS_MEMORY_CAST(Each, pp) ||
-  //         SASS_MEMORY_CAST(For, pp) ||
-  //         SASS_MEMORY_CAST(If, pp) ||
-  //         SASS_MEMORY_CAST(While, pp) ||
-  //         SASS_MEMORY_CAST(Trace, pp) ||
-  //         SASS_MEMORY_CAST(Mixin_Call, pp) ||
+  //         Cast<Each>(pp) ||
+  //         Cast<For>(pp) ||
+  //         Cast<If>(pp) ||
+  //         Cast<While>(pp) ||
+  //         Cast<Trace>(pp) ||
+  //         Cast<Mixin_Call>(pp) ||
   //         is_mixin(pp)
   //     ) {
   //       throw Exception::InvalidSass(
@@ -212,12 +212,12 @@ namespace Sass {
   {
     for (Statement_Ptr pp : this->parents) {
       if (
-          SASS_MEMORY_CAST_PTR(Each, pp) ||
-          SASS_MEMORY_CAST_PTR(For, pp) ||
-          SASS_MEMORY_CAST_PTR(If, pp) ||
-          SASS_MEMORY_CAST_PTR(While, pp) ||
-          SASS_MEMORY_CAST_PTR(Trace, pp) ||
-          SASS_MEMORY_CAST_PTR(Mixin_Call, pp) ||
+          Cast<Each>(pp) ||
+          Cast<For>(pp) ||
+          Cast<If>(pp) ||
+          Cast<While>(pp) ||
+          Cast<Trace>(pp) ||
+          Cast<Mixin_Call>(pp) ||
           is_mixin(pp)
       ) {
         throw Exception::InvalidSass(
@@ -232,12 +232,12 @@ namespace Sass {
   {
     for (Statement_Ptr pp : this->parents) {
       if (
-          SASS_MEMORY_CAST_PTR(Each, pp) ||
-          SASS_MEMORY_CAST_PTR(For, pp) ||
-          SASS_MEMORY_CAST_PTR(If, pp) ||
-          SASS_MEMORY_CAST_PTR(While, pp) ||
-          SASS_MEMORY_CAST_PTR(Trace, pp) ||
-          SASS_MEMORY_CAST_PTR(Mixin_Call, pp) ||
+          Cast<Each>(pp) ||
+          Cast<For>(pp) ||
+          Cast<If>(pp) ||
+          Cast<While>(pp) ||
+          Cast<Trace>(pp) ||
+          Cast<Mixin_Call>(pp) ||
           is_mixin(pp)
       ) {
         throw Exception::InvalidSass(
@@ -251,19 +251,19 @@ namespace Sass {
   void CheckNesting::invalid_function_child(Statement_Ptr child)
   {
     if (!(
-        SASS_MEMORY_CAST_PTR(Each, child) ||
-        SASS_MEMORY_CAST_PTR(For, child) ||
-        SASS_MEMORY_CAST_PTR(If, child) ||
-        SASS_MEMORY_CAST_PTR(While, child) ||
-        SASS_MEMORY_CAST_PTR(Trace, child) ||
-        SASS_MEMORY_CAST_PTR(Comment, child) ||
-        SASS_MEMORY_CAST_PTR(Debug, child) ||
-        SASS_MEMORY_CAST_PTR(Return, child) ||
-        SASS_MEMORY_CAST_PTR(Variable, child) ||
+        Cast<Each>(child) ||
+        Cast<For>(child) ||
+        Cast<If>(child) ||
+        Cast<While>(child) ||
+        Cast<Trace>(child) ||
+        Cast<Comment>(child) ||
+        Cast<Debug>(child) ||
+        Cast<Return>(child) ||
+        Cast<Variable>(child) ||
         // Ruby Sass doesn't distinguish variables and assignments
-        SASS_MEMORY_CAST_PTR(Assignment, child) ||
-        SASS_MEMORY_CAST_PTR(Warning, child) ||
-        SASS_MEMORY_CAST_PTR(Error, child)
+        Cast<Assignment>(child) ||
+        Cast<Warning>(child) ||
+        Cast<Error>(child)
     )) {
       throw Exception::InvalidSass(
         child->pstate(),
@@ -275,14 +275,14 @@ namespace Sass {
   void CheckNesting::invalid_prop_child(Statement_Ptr child)
   {
     if (!(
-        SASS_MEMORY_CAST_PTR(Each, child) ||
-        SASS_MEMORY_CAST_PTR(For, child) ||
-        SASS_MEMORY_CAST_PTR(If, child) ||
-        SASS_MEMORY_CAST_PTR(While, child) ||
-        SASS_MEMORY_CAST_PTR(Trace, child) ||
-        SASS_MEMORY_CAST_PTR(Comment, child) ||
-        SASS_MEMORY_CAST_PTR(Declaration, child) ||
-        SASS_MEMORY_CAST_PTR(Mixin_Call, child)
+        Cast<Each>(child) ||
+        Cast<For>(child) ||
+        Cast<If>(child) ||
+        Cast<While>(child) ||
+        Cast<Trace>(child) ||
+        Cast<Comment>(child) ||
+        Cast<Declaration>(child) ||
+        Cast<Mixin_Call>(child)
     )) {
       throw Exception::InvalidSass(
         child->pstate(),
@@ -296,10 +296,10 @@ namespace Sass {
     if (!(
         is_mixin(parent) ||
         is_directive_node(parent) ||
-        SASS_MEMORY_CAST_PTR(Ruleset, parent) ||
-        SASS_MEMORY_CAST_PTR(Keyframe_Rule, parent) ||
-        SASS_MEMORY_CAST_PTR(Declaration, parent) ||
-        SASS_MEMORY_CAST_PTR(Mixin_Call, parent)
+        Cast<Ruleset>(parent) ||
+        Cast<Keyframe_Rule>(parent) ||
+        Cast<Declaration>(parent) ||
+        Cast<Mixin_Call>(parent)
     )) {
       throw Exception::InvalidSass(
         parent->pstate(),
@@ -326,51 +326,51 @@ namespace Sass {
                              !is_root_node(grandparent) &&
                              !is_at_root_node(grandparent);
 
-    return SASS_MEMORY_CAST_PTR(Import, parent) ||
-           SASS_MEMORY_CAST_PTR(Each, parent) ||
-           SASS_MEMORY_CAST_PTR(For, parent) ||
-           SASS_MEMORY_CAST_PTR(If, parent) ||
-           SASS_MEMORY_CAST_PTR(While, parent) ||
-           SASS_MEMORY_CAST_PTR(Trace, parent) ||
+    return Cast<Import>(parent) ||
+           Cast<Each>(parent) ||
+           Cast<For>(parent) ||
+           Cast<If>(parent) ||
+           Cast<While>(parent) ||
+           Cast<Trace>(parent) ||
            valid_bubble_node;
   }
 
   bool CheckNesting::is_charset(Statement_Ptr n)
   {
-    Directive_Ptr d = SASS_MEMORY_CAST_PTR(Directive, n);
+    Directive_Ptr d = Cast<Directive>(n);
     return d && d->keyword() == "charset";
   }
 
   bool CheckNesting::is_mixin(Statement_Ptr n)
   {
-    Definition_Ptr def = SASS_MEMORY_CAST_PTR(Definition, n);
+    Definition_Ptr def = Cast<Definition>(n);
     return def && def->type() == Definition::MIXIN;
   }
 
   bool CheckNesting::is_function(Statement_Ptr n)
   {
-    Definition_Ptr def = SASS_MEMORY_CAST_PTR(Definition, n);
+    Definition_Ptr def = Cast<Definition>(n);
     return def && def->type() == Definition::FUNCTION;
   }
 
   bool CheckNesting::is_root_node(Statement_Ptr n)
   {
-    if (SASS_MEMORY_CAST_PTR(Ruleset, n)) return false;
+    if (Cast<Ruleset>(n)) return false;
 
-    Block_Ptr b = SASS_MEMORY_CAST_PTR(Block, n);
+    Block_Ptr b = Cast<Block>(n);
     return b && b->is_root();
   }
 
   bool CheckNesting::is_at_root_node(Statement_Ptr n)
   {
-    return SASS_MEMORY_CAST_PTR(At_Root_Block, n) != NULL;
+    return Cast<At_Root_Block>(n) != NULL;
   }
 
   bool CheckNesting::is_directive_node(Statement_Ptr n)
   {
-    return SASS_MEMORY_CAST_PTR(Directive, n) ||
-           SASS_MEMORY_CAST_PTR(Import, n) ||
-           SASS_MEMORY_CAST_PTR(Media_Block, n) ||
-           SASS_MEMORY_CAST_PTR(Supports_Block, n);
+    return Cast<Directive>(n) ||
+           Cast<Import>(n) ||
+           Cast<Media_Block>(n) ||
+           Cast<Supports_Block>(n);
   }
 }

src/libsass/src/check_nesting.hpp

@@ -6,8 +6,6 @@
 
 namespace Sass {
 
-  typedef Environment<AST_Node_Obj> Env;
-
   class CheckNesting : public Operation_CRTP<Statement_Ptr, CheckNesting> {
 
     std::vector<Statement_Ptr>  parents;
@@ -27,7 +25,7 @@ namespace Sass {
 
     template <typename U>
     Statement_Ptr fallback(U x) {
-      Statement_Ptr n = SASS_MEMORY_CAST_PTR(Statement, x);
+      Statement_Ptr n = Cast<Statement>(x);
       if (this->should_visit(n)) {
         return fallback_impl(n);
       }

src/libsass/src/color_maps.hpp

+
 #ifndef SASS_COLOR_MAPS_H
 #define SASS_COLOR_MAPS_H
 
@@ -319,14 +320,11 @@ namespace Sass {
     extern const Color transparent;
   }
 
-  extern const std::map<const int, const char*> colors_to_names;
-  extern const std::map<const char*, Color_Ptr_Const, map_cmp_str> names_to_colors;
-
-  extern Color_Ptr_Const name_to_color(const char*);
-  extern Color_Ptr_Const name_to_color(const std::string&);
-  extern const char* color_to_name(const int);
-  extern const char* color_to_name(const Color&);
-  extern const char* color_to_name(const double);
+  Color_Ptr_Const name_to_color(const char*);
+  Color_Ptr_Const name_to_color(const std::string&);
+  const char* color_to_name(const int);
+  const char* color_to_name(const Color&);
+  const char* color_to_name(const double);
 
 }
 

src/libsass/src/context.cpp

@@ -87,8 +87,9 @@ namespace Sass {
 
   {
 
-    // add cwd to include paths
-    include_paths.push_back(CWD);
+    // Sass 3.4: The current working directory will no longer be placed onto the Sass load path by default.
+    // If you need the current working directory to be available, set SASS_PATH=. in your shell's environment.
+    // include_paths.push_back(CWD);
 
     // collect more paths from different options
     collect_include_paths(c_options.include_path);
@@ -391,8 +392,8 @@ namespace Sass {
       String_Constant_Ptr loc = SASS_MEMORY_NEW(String_Constant, pstate, unquote(load_path));
       Argument_Obj loc_arg = SASS_MEMORY_NEW(Argument, pstate, loc);
       Arguments_Obj loc_args = SASS_MEMORY_NEW(Arguments, pstate);
-      loc_args->append(&loc_arg);
-      Function_Call_Ptr new_url = SASS_MEMORY_NEW(Function_Call, pstate, "url", &loc_args);
+      loc_args->append(loc_arg);
+      Function_Call_Ptr new_url = SASS_MEMORY_NEW(Function_Call, pstate, "url", loc_args);
       imp->urls().push_back(new_url);
     }
     else {
@@ -528,11 +529,11 @@ namespace Sass {
     Import_Obj imp = SASS_MEMORY_NEW(Import, pstate);
     // dispatch headers which will add custom functions
     // custom headers are added to the import instance
-    call_headers(entry_path, ctx_path, pstate, &imp);
+    call_headers(entry_path, ctx_path, pstate, imp);
     // increase head count to skip later
     head_imports += resources.size() - 1;
     // add the statement if we have urls
-    if (!imp->urls().empty()) root->append(&imp);
+    if (!imp->urls().empty()) root->append(imp);
     // process all other resources (add Import_Stub nodes)
     for (size_t i = 0, S = imp->incs().size(); i < S; ++i) {
       root->append(SASS_MEMORY_NEW(Import_Stub, pstate, imp->incs()[i]));
@@ -650,24 +651,24 @@ namespace Sass {
     Cssize cssize(*this, &backtrace);
     CheckNesting check_nesting;
     // check nesting
-    check_nesting(&root);
+    check_nesting(root);
     // expand and eval the tree
-    root = expand(&root);
+    root = expand(root);
     // check nesting
-    check_nesting(&root);
+    check_nesting(root);
     // merge and bubble certain rules
-    root = cssize(&root);
+    root = cssize(root);
     // should we extend something?
     if (!subset_map.empty()) {
       // create crtp visitor object
       Extend extend(*this, subset_map);
       // extend tree nodes
-      extend(&root);
+      extend(root);
     }
 
     // clean up by removing empty placeholders
     // ToDo: maybe we can do this somewhere else?
-    Remove_Placeholders remove_placeholders(*this);
+    Remove_Placeholders remove_placeholders;
     root->perform(&remove_placeholders);
     // return processed tree
     return root;
@@ -810,6 +811,7 @@ namespace Sass {
     register_function(ctx, append_sig, append, env);
     register_function(ctx, zip_sig, zip, env);
     register_function(ctx, list_separator_sig, list_separator, env);
+    register_function(ctx, is_bracketed_sig, is_bracketed, env);
     // Map Functions
     register_function(ctx, map_get_sig, map_get, env);
     register_function(ctx, map_merge_sig, map_merge, env);

src/libsass/src/context.hpp

@@ -50,6 +50,7 @@ namespace Sass {
     std::map<const std::string, StyleSheet> sheets;
     Subset_Map subset_map;
     std::vector<Sass_Import_Entry> import_stack;
+    std::vector<Sass_Callee> callee_stack;
 
     struct Sass_Compiler* c_compiler;
 

src/libsass/src/cssize.hpp

@@ -8,7 +8,6 @@
 
 namespace Sass {
 
-  typedef Environment<AST_Node_Obj> Env;
   struct Backtrace;
 
   class Cssize : public Operation_CRTP<Statement_Ptr, Cssize> {

src/libsass/src/environment.cpp

@@ -179,7 +179,7 @@ namespace Sass {
     for (typename std::map<std::string, T>::iterator i = local_frame_.begin(); i != local_frame_.end(); ++i) {
       if (!ends_with(i->first, "[f]") && !ends_with(i->first, "[f]4") && !ends_with(i->first, "[f]2")) {
         std::cerr << prefix << std::string(indent, ' ') << i->first << " " << i->second;
-        if (Value_Ptr val = SASS_MEMORY_CAST_PTR(Value, i->second))
+        if (Value_Ptr val = Cast<Value>(i->second))
         { std::cerr << " : " << val->to_string(); }
         std::cerr << std::endl;
       }

src/libsass/src/environment.hpp

@@ -87,6 +87,9 @@ namespace Sass {
 
   };
 
+  // define typedef for our use case
+  typedef Environment<AST_Node_Obj> Env;
+
 }
 
 #endif

src/libsass/src/expand.hpp

@@ -13,14 +13,12 @@ namespace Sass {
   class Listize;
   class Context;
   class Eval;
-  typedef Environment<AST_Node_Obj> Env;
   struct Backtrace;
 
   class Expand : public Operation_CRTP<Statement_Ptr, Expand> {
   public:
 
     Env* environment();
-    Context& context();
     Selector_List_Obj selector();
     Backtrace* backtrace();
 

src/libsass/src/file.cpp

@@ -20,6 +20,7 @@
 #include "context.hpp"
 #include "prelexer.hpp"
 #include "utf8_string.hpp"
+#include "sass_functions.hpp"
 #include "sass2scss.h"
 
 #ifdef _WIN32
@@ -301,13 +302,9 @@ namespace Sass {
     // (2) underscore + given
     // (3) underscore + given + extension
     // (4) given + extension
-    std::vector<Include> resolve_includes(const std::string& root, const std::string& file)
+    std::vector<Include> resolve_includes(const std::string& root, const std::string& file, const std::vector<std::string>& exts)
     {
       std::string filename = join_paths(root, file);
-      // supported extensions
-      const std::vector<std::string> exts = {
-        ".scss", ".sass", ".css"
-      };
       // split the filename
       std::string base(dir_name(file));
       std::string name(base_name(file));
@@ -336,9 +333,42 @@ namespace Sass {
       return includes;
     }
 
-    // helper function to resolve a filename
+    std::vector<std::string> find_files(const std::string& file, const std::vector<std::string> paths)
+    {
+      std::vector<std::string> includes;
+      for (std::string path : paths) {
+        std::string abs_path(join_paths(path, file));
+        if (file_exists(abs_path)) includes.push_back(abs_path);
+      }
+      return includes;
+    }
+
+    std::vector<std::string> find_files(const std::string& file, struct Sass_Compiler* compiler)
+    {
+      // get the last import entry to get current base directory
+      // struct Sass_Options* options = sass_compiler_get_options(compiler);
+      Sass_Import_Entry import = sass_compiler_get_last_import(compiler);
+      const std::vector<std::string>& incs = compiler->cpp_ctx->include_paths;
+      // create the vector with paths to lookup
+      std::vector<std::string> paths(1 + incs.size());
+      paths.push_back(dir_name(import->abs_path));
+      paths.insert(paths.end(), incs.begin(), incs.end());
+      // dispatch to find files in paths
+      return find_files(file, paths);
+    }
+
+    // helper function to search one file in all include paths
+    // this is normally not used internally by libsass (C-API sugar)
     std::string find_file(const std::string& file, const std::vector<std::string> paths)
     {
+      if (file.empty()) return file;
+      auto res = find_files(file, paths);
+      return res.empty() ? "" : res.front();
+    }
+
+    // helper function to resolve a filename
+    std::string find_include(const std::string& file, const std::vector<std::string> paths)
+    {
       // search in every include path for a match
       for (size_t i = 0, S = paths.size(); i < S; ++i)
       {
@@ -349,20 +379,6 @@ namespace Sass {
       return std::string("");
     }
 
-    // inc paths can be directly passed from C code
-    std::string find_file(const std::string& file, const char* paths[])
-    {
-      if (paths == 0) return std::string("");
-      std::vector<std::string> includes(0);
-      // includes.push_back(".");
-      const char** it = paths;
-      while (it && *it) {
-        includes.push_back(*it);
-        ++it;
-      }
-      return find_file(file, includes);
-    }
-
     // try to load the given filename
     // returned memory must be freed
     // will auto convert .sass files
@@ -414,5 +430,25 @@ namespace Sass {
       }
     }
 
+    // split a path string delimited by semicolons or colons (OS dependent)
+    std::vector<std::string> split_path_list(const char* str)
+    {
+      std::vector<std::string> paths;
+      if (str == NULL) return paths;
+      // find delimiter via prelexer (return zero at end)
+      const char* end = Prelexer::find_first<PATH_SEP>(str);
+      // search until null delimiter
+      while (end) {
+        // add path from current position to delimiter
+        paths.push_back(std::string(str, end - str));
+        str = end + 1; // skip delimiter
+        end = Prelexer::find_first<PATH_SEP>(str);
+      }
+      // add path from current position to end
+      paths.push_back(std::string(str));
+      // return back
+      return paths;
+    }
+
   }
 }

src/libsass/src/file.hpp

@@ -4,6 +4,7 @@
 #include <string>
 #include <vector>
 
+#include "sass/context.h"
 #include "ast_fwd_decl.hpp"
 
 namespace Sass {
@@ -47,9 +48,16 @@ namespace Sass {
     std::string abs2rel(const std::string& path, const std::string& base = ".", const std::string& cwd = get_cwd());
 
     // helper function to resolve a filename
+    // searching without variations in all paths
+    std::string find_file(const std::string& file, struct Sass_Compiler* options);
     std::string find_file(const std::string& file, const std::vector<std::string> paths);
-    // inc paths can be directly passed from C code
-    std::string find_file(const std::string& file, const char** paths);
+
+    // helper function to resolve a include filename
+    // this has the original resolve logic for sass include
+    std::string find_include(const std::string& file, const std::vector<std::string> paths);
+
+    // split a path string delimited by semicolons or colons (OS dependent)
+    std::vector<std::string> split_path_list(const char* paths);
 
     // try to load the given filename
     // returned memory must be freed
@@ -113,7 +121,10 @@ namespace Sass {
 
   namespace File {
 
-    std::vector<Include> resolve_includes(const std::string& root, const std::string& file);
+    static std::vector<std::string> defaultExtensions = { ".scss", ".sass", ".css" };
+
+    std::vector<Include> resolve_includes(const std::string& root, const std::string& file,
+      const std::vector<std::string>& exts = defaultExtensions);
 
   }
 

src/libsass/src/functions.hpp

@@ -12,7 +12,6 @@ name(Env& env, Env& d_env, Context& ctx, Signature sig, ParserState pstate, Back
 
 namespace Sass {
   struct Backtrace;
-  typedef Environment<AST_Node_Obj> Env;
   typedef const char* Signature;
   typedef Expression_Ptr (*Native_Function)(Env&, Env&, Context&, Signature, ParserState, Backtrace*, std::vector<Selector_List_Obj>);
 
@@ -89,7 +88,6 @@ namespace Sass {
     extern Signature call_sig;
     extern Signature not_sig;
     extern Signature if_sig;
-    extern Signature image_url_sig;
     extern Signature map_get_sig;
     extern Signature map_merge_sig;
     extern Signature map_remove_sig;
@@ -107,6 +105,7 @@ namespace Sass {
     extern Signature is_superselector_sig;
     extern Signature simple_selectors_sig;
     extern Signature selector_parse_sig;
+    extern Signature is_bracketed_sig;
 
     BUILT_IN(rgb);
     BUILT_IN(rgba_4);
@@ -171,7 +170,6 @@ namespace Sass {
     BUILT_IN(call);
     BUILT_IN(sass_not);
     BUILT_IN(sass_if);
-    BUILT_IN(image_url);
     BUILT_IN(map_get);
     BUILT_IN(map_merge);
     BUILT_IN(map_remove);
@@ -189,6 +187,7 @@ namespace Sass {
     BUILT_IN(is_superselector);
     BUILT_IN(simple_selectors);
     BUILT_IN(selector_parse);
+    BUILT_IN(is_bracketed);
   }
 }
 

src/libsass/src/inspect.cpp

@@ -166,7 +166,7 @@ namespace Sass {
 
       import->urls().front()->perform(this);
       if (import->urls().size() == 1) {
-        if (&import->import_queries()) {
+        if (import->import_queries()) {
           append_mandatory_space();
           import->import_queries()->perform(this);
         }
@@ -179,7 +179,7 @@ namespace Sass {
 
         import->urls()[i]->perform(this);
         if (import->urls().size() - 1 == i) {
-          if (&import->import_queries()) {
+          if (import->import_queries()) {
             append_mandatory_space();
             import->import_queries()->perform(this);
           }
@@ -360,10 +360,19 @@ namespace Sass {
     append_string(")");
   }
 
+  std::string Inspect::lbracket(List_Ptr list) {
+    return list->is_bracketed() ? "[" : "(";
+  }
+
+  std::string Inspect::rbracket(List_Ptr list) {
+    return list->is_bracketed() ? "]" : ")";
+  }
+
   void Inspect::operator()(List_Ptr list)
   {
-    if (output_style() == TO_SASS && list->empty()) {
-      append_string("()");
+    if (list->empty() && (output_style() == TO_SASS || list->is_bracketed())) {
+      append_string(lbracket(list));
+      append_string(rbracket(list));
       return;
     }
     std::string sep(list->separator() == SASS_SPACE ? " " : ",");
@@ -374,19 +383,24 @@ namespace Sass {
 
     bool was_space_array = in_space_array;
     bool was_comma_array = in_comma_array;
+    // if the list is bracketed, always include the left bracket
+    if (list->is_bracketed()) {
+      append_string(lbracket(list));
+    }
     // probably ruby sass eqivalent of element_needs_parens
-    if (output_style() == TO_SASS &&
+    else if (output_style() == TO_SASS &&
         list->length() == 1 &&
         !list->from_selector() &&
-        !SASS_MEMORY_CAST(List, list->at(0)) &&
-        !SASS_MEMORY_CAST(Selector_List, list->at(0))) {
-      append_string("(");
+        !Cast<List>(list->at(0)) &&
+        !Cast<Selector_List>(list->at(0))
+    ) {
+      append_string(lbracket(list));
     }
     else if (!in_declaration && (list->separator() == SASS_HASH ||
         (list->separator() == SASS_SPACE && in_space_array) ||
         (list->separator() == SASS_COMMA && in_comma_array)
     )) {
-      append_string("(");
+      append_string(lbracket(list));
     }
 
     if (list->separator() == SASS_SPACE) in_space_array = true;
@@ -399,7 +413,7 @@ namespace Sass {
       if (output_style() != TO_SASS) {
         if (list_item->is_invisible()) {
           // this fixes an issue with "" in a list
-          if (!SASS_MEMORY_CAST(String_Constant, list_item)) {
+          if (!Cast<String_Constant>(list_item)) {
             continue;
           }
         }
@@ -415,19 +429,29 @@ namespace Sass {
 
     in_comma_array = was_comma_array;
     in_space_array = was_space_array;
+
+    // if the list is bracketed, always include the right bracket
+    if (list->is_bracketed()) {
+      if (list->separator() == SASS_COMMA && list->size() == 1) {
+        append_string(",");
+      }
+      append_string(rbracket(list));
+    }
     // probably ruby sass eqivalent of element_needs_parens
-    if (output_style() == TO_SASS &&
+    else if (output_style() == TO_SASS &&
         list->length() == 1 &&
         !list->from_selector() &&
-        !SASS_MEMORY_CAST(List, list->at(0)) &&
-        !SASS_MEMORY_CAST(Selector_List, list->at(0))) {
-      append_string(",)");
+        !Cast<List>(list->at(0)) &&
+        !Cast<Selector_List>(list->at(0))
+    ) {
+      append_string(",");
+      append_string(rbracket(list));
     }
     else if (!in_declaration && (list->separator() == SASS_HASH ||
         (list->separator() == SASS_SPACE && in_space_array) ||
         (list->separator() == SASS_COMMA && in_comma_array)
     )) {
-      append_string(")");
+      append_string(rbracket(list));
     }
 
   }
@@ -443,7 +467,7 @@ namespace Sass {
               expr->is_right_interpolant())
 
     )) append_string(" ");
-    switch (expr->type()) {
+    switch (expr->optype()) {
       case Sass_OP::AND: append_string("&&"); break;
       case Sass_OP::OR:  append_string("||");  break;
       case Sass_OP::EQ:  append_string("==");  break;
@@ -471,7 +495,7 @@ namespace Sass {
 
   void Inspect::operator()(Unary_Expression_Ptr expr)
   {
-    if (expr->type() == Unary_Expression::PLUS) append_string("+");
+    if (expr->optype() == Unary_Expression::PLUS) append_string("+");
     else                                          append_string("-");
     expr->operand()->perform(this);
   }
@@ -744,9 +768,9 @@ namespace Sass {
   {
     append_token("not", sn);
     append_mandatory_space();
-    if (sn->needs_parens(&sn->condition())) append_string("(");
+    if (sn->needs_parens(sn->condition())) append_string("(");
     sn->condition()->perform(this);
-    if (sn->needs_parens(&sn->condition())) append_string(")");
+    if (sn->needs_parens(sn->condition())) append_string(")");
   }
 
   void Inspect::operator()(Supports_Declaration_Ptr sd)
@@ -766,7 +790,7 @@ namespace Sass {
   void Inspect::operator()(Media_Query_Ptr mq)
   {
     size_t i = 0;
-    if (&mq->media_type()) {
+    if (mq->media_type()) {
       if      (mq->is_negated())    append_string("not ");
       else if (mq->is_restricted()) append_string("only ");
       mq->media_type()->perform(this);
@@ -851,7 +875,7 @@ namespace Sass {
       return;
     }
     if (a->value()->concrete_type() == Expression::STRING) {
-      String_Constant_Ptr s = SASS_MEMORY_CAST(String_Constant, a->value());
+      String_Constant_Ptr s = Cast<String_Constant>(a->value());
       if (s) s->perform(this);
     } else {
       a->value()->perform(this);
@@ -919,7 +943,7 @@ namespace Sass {
     append_token(s->ns_name(), s);
     if (!s->matcher().empty()) {
       append_string(s->matcher());
-      if (&s->value() && *s->value()) {
+      if (s->value() && *s->value()) {
         s->value()->perform(this);
       }
     }
@@ -1040,8 +1064,8 @@ namespace Sass {
     bool was_comma_array = in_comma_array;
     // probably ruby sass eqivalent of element_needs_parens
     if (output_style() == TO_SASS && g->length() == 1 &&
-      (!SASS_MEMORY_CAST(List, (*g)[0]) &&
-       !SASS_MEMORY_CAST(Selector_List, (*g)[0]))) {
+      (!Cast<List>((*g)[0]) &&
+       !Cast<Selector_List>((*g)[0]))) {
       append_string("(");
     }
     else if (!in_declaration && in_comma_array) {
@@ -1053,7 +1077,7 @@ namespace Sass {
     for (size_t i = 0, L = g->length(); i < L; ++i) {
       if (!in_wrapped && i == 0) append_indentation();
       if ((*g)[i] == 0) continue;
-      schedule_mapping(&g->at(i)->last());
+      schedule_mapping(g->at(i)->last());
       // add_open_mapping((*g)[i]->last());
       (*g)[i]->perform(this);
       // add_close_mapping((*g)[i]->last());
@@ -1066,8 +1090,8 @@ namespace Sass {
     in_comma_array = was_comma_array;
     // probably ruby sass eqivalent of element_needs_parens
     if (output_style() == TO_SASS && g->length() == 1 &&
-      (!SASS_MEMORY_CAST(List, (*g)[0]) &&
-       !SASS_MEMORY_CAST(Selector_List, (*g)[0]))) {
+      (!Cast<List>((*g)[0]) &&
+       !Cast<Selector_List>((*g)[0]))) {
       append_string(",)");
     }
     else if (!in_declaration && in_comma_array) {

src/libsass/src/inspect.hpp

@@ -92,6 +92,9 @@ namespace Sass {
     virtual void operator()(Complex_Selector_Ptr);
     virtual void operator()(Selector_List_Ptr);
 
+    virtual std::string lbracket(List_Ptr);
+    virtual std::string rbracket(List_Ptr);
+
     // template <typename U>
     // void fallback(U x) { fallback_impl(reinterpret_cast<AST_Node_Ptr>(x)); }
   };

src/libsass/src/lexer.cpp

 #include "sass.hpp"
 #include <cctype>
-#include <cstddef>
 #include <iostream>
 #include <iomanip>
 #include "lexer.hpp"

src/libsass/src/listize.cpp

@@ -70,7 +70,7 @@ namespace Sass {
     if (tail)
     {
       Expression_Obj tt = tail->perform(this);
-      if (List_Ptr ls = SASS_MEMORY_CAST(List, tt))
+      if (List_Ptr ls = Cast<List>(tt))
       { l->concat(ls); }
     }
     if (l->length() == 0) return 0;
@@ -79,7 +79,7 @@ namespace Sass {
 
   Expression_Ptr Listize::fallback_impl(AST_Node_Ptr n)
   {
-    return dynamic_cast<Expression_Ptr>(n);
+    return Cast<Expression>(n);
   }
 
 }

src/libsass/src/listize.hpp

@@ -11,7 +11,6 @@
 
 namespace Sass {
 
-  typedef Environment<AST_Node_Obj> Env;
   struct Backtrace;
 
   class Listize : public Operation_CRTP<Expression_Ptr, Listize> {

src/libsass/src/memory/SharedPtr.cpp

@@ -18,7 +18,7 @@ namespace Sass {
       std::cerr << "# REPORTING MISSING DEALLOCATIONS #\n";
       std::cerr << "###################################\n";
       for (auto var : all) {
-        if (AST_Node_Ptr ast = SASS_MEMORY_CAST_PTR(AST_Node, var)) {
+        if (AST_Node_Ptr ast = Cast<AST_Node>(var)) {
           debug_ast(ast);
         } else {
           std::cerr << "LEAKED " << var << "\n";
@@ -62,7 +62,7 @@ namespace Sass {
       #endif
       if (node->refcounter == 0) {
         #ifdef DEBUG_SHARED_PTR
-          AST_Node_Ptr ptr = SASS_MEMORY_CAST_PTR(AST_Node, node);
+          AST_Node_Ptr ptr = Cast<AST_Node>(node);
           if (node->dbg) std::cerr << "DELETE NODE " << node << "\n";
         #endif
         if (!node->detached) {

src/libsass/src/memory/SharedPtr.hpp

@@ -17,7 +17,7 @@ namespace Sass {
   #ifdef DEBUG_SHARED_PTR
 
     #define SASS_MEMORY_NEW(Class, ...) \
-      static_cast<Class##_Ptr>((new Class(__VA_ARGS__))->trace(__FILE__, __LINE__)) \
+      ((new Class(__VA_ARGS__))->trace(__FILE__, __LINE__)) \
 
     #define SASS_MEMORY_COPY(obj) \
       ((obj)->copy(__FILE__, __LINE__)) \
@@ -38,12 +38,6 @@ namespace Sass {
 
   #endif
 
-  #define SASS_MEMORY_CAST(Class, obj) \
-    (dynamic_cast<Class##_Ptr>(&obj)) \
-
-  #define SASS_MEMORY_CAST_PTR(Class, ptr) \
-    (dynamic_cast<Class##_Ptr>(ptr)) \
-
   class SharedObj {
   protected:
   friend class SharedPtr;
@@ -114,13 +108,10 @@ namespace Sass {
     // destructor
     ~SharedPtr();
   public:
-    SharedObj* obj () {
-      return node;
-    };
     SharedObj* obj () const {
       return node;
     };
-    SharedObj* operator-> () {
+    SharedObj* operator-> () const {
       return node;
     };
     bool isNull () {
@@ -129,68 +120,58 @@ namespace Sass {
     bool isNull () const {
       return node == NULL;
     };
-    SharedObj* detach() {
-      node->detached = true;
-      return node;
-    };
     SharedObj* detach() const {
       if (node) {
         node->detached = true;
       }
       return node;
     };
-    operator bool() {
-      return node != NULL;
-    };
     operator bool() const {
       return node != NULL;
     };
 
   };
 
-  template < typename T >
+  template < class T >
   class SharedImpl : private SharedPtr {
   public:
     SharedImpl()
     : SharedPtr(NULL) {};
     SharedImpl(T* node)
     : SharedPtr(node) {};
+    template < class U >
+    SharedImpl(SharedImpl<U> obj)
+    : SharedPtr(static_cast<T*>(obj.ptr())) {}
     SharedImpl(T&& node)
     : SharedPtr(node) {};
     SharedImpl(const T& node)
     : SharedPtr(node) {};
     ~SharedImpl() {};
   public:
-    T* operator& () {
+    operator T*() const {
       return static_cast<T*>(this->obj());
-    };
-    T* operator& () const {
-      return static_cast<T*>(this->obj());
-    };
-    T& operator* () {
+    }
+    operator T&() const {
       return *static_cast<T*>(this->obj());
-    };
+    }
     T& operator* () const {
       return *static_cast<T*>(this->obj());
     };
-    T* operator-> () {
-      return static_cast<T*>(this->obj());
-    };
     T* operator-> () const {
       return static_cast<T*>(this->obj());
     };
-    T* ptr () {
+    T* ptr () const {
       return static_cast<T*>(this->obj());
     };
-    T* detach() {
+    T* detach() const {
       if (this->obj() == NULL) return NULL;
       return static_cast<T*>(SharedPtr::detach());
     }
-    bool isNull() {
+    bool isNull() const {
       return this->obj() == NULL;
     }
-    operator bool() {
-      return this->obj() != NULL;
+    bool operator<(const T& rhs) const {
+      return *this->ptr() < rhs;
     };
     operator bool() const {
       return this->obj() != NULL;

src/libsass/src/node.cpp

@@ -71,7 +71,7 @@ namespace Sass {
     for (NodeDeque::iterator iter = mpCollection->begin(), iterEnd = mpCollection->end(); iter != iterEnd; iter++) {
       Node& toTest = *iter;
 
-      if (nodesEqual(toTest, potentialChild, simpleSelectorOrderDependent)) {
+      if (toTest == potentialChild) {
         found = true;
         break;
       }
@@ -82,37 +82,32 @@ namespace Sass {
 
 
   bool Node::operator==(const Node& rhs) const {
-  	return nodesEqual(*this, rhs, true /*simpleSelectorOrderDependent*/);
-  }
-
-
-  bool nodesEqual(const Node& lhs, const Node& rhs, bool simpleSelectorOrderDependent) {
-    if (lhs.type() != rhs.type()) {
+    if (this->type() != rhs.type()) {
       return false;
     }
 
-    if (lhs.isCombinator()) {
+    if (this->isCombinator()) {
 
-    	return lhs.combinator() == rhs.combinator();
+      return this->combinator() == rhs.combinator();
 
-    } else if (lhs.isNil()) {
+    } else if (this->isNil()) {
 
       return true; // no state to check
 
-    } else if (lhs.isSelector()){
+    } else if (this->isSelector()){
 
-      return selectors_equal(*&lhs.selector(), *&rhs.selector(), simpleSelectorOrderDependent);
+      return *this->selector() == *rhs.selector();
 
-    } else if (lhs.isCollection()) {
+    } else if (this->isCollection()) {
 
-      if (lhs.collection()->size() != rhs.collection()->size()) {
+      if (this->collection()->size() != rhs.collection()->size()) {
         return false;
       }
 
-      for (NodeDeque::iterator lhsIter = lhs.collection()->begin(), lhsIterEnd = lhs.collection()->end(),
+      for (NodeDeque::iterator lhsIter = this->collection()->begin(), lhsIterEnd = this->collection()->end(),
            rhsIter = rhs.collection()->begin(); lhsIter != lhsIterEnd; lhsIter++, rhsIter++) {
 
-        if (!nodesEqual(*lhsIter, *rhsIter, simpleSelectorOrderDependent)) {
+        if (*lhsIter != *rhsIter) {
           return false;
         }
 
@@ -189,7 +184,7 @@ namespace Sass {
     if (pToConvert->head() && pToConvert->head()->has_parent_ref()) {
       Complex_Selector_Obj tail = pToConvert->tail();
       if (tail) tail->has_line_feed(pToConvert->has_line_feed());
-      pToConvert = &tail;
+      pToConvert = tail;
     }
 
     while (pToConvert) {
@@ -216,7 +211,7 @@ namespace Sass {
         // pToConvert->tail()->has_line_feed(pToConvert->has_line_feed());
       }
 
-      pToConvert = &pToConvert->tail();
+      pToConvert = pToConvert->tail();
     }
 
     return node;
@@ -254,7 +249,7 @@ namespace Sass {
         // collections, and can result in an infinite loop during the call to parentSuperselector()
         pCurrent->tail(SASS_MEMORY_COPY(child.selector()));
         // if (child.got_line_feed) pCurrent->has_line_feed(child.got_line_feed);
-        pCurrent = &pCurrent->tail();
+        pCurrent = pCurrent->tail();
       } else if (child.isCombinator()) {
         pCurrent->combinator(child.combinator());
         if (child.got_line_feed) pCurrent->has_line_feed(child.got_line_feed);
@@ -265,7 +260,7 @@ namespace Sass {
           if (nextNode.isCombinator()) {
             pCurrent->tail(SASS_MEMORY_NEW(Complex_Selector, ParserState("[NODE]"), Complex_Selector::ANCESTOR_OF, NULL, NULL));
             if (nextNode.got_line_feed) pCurrent->tail()->has_line_feed(nextNode.got_line_feed);
-            pCurrent = &pCurrent->tail();
+            pCurrent = pCurrent->tail();
           }
         }
       } else {

src/libsass/src/node.hpp

@@ -113,8 +113,6 @@ namespace Sass {
   Node complexSelectorToNode(Complex_Selector_Ptr pToConvert, Context& ctx);
   Complex_Selector_Ptr nodeToComplexSelector(const Node& toConvert, Context& ctx);
 
-  bool nodesEqual(const Node& one, const Node& two, bool simpleSelectorOrderDependent);
-
 }
 
 #endif

src/libsass/src/output.cpp

@@ -116,8 +116,8 @@ namespace Sass {
     if (!Util::isPrintable(r, output_style())) {
       for (size_t i = 0, L = b->length(); i < L; ++i) {
         const Statement_Obj& stm = b->at(i);
-        if (dynamic_cast<Has_Block_Ptr>(&stm)) {
-          if (!dynamic_cast<Declaration_Ptr>(&stm)) {
+        if (Cast<Has_Block>(stm)) {
+          if (!Cast<Declaration>(stm)) {
             stm->perform(this);
           }
         }
@@ -135,27 +135,27 @@ namespace Sass {
       append_optional_linefeed();
     }
     if (s) s->perform(this);
-    append_scope_opener(&b);
+    append_scope_opener(b);
     for (size_t i = 0, L = b->length(); i < L; ++i) {
       Statement_Obj stm = b->at(i);
       bool bPrintExpression = true;
       // Check print conditions
-      if (Declaration_Ptr dec = SASS_MEMORY_CAST(Declaration, stm)) {
-        if (String_Constant_Ptr valConst = SASS_MEMORY_CAST(String_Constant, dec->value())) {
+      if (Declaration_Ptr dec = Cast<Declaration>(stm)) {
+        if (String_Constant_Ptr valConst = Cast<String_Constant>(dec->value())) {
           std::string val(valConst->value());
-          if (String_Quoted_Ptr qstr = SASS_MEMORY_CAST_PTR(String_Quoted, valConst)) {
+          if (String_Quoted_Ptr qstr = Cast<String_Quoted>(valConst)) {
             if (!qstr->quote_mark() && val.empty()) {
               bPrintExpression = false;
             }
           }
         }
-        else if (List_Ptr list = SASS_MEMORY_CAST(List, dec->value())) {
+        else if (List_Ptr list = Cast<List>(dec->value())) {
           bool all_invisible = true;
           for (size_t list_i = 0, list_L = list->length(); list_i < list_L; ++list_i) {
-            Expression_Ptr item = &list->at(list_i);
+            Expression_Ptr item = list->at(list_i);
             if (!item->is_invisible()) all_invisible = false;
           }
-          if (all_invisible) bPrintExpression = false;
+          if (all_invisible && !list->is_bracketed()) bPrintExpression = false;
         }
       }
       // Print if OK
@@ -164,7 +164,7 @@ namespace Sass {
       }
     }
     if (output_style() == NESTED) indentation -= r->tabs();
-    append_scope_closer(&b);
+    append_scope_closer(b);
 
   }
   void Output::operator()(Keyframe_Rule_Ptr r)
@@ -172,7 +172,7 @@ namespace Sass {
     Block_Obj b = r->block();
     Selector_Obj v = r->name();
 
-    if (&v) {
+    if (!v.isNull()) {
       v->perform(this);
     }
 
@@ -201,7 +201,7 @@ namespace Sass {
     if (!Util::isPrintable(f, output_style())) {
       for (size_t i = 0, L = b->length(); i < L; ++i) {
         Statement_Obj stm = b->at(i);
-        if (dynamic_cast<Has_Block_Ptr>(&stm)) {
+        if (Cast<Has_Block>(stm)) {
           stm->perform(this);
         }
       }
@@ -237,7 +237,7 @@ namespace Sass {
     if (!Util::isPrintable(m, output_style())) {
       for (size_t i = 0, L = b->length(); i < L; ++i) {
         Statement_Obj stm = b->at(i);
-        if (dynamic_cast<Has_Block_Ptr>(&stm)) {
+        if (Cast<Has_Block>(stm)) {
           stm->perform(this);
         }
       }
@@ -282,7 +282,7 @@ namespace Sass {
     if (v) {
       append_mandatory_space();
       // ruby sass bug? should use options?
-      append_token(v->to_string(/* opt */), &v);
+      append_token(v->to_string(/* opt */), v);
     }
     if (!b) {
       append_delimiter();

src/libsass/src/parser.hpp

@@ -39,12 +39,11 @@ namespace Sass {
 
 
     Token lexed;
-    bool in_at_root;
 
     Parser(Context& ctx, const ParserState& pstate)
     : ParserState(pstate), ctx(ctx), block_stack(), stack(0), last_media_block(),
       source(0), position(0), end(0), before_token(pstate), after_token(pstate), pstate(pstate), indentation(0)
-    { in_at_root = false; stack.push_back(Scope::Root); }
+    { stack.push_back(Scope::Root); }
 
     // static Parser from_string(const std::string& src, Context& ctx, ParserState pstate = ParserState("[STRING]"));
     static Parser from_c_str(const char* src, Context& ctx, ParserState pstate = ParserState("[CSTRING]"), const char* source = 0);
@@ -240,10 +239,10 @@ namespace Sass {
     Arguments_Obj parse_arguments();
     Argument_Obj parse_argument();
     Assignment_Obj parse_assignment();
-    Ruleset_Obj parse_ruleset(Lookahead lookahead, bool is_root = false);
-    Selector_Schema_Obj parse_selector_schema(const char* end_of_selector);
-    Selector_List_Obj parse_selector_list(bool at_root = false);
-    Complex_Selector_Obj parse_complex_selector(bool in_root = true);
+    Ruleset_Obj parse_ruleset(Lookahead lookahead);
+    Selector_List_Obj parse_selector_list(bool chroot);
+    Complex_Selector_Obj parse_complex_selector(bool chroot);
+    Selector_Schema_Obj parse_selector_schema(const char* end_of_selector, bool chroot);
     Compound_Selector_Obj parse_compound_selector();
     Simple_Selector_Obj parse_simple_selector();
     Wrapped_Selector_Obj parse_negated_selector();
@@ -257,6 +256,7 @@ namespace Sass {
     bool parse_number_prefix();
     Declaration_Obj parse_declaration();
     Expression_Obj parse_map();
+    Expression_Obj parse_bracket_list();
     Expression_Obj parse_list(bool delayed = false);
     Expression_Obj parse_comma_list(bool delayed = false);
     Expression_Obj parse_space_list();
@@ -340,15 +340,15 @@ namespace Sass {
         schema->append(SASS_MEMORY_NEW(String_Constant, pstate, lexed));
         if (position[0] == '#' && position[1] == '{') {
           Expression_Obj itpl = lex_interpolation();
-          if (&itpl) schema->append(&itpl);
+          if (!itpl.isNull()) schema->append(itpl);
           while (lex < close >(false)) {
             // std::cerr << "LEX [[" << std::string(lexed) << "]]\n";
             schema->append(SASS_MEMORY_NEW(String_Constant, pstate, lexed));
             if (position[0] == '#' && position[1] == '{') {
               Expression_Obj itpl = lex_interpolation();
-              if (&itpl) schema->append(&itpl);
+              if (!itpl.isNull()) schema->append(itpl);
             } else {
-              return &schema;
+              return schema;
             }
           }
         } else {

src/libsass/src/plugins.cpp

+#include "sass.hpp"
+#include <iostream>
+#include "output.hpp"
+#include "plugins.hpp"
+
 #ifdef _WIN32
 #include <windows.h>
 #else
@@ -7,15 +12,21 @@
 #include <dlfcn.h>
 #endif
 
-#include "sass.hpp"
-#include <iostream>
-#include "output.hpp"
-#include "plugins.hpp"
-
 namespace Sass {
 
   Plugins::Plugins(void) { }
-  Plugins::~Plugins(void) { }
+  Plugins::~Plugins(void)
+  {
+    for (auto function : functions) {
+      sass_delete_function(function);
+    }
+    for (auto importer : importers) {
+      sass_delete_importer(importer);
+    }
+    for (auto header : headers) {
+      sass_delete_importer(header);
+    }
+  }
 
   // check if plugin is compatible with this version
   // plugins may be linked static against libsass
@@ -57,20 +68,23 @@ namespace Sass {
         // try to get import address for "libsass_load_functions"
         if (LOAD_LIB_FN(__plugin_load_fns__, plugin_load_functions, "libsass_load_functions"))
         {
-          Sass_Function_List fns = plugin_load_functions();
+          Sass_Function_List fns = plugin_load_functions(), _p = fns;
           while (fns && *fns) { functions.push_back(*fns); ++ fns; }
+          sass_free_memory(_p); // only delete the container, items not yet
         }
         // try to get import address for "libsass_load_importers"
         if (LOAD_LIB_FN(__plugin_load_imps__, plugin_load_importers, "libsass_load_importers"))
         {
-          Sass_Importer_List imps = plugin_load_importers();
+          Sass_Importer_List imps = plugin_load_importers(), _p = imps;
           while (imps && *imps) { importers.push_back(*imps); ++ imps; }
+          sass_free_memory(_p); // only delete the container, items not yet
         }
         // 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();
+          Sass_Importer_List imps = plugin_load_headers(), _p = imps;
           while (imps && *imps) { headers.push_back(*imps); ++ imps; }
+          sass_free_memory(_p); // only delete the container, items not yet
         }
         // success
         return true;
@@ -153,7 +167,11 @@ namespace Sass {
       struct dirent *dirp;
       if((dp  = opendir(path.c_str())) == NULL) return -1;
       while ((dirp = readdir(dp)) != NULL) {
+        #if __APPLE__
+          if (!ends_with(dirp->d_name, ".dylib")) continue;
+        #else
           if (!ends_with(dirp->d_name, ".so")) continue;
+        #endif
         if (load_plugin(path + dirp->d_name)) ++ loaded;
       }
       closedir(dp);

src/libsass/src/position.hpp

@@ -85,7 +85,7 @@ namespace Sass {
 
     size_t length()    const { return end - begin; }
     std::string ws_before() const { return std::string(prefix, begin); }
-    std::string to_string() const { return std::string(begin, end); }
+    const std::string to_string() const { return std::string(begin, end); }
     std::string time_wspace() const {
       std::string str(to_string());
       std::string whitespaces(" \t\f\v\n\r");

src/libsass/src/prelexer.cpp

 #include "sass.hpp"
 #include <cctype>
-#include <cstddef>
 #include <iostream>
 #include <iomanip>
 #include "util.hpp"
@@ -1420,6 +1419,28 @@ namespace Sass {
       >(src);
     }
 
+    const char* list_terminator(const char* src) {
+      return alternatives <
+        exactly<';'>,
+        exactly<'}'>,
+        exactly<'{'>,
+        exactly<')'>,
+        exactly<']'>,
+        exactly<':'>,
+        end_of_file,
+        exactly<ellipsis>,
+        default_flag,
+        global_flag
+      >(src);
+    };
+
+    const char* space_list_terminator(const char* src) {
+      return alternatives <
+        exactly<','>,
+        list_terminator
+      >(src);
+    };
+
 
     // const char* real_uri_prefix(const char* src) {
     //   return alternatives<

src/libsass/src/prelexer.hpp

@@ -355,6 +355,10 @@ namespace Sass {
     const char* ie_keyword_arg_value(const char* src);
     const char* ie_keyword_arg_property(const char* src);
 
+    // characters that terminate parsing of a list
+    const char* list_terminator(const char* src);
+    const char* space_list_terminator(const char* src);
+
     // match url()
     const char* H(const char* src);
     const char* W(const char* src);

src/libsass/src/remove_placeholders.cpp

@@ -6,13 +6,12 @@
 
 namespace Sass {
 
-    Remove_Placeholders::Remove_Placeholders(Context& ctx)
-    : ctx(ctx)
+    Remove_Placeholders::Remove_Placeholders()
     { }
 
     void Remove_Placeholders::operator()(Block_Ptr b) {
         for (size_t i = 0, L = b->length(); i < L; ++i) {
-            Statement_Ptr st = &b->at(i);
+            Statement_Ptr st = b->at(i);
             st->perform(this);
         }
     }
@@ -34,18 +33,18 @@ namespace Sass {
 
     void Remove_Placeholders::operator()(Ruleset_Ptr r) {
         // Create a new selector group without placeholders
-        Selector_List_Obj sl = SASS_MEMORY_CAST(Selector_List, r->selector());
+        Selector_List_Obj sl = Cast<Selector_List>(r->selector());
 
         if (sl) {
           // Set the new placeholder selector list
-          r->selector(remove_placeholders(&sl));
+          r->selector(remove_placeholders(sl));
           // Remove placeholders in wrapped selectors
           for (Complex_Selector_Obj cs : sl->elements()) {
             while (cs) {
               if (cs->head()) {
                 for (Simple_Selector_Obj& ss : cs->head()->elements()) {
-                  if (Wrapped_Selector_Ptr ws = SASS_MEMORY_CAST(Wrapped_Selector, ss)) {
-                    if (Selector_List_Ptr sl = SASS_MEMORY_CAST(Selector_List, ws->selector())) {
+                  if (Wrapped_Selector_Ptr ws = Cast<Wrapped_Selector>(ss)) {
+                    if (Selector_List_Ptr sl = Cast<Selector_List>(ws->selector())) {
                       Selector_List_Ptr clean = remove_placeholders(sl);
                       // also clean superflous parent selectors
                       // probably not really the correct place
@@ -72,10 +71,10 @@ namespace Sass {
     }
 
     void Remove_Placeholders::operator()(Media_Block_Ptr m) {
-        operator()(&m->block());
+        operator()(m->block());
     }
     void Remove_Placeholders::operator()(Supports_Block_Ptr m) {
-        operator()(&m->block());
+        operator()(m->block());
     }
 
     void Remove_Placeholders::operator()(Directive_Ptr a) {

src/libsass/src/remove_placeholders.hpp

@@ -9,19 +9,15 @@
 namespace Sass {
 
 
-    class Context;
-
     class Remove_Placeholders : public Operation_CRTP<void, Remove_Placeholders> {
 
-        Context&          ctx;
-
         void fallback_impl(AST_Node_Ptr n) {}
 
     public:
       Selector_List_Ptr remove_placeholders(Selector_List_Ptr);
 
     public:
-        Remove_Placeholders(Context&);
+        Remove_Placeholders();
         ~Remove_Placeholders() { }
 
         void operator()(Block_Ptr);

src/libsass/src/sass.cpp

@@ -7,6 +7,23 @@
 #include "sass.h"
 #include "file.hpp"
 #include "util.hpp"
+#include "sass_context.hpp"
+#include "sass_functions.hpp"
+
+namespace Sass {
+
+  // helper to convert string list to vector
+  std::vector<std::string> list2vec(struct string_list* cur)
+  {
+    std::vector<std::string> list;
+    while (cur) {
+      list.push_back(cur->string);
+      cur = cur->next;
+    }
+    return list;
+  }
+
+}
 
 extern "C" {
   using namespace Sass;
@@ -49,11 +66,50 @@ extern "C" {
     return sass_copy_c_string(unquoted.c_str());
   }
 
+  char* ADDCALL sass_compiler_find_include (const char* file, struct Sass_Compiler* compiler)
+  {
+    // get the last import entry to get current base directory
+    Sass_Import_Entry import = sass_compiler_get_last_import(compiler);
+    const std::vector<std::string>& incs = compiler->cpp_ctx->include_paths;
+    // create the vector with paths to lookup
+    std::vector<std::string> paths(1 + incs.size());
+    paths.push_back(File::dir_name(import->abs_path));
+    paths.insert( paths.end(), incs.begin(), incs.end() );
+    // now resolve the file path relative to lookup paths
+    std::string resolved(File::find_include(file, paths));
+    return sass_copy_c_string(resolved.c_str());
+  }
+
+  char* ADDCALL sass_compiler_find_file (const char* file, struct Sass_Compiler* compiler)
+  {
+    // get the last import entry to get current base directory
+    Sass_Import_Entry import = sass_compiler_get_last_import(compiler);
+    const std::vector<std::string>& incs = compiler->cpp_ctx->include_paths;
+    // create the vector with paths to lookup
+    std::vector<std::string> paths(1 + incs.size());
+    paths.push_back(File::dir_name(import->abs_path));
+    paths.insert( paths.end(), incs.begin(), incs.end() );
+    // now resolve the file path relative to lookup paths
+    std::string resolved(File::find_file(file, paths));
+    return sass_copy_c_string(resolved.c_str());
+  }
+
   // Make sure to free the returned value!
   // Incs array has to be null terminated!
-  char* ADDCALL sass_resolve_file (const char* file, const char* paths[])
+  // this has the original resolve logic for sass include
+  char* ADDCALL sass_find_include (const char* file, struct Sass_Options* opt)
   {
-    std::string resolved(File::find_file(file, paths));
+    std::vector<std::string> vec(list2vec(opt->include_paths));
+    std::string resolved(File::find_include(file, vec));
+    return sass_copy_c_string(resolved.c_str());
+  }
+
+  // Make sure to free the returned value!
+  // Incs array has to be null terminated!
+  char* ADDCALL sass_find_file (const char* file, struct Sass_Options* opt)
+  {
+    std::vector<std::string> vec(list2vec(opt->include_paths));
+    std::string resolved(File::find_file(file, vec));
     return sass_copy_c_string(resolved.c_str());
   }
 

src/libsass/src/sass_context.cpp

@@ -272,10 +272,14 @@ extern "C" {
   #define IMPLEMENT_SASS_OPTION_ACCESSOR(type, option) \
     type ADDCALL sass_option_get_##option (struct Sass_Options* options) { return options->option; } \
     void ADDCALL sass_option_set_##option (struct Sass_Options* options, type option) { options->option = option; }
-  #define IMPLEMENT_SASS_OPTION_STRING_ACCESSOR(type, option, def) \
-    type ADDCALL sass_option_get_##option (struct Sass_Options* options) { return safe_str(options->option, def); } \
+  #define IMPLEMENT_SASS_OPTION_STRING_GETTER(type, option, def) \
+    type ADDCALL sass_option_get_##option (struct Sass_Options* options) { return safe_str(options->option, def); }
+  #define IMPLEMENT_SASS_OPTION_STRING_SETTER(type, option, def) \
     void ADDCALL sass_option_set_##option (struct Sass_Options* options, type option) \
     { free(options->option); options->option = option || def ? sass_copy_c_string(option ? option : def) : 0; }
+  #define IMPLEMENT_SASS_OPTION_STRING_ACCESSOR(type, option, def) \
+    IMPLEMENT_SASS_OPTION_STRING_GETTER(type, option, def) \
+    IMPLEMENT_SASS_OPTION_STRING_SETTER(type, option, def)
 
   #define IMPLEMENT_SASS_CONTEXT_GETTER(type, option) \
     type ADDCALL sass_context_get_##option (struct Sass_Context* ctx) { return ctx->option; }
@@ -468,7 +472,7 @@ extern "C" {
     if (compiler->c_ctx->error_status)
       return compiler->c_ctx->error_status;
     // parse the context we have set up (file or data)
-    compiler->root = &sass_parse_block(compiler);
+    compiler->root = sass_parse_block(compiler);
     // success
     return 0;
   }
@@ -674,6 +678,10 @@ extern "C" {
   size_t ADDCALL sass_compiler_get_import_stack_size(struct Sass_Compiler* compiler) { return compiler->cpp_ctx->import_stack.size(); }
   Sass_Import_Entry ADDCALL sass_compiler_get_last_import(struct Sass_Compiler* compiler) { return compiler->cpp_ctx->import_stack.back(); }
   Sass_Import_Entry ADDCALL sass_compiler_get_import_entry(struct Sass_Compiler* compiler, size_t idx) { return compiler->cpp_ctx->import_stack[idx]; }
+  // Getters for Sass_Compiler options (query function stack)
+  size_t ADDCALL sass_compiler_get_callee_stack_size(struct Sass_Compiler* compiler) { return compiler->cpp_ctx->callee_stack.size(); }
+  Sass_Callee_Entry ADDCALL sass_compiler_get_last_callee(struct Sass_Compiler* compiler) { return &compiler->cpp_ctx->callee_stack.back(); }
+  Sass_Callee_Entry ADDCALL sass_compiler_get_callee_entry(struct Sass_Compiler* compiler, size_t idx) { return &compiler->cpp_ctx->callee_stack[idx]; }
 
   // Calculate the size of the stored null terminated array
   size_t ADDCALL sass_context_get_included_files_size (struct Sass_Context* ctx)
@@ -693,10 +701,10 @@ extern "C" {
   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_SETTER(const char*, plugin_path, 0);
+  IMPLEMENT_SASS_OPTION_STRING_SETTER(const char*, include_path, 0);
   IMPLEMENT_SASS_OPTION_STRING_ACCESSOR(const char*, input_path, 0);
   IMPLEMENT_SASS_OPTION_STRING_ACCESSOR(const char*, output_path, 0);
-  IMPLEMENT_SASS_OPTION_STRING_ACCESSOR(const char*, plugin_path, 0);
-  IMPLEMENT_SASS_OPTION_STRING_ACCESSOR(const char*, include_path, 0);
   IMPLEMENT_SASS_OPTION_STRING_ACCESSOR(const char*, source_map_file, 0);
   IMPLEMENT_SASS_OPTION_STRING_ACCESSOR(const char*, source_map_root, 0);
 
@@ -740,6 +748,23 @@ extern "C" {
 
   }
 
+  // Push function for include paths (no manipulation support for now)
+  size_t ADDCALL sass_option_get_include_path_size(struct Sass_Options* options)
+  {
+    size_t len = 0;
+    struct string_list* cur = options->include_paths;
+    while (cur) { len ++; cur = cur->next; }
+    return len;
+  }
+
+  // Push function for include paths (no manipulation support for now)
+  const char* ADDCALL sass_option_get_include_path(struct Sass_Options* options, size_t i)
+  {
+    struct string_list* cur = options->include_paths;
+    while (i) { i--; cur = cur->next; }
+    return cur->string;
+  }
+
   // Push function for plugin paths (no manipulation support for now)
   void ADDCALL sass_option_push_plugin_path(struct Sass_Options* options, const char* path)
   {

src/libsass/src/sass_context.hpp

 #ifndef SASS_SASS_CONTEXT_H
 #define SASS_SASS_CONTEXT_H
 
-#include "sass.h"
-#include "sass.hpp"
-#include "context.hpp"
+#include "sass/base.h"
+#include "sass/context.h"
 #include "ast_fwd_decl.hpp"
 
 // sass config options structure
@@ -33,7 +32,7 @@ struct Sass_Options : Sass_Output_Options {
   char* input_path;
 
   // The output path is used for source map
-  // generation. Libsass will not write to
+  // generation. LibSass will not write to
   // this file, it is just used to create
   // information in source-maps etc.
   char* output_path;

src/libsass/src/sass_functions.cpp

@@ -2,6 +2,7 @@
 #include <cstring>
 #include "util.hpp"
 #include "context.hpp"
+#include "values.hpp"
 #include "sass/functions.h"
 #include "sass_functions.hpp"
 
@@ -17,12 +18,30 @@ extern "C" {
   {
     Sass_Function_Entry cb = (Sass_Function_Entry) calloc(1, sizeof(Sass_Function));
     if (cb == 0) return 0;
-    cb->signature = signature;
+    cb->signature = strdup(signature);
     cb->function = function;
     cb->cookie = cookie;
     return cb;
   }
 
+  void ADDCALL sass_delete_function(Sass_Function_Entry entry)
+  {
+    free(entry->signature);
+    free(entry);
+  }
+
+  // Deallocator for the allocated memory
+  void ADDCALL sass_delete_function_list(Sass_Function_List list)
+  {
+    Sass_Function_List it = list;
+    if (list == 0) return;
+    while(*list) {
+      sass_delete_function(*list);
+      ++list;
+    }
+    free(it);
+  }
+
   // Setters and getters for callbacks on function lists
   Sass_Function_Entry ADDCALL sass_function_get_list_entry(Sass_Function_List list, size_t pos) { return list[pos]; }
   void sass_function_set_list_entry(Sass_Function_List list, size_t pos, Sass_Function_Entry cb) { list[pos] = cb; }
@@ -57,6 +76,18 @@ extern "C" {
     return (Sass_Importer_List) calloc(length + 1, sizeof(Sass_Importer_Entry));
   }
 
+  // Deallocator for the allocated memory
+  void ADDCALL sass_delete_importer_list(Sass_Importer_List list)
+  {
+    Sass_Importer_List it = list;
+    if (list == 0) return;
+    while(*list) {
+      sass_delete_importer(*list);
+      ++list;
+    }
+    free(it);
+  }
+
   Sass_Importer_Entry ADDCALL sass_importer_get_list_entry(Sass_Importer_List list, size_t idx) { return list[idx]; }
   void ADDCALL sass_importer_set_list_entry(Sass_Importer_List list, size_t idx, Sass_Importer_Entry cb) { list[idx] = cb; }
 
@@ -126,6 +157,37 @@ extern "C" {
     free(import);
   }
 
+  // Getter for callee entry
+  const char* ADDCALL sass_callee_get_name(Sass_Callee_Entry entry) { return entry->name; }
+  const char* ADDCALL sass_callee_get_path(Sass_Callee_Entry entry) { return entry->path; }
+  size_t ADDCALL sass_callee_get_line(Sass_Callee_Entry entry) { return entry->line; }
+  size_t ADDCALL sass_callee_get_column(Sass_Callee_Entry entry) { return entry->column; }
+  enum Sass_Callee_Type ADDCALL sass_callee_get_type(Sass_Callee_Entry entry) { return entry->type; }
+  Sass_Env_Frame ADDCALL sass_callee_get_env (Sass_Callee_Entry entry) { return &entry->env; }
+
+  // Getters and Setters for environments (lexical, local and global)
+  union Sass_Value* ADDCALL sass_env_get_lexical (Sass_Env_Frame env, const char* name) {
+    Expression_Ptr ex = Cast<Expression>((*env->frame)[name]);
+    return ex != NULL ? ast_node_to_sass_value(ex) : NULL;
+  }
+  void ADDCALL sass_env_set_lexical (Sass_Env_Frame env, const char* name, union Sass_Value* val) {
+    (*env->frame)[name] = sass_value_to_ast_node(val);
+  }
+  union Sass_Value* ADDCALL sass_env_get_local (Sass_Env_Frame env, const char* name) {
+    Expression_Ptr ex = Cast<Expression>(env->frame->get_local(name));
+    return ex != NULL ? ast_node_to_sass_value(ex) : NULL;
+  }
+  void ADDCALL sass_env_set_local (Sass_Env_Frame env, const char* name, union Sass_Value* val) {
+    env->frame->set_local(name, sass_value_to_ast_node(val));
+  }
+  union Sass_Value* ADDCALL sass_env_get_global (Sass_Env_Frame env, const char* name) {
+    Expression_Ptr ex = Cast<Expression>(env->frame->get_global(name));
+    return ex != NULL ? ast_node_to_sass_value(ex) : NULL;
+  }
+  void ADDCALL sass_env_set_global (Sass_Env_Frame env, const char* name, union Sass_Value* val) {
+    env->frame->set_global(name, sass_value_to_ast_node(val));
+  }
+
   // Getter for import entry
   const char* ADDCALL sass_import_get_imp_path(Sass_Import_Entry entry) { return entry->imp_path; }
   const char* ADDCALL sass_import_get_abs_path(Sass_Import_Entry entry) { return entry->abs_path; }

src/libsass/src/sass_functions.hpp

@@ -2,10 +2,12 @@
 #define SASS_SASS_FUNCTIONS_H
 
 #include "sass.h"
+#include "environment.hpp"
+#include "functions.hpp"
 
 // Struct to hold custom function callback
 struct Sass_Function {
-  const char*      signature;
+  char*            signature;
   Sass_Function_Fn function;
   void*            cookie;
 };
@@ -22,6 +24,22 @@ struct Sass_Import {
   size_t column;
 };
 
+// External environments
+struct Sass_Env {
+  // links to parent frames
+  Sass::Env* frame;
+};
+
+// External call entry
+struct Sass_Callee {
+  const char* name;
+  const char* path;
+  size_t line;
+  size_t column;
+  enum Sass_Callee_Type type;
+  struct Sass_Env env;
+};
+
 // Struct to hold importer callback
 struct Sass_Importer {
   Sass_Importer_Fn importer;

src/libsass/src/sass_util.hpp

@@ -40,7 +40,7 @@ namespace Sass {
     bool operator()(const Node& one, const Node& two, Node& out) const {
       // TODO: Is this the correct C++ interpretation?
       // block ||= proc {|a, b| a == b && a}
-      if (nodesEqual(one, two, true)) {
+      if (one == two) {
         out = one;
         return true;
       }

src/libsass/src/sass_values.cpp

@@ -54,6 +54,8 @@ extern "C" {
   size_t ADDCALL sass_list_get_length(const union Sass_Value* v) { return v->list.length; }
   enum Sass_Separator ADDCALL sass_list_get_separator(const union Sass_Value* v) { return v->list.separator; }
   void ADDCALL sass_list_set_separator(union Sass_Value* v, enum Sass_Separator separator) { v->list.separator = separator; }
+  bool ADDCALL sass_list_get_is_bracketed(const union Sass_Value* v) { return v->list.is_bracketed; }
+  void ADDCALL sass_list_set_is_bracketed(union Sass_Value* v, bool is_bracketed) { v->list.is_bracketed = is_bracketed; }
   // Getters and setters for Sass_List values
   union Sass_Value* ADDCALL sass_list_get_value(const union Sass_Value* v, size_t i) { return v->list.values[i]; }
   void ADDCALL sass_list_set_value(union Sass_Value* v, size_t i, union Sass_Value* value) { v->list.values[i] = value; }
@@ -130,13 +132,14 @@ extern "C" {
     return v;
   }
 
-  union Sass_Value* ADDCALL sass_make_list(size_t len, enum Sass_Separator sep)
+  union Sass_Value* ADDCALL sass_make_list(size_t len, enum Sass_Separator sep, bool is_bracketed)
   {
     union Sass_Value* v = (Sass_Value*) calloc(1, sizeof(Sass_Value));
     if (v == 0) return 0;
     v->list.tag = SASS_LIST;
     v->list.length = len;
     v->list.separator = sep;
+    v->list.is_bracketed = is_bracketed;
     v->list.values = (union Sass_Value**) calloc(len, sizeof(union Sass_Value*));
     if (v->list.values == 0) { free(v); return 0; }
     return v;
@@ -247,7 +250,7 @@ extern "C" {
                 return sass_string_is_quoted(val) ? sass_make_qstring(val->string.value) : sass_make_string(val->string.value);
         }   break;
         case SASS_LIST: {
-                union Sass_Value* list = sass_make_list(val->list.length, val->list.separator);
+                union Sass_Value* list = sass_make_list(val->list.length, val->list.separator, val->list.is_bracketed);
                 for (i = 0; i < list->list.length; i++) {
                     list->list.values[i] = sass_clone_value(val->list.values[i]);
                 }
@@ -294,40 +297,40 @@ extern "C" {
 
       // see if it's a relational expression
       switch(op) {
-        case Sass_OP::EQ:  return sass_make_boolean(Eval::eq(&lhs, &rhs));
-        case Sass_OP::NEQ: return sass_make_boolean(!Eval::eq(&lhs, &rhs));
-        case Sass_OP::GT:  return sass_make_boolean(!Eval::lt(&lhs, &rhs, "gt") && !Eval::eq(&lhs, &rhs));
-        case Sass_OP::GTE: return sass_make_boolean(!Eval::lt(&lhs, &rhs, "gte"));
-        case Sass_OP::LT:  return sass_make_boolean(Eval::lt(&lhs, &rhs, "lt"));
-        case Sass_OP::LTE: return sass_make_boolean(Eval::lt(&lhs, &rhs, "lte") || Eval::eq(&lhs, &rhs));
-        case Sass_OP::AND: return ast_node_to_sass_value(lhs->is_false() ? &lhs : &rhs);
-        case Sass_OP::OR:  return ast_node_to_sass_value(lhs->is_false() ? &rhs : &lhs);
+        case Sass_OP::EQ:  return sass_make_boolean(Eval::eq(lhs, rhs));
+        case Sass_OP::NEQ: return sass_make_boolean(!Eval::eq(lhs, rhs));
+        case Sass_OP::GT:  return sass_make_boolean(!Eval::lt(lhs, rhs, "gt") && !Eval::eq(lhs, rhs));
+        case Sass_OP::GTE: return sass_make_boolean(!Eval::lt(lhs, rhs, "gte"));
+        case Sass_OP::LT:  return sass_make_boolean(Eval::lt(lhs, rhs, "lt"));
+        case Sass_OP::LTE: return sass_make_boolean(Eval::lt(lhs, rhs, "lte") || Eval::eq(lhs, rhs));
+        case Sass_OP::AND: return ast_node_to_sass_value(lhs->is_false() ? lhs : rhs);
+        case Sass_OP::OR:  return ast_node_to_sass_value(lhs->is_false() ? rhs : lhs);
         default:           break;
       }
 
       if (sass_value_is_number(a) && sass_value_is_number(b)) {
-        Number_Ptr_Const l_n = SASS_MEMORY_CAST(Number, lhs);
-        Number_Ptr_Const r_n = SASS_MEMORY_CAST(Number, rhs);
+        Number_Ptr_Const l_n = Cast<Number>(lhs);
+        Number_Ptr_Const r_n = Cast<Number>(rhs);
         rv = Eval::op_numbers(op, *l_n, *r_n, options);
       }
       else if (sass_value_is_number(a) && sass_value_is_color(a)) {
-        Number_Ptr_Const l_n = SASS_MEMORY_CAST(Number, lhs);
-        Color_Ptr_Const r_c = SASS_MEMORY_CAST(Color, rhs);
+        Number_Ptr_Const l_n = Cast<Number>(lhs);
+        Color_Ptr_Const r_c = Cast<Color>(rhs);
         rv = Eval::op_number_color(op, *l_n, *r_c, options);
       }
       else if (sass_value_is_color(a) && sass_value_is_number(b)) {
-        Color_Ptr_Const l_c = SASS_MEMORY_CAST(Color, lhs);
-        Number_Ptr_Const r_n = SASS_MEMORY_CAST(Number, rhs);
+        Color_Ptr_Const l_c = Cast<Color>(lhs);
+        Number_Ptr_Const r_n = Cast<Number>(rhs);
         rv = Eval::op_color_number(op, *l_c, *r_n, options);
       }
       else if (sass_value_is_color(a) && sass_value_is_color(b)) {
-        Color_Ptr_Const l_c = SASS_MEMORY_CAST(Color, lhs);
-        Color_Ptr_Const r_c = SASS_MEMORY_CAST(Color, rhs);
+        Color_Ptr_Const l_c = Cast<Color>(lhs);
+        Color_Ptr_Const r_c = Cast<Color>(rhs);
         rv = Eval::op_colors(op, *l_c, *r_c, options);
       }
       else /* convert other stuff to string and apply operation */ {
-        Value_Ptr l_v = SASS_MEMORY_CAST(Value, lhs);
-        Value_Ptr r_v = SASS_MEMORY_CAST(Value, rhs);
+        Value_Ptr l_v = Cast<Value>(lhs);
+        Value_Ptr r_v = Cast<Value>(rhs);
         rv = Eval::op_strings(op, *l_v, *r_v, options);
       }
 

src/libsass/src/sass_values.hpp

@@ -35,6 +35,7 @@ struct Sass_String {
 struct Sass_List {
   enum Sass_Tag       tag;
   enum Sass_Separator separator;
+  bool                is_bracketed;
   size_t              length;
   // null terminated "array"
   union Sass_Value**  values;

src/libsass/src/source_map.cpp

@@ -2,7 +2,6 @@
 #include <string>
 #include <sstream>
 #include <iostream>
-#include <cstddef>
 #include <iomanip>
 
 #include "ast.hpp"

src/libsass/src/subset_map.cpp

@@ -4,22 +4,20 @@
 
 namespace Sass {
 
-  void Subset_Map::put(const Compound_Selector_Obj& sel, const Subset_Map_Val& value)
+  void Subset_Map::put(const Compound_Selector_Obj& sel, const SubSetMapPair& value)
   {
     if (sel->empty()) throw std::runtime_error("internal error: subset map keys may not be empty");
     size_t index = values_.size();
     values_.push_back(value);
     for (size_t i = 0, S = sel->length(); i < S; ++i)
     {
-      hash_[(*sel)[i]].push_back(std::make_pair(&sel, index));
+      hash_[(*sel)[i]].push_back(std::make_pair(sel, index));
     }
   }
 
-  std::vector<Subset_Map_Val> Subset_Map::get_kv(const Compound_Selector_Obj& sel)
+  std::vector<SubSetMapPair> Subset_Map::get_kv(const Compound_Selector_Obj& sel)
   {
-    // std::vector<Subset_Map_Key> s = sel->to_str_vec();
-    // std::set<std::string> dict(s.begin(), s.end());
-    std::unordered_set<Simple_Selector_Obj, HashSimpleSelector, CompareSimpleSelector> dict(sel->begin(), sel->end());
+    SimpleSelectorDict dict(sel->begin(), sel->end()); // XXX Set
     std::vector<size_t> indices;
     for (size_t i = 0, S = sel->length(); i < S; ++i) {
       if (!hash_.count((*sel)[i])) {
@@ -42,14 +40,14 @@ namespace Sass {
     std::vector<size_t>::iterator indices_end = unique(indices.begin(), indices.end());
     indices.resize(distance(indices.begin(), indices_end));
 
-    std::vector<Subset_Map_Val> results;
+    std::vector<SubSetMapPair> results;
     for (size_t i = 0, S = indices.size(); i < S; ++i) {
       results.push_back(values_[indices[i]]);
     }
     return results;
   }
 
-  std::vector<Subset_Map_Val> Subset_Map::get_v(const Compound_Selector_Obj& sel)
+  std::vector<SubSetMapPair> Subset_Map::get_v(const Compound_Selector_Obj& sel)
   {
     return get_kv(sel);
   }

src/libsass/src/subset_map.hpp

@@ -60,15 +60,15 @@ namespace Sass {
 
   class Subset_Map {
   private:
-    std::vector<Subset_Map_Val> values_;
-    std::map<Simple_Selector_Obj, std::vector<std::pair<Compound_Selector_Obj, size_t> > > hash_;
+    std::vector<SubSetMapPair> values_;
+    std::map<Simple_Selector_Obj, std::vector<std::pair<Compound_Selector_Obj, size_t> >, OrderNodes > hash_;
   public:
-    void put(const Compound_Selector_Obj& sel, const Subset_Map_Val& value);
-    std::vector<Subset_Map_Val> get_kv(const Compound_Selector_Obj& s);
-    std::vector<Subset_Map_Val> get_v(const Compound_Selector_Obj& s);
+    void put(const Compound_Selector_Obj& sel, const SubSetMapPair& value);
+    std::vector<SubSetMapPair> get_kv(const Compound_Selector_Obj& s);
+    std::vector<SubSetMapPair> get_v(const Compound_Selector_Obj& s);
     bool empty() { return values_.empty(); }
     void clear() { values_.clear(); hash_.clear(); }
-    const std::vector<Subset_Map_Val> values(void) { return values_; }
+    const std::vector<SubSetMapPair> values(void) { return values_; }
   };
 
 }

src/libsass/src/to_c.cpp

@@ -36,7 +36,7 @@ namespace Sass {
 
   union Sass_Value* To_C::operator()(List_Ptr l)
   {
-    union Sass_Value* v = sass_make_list(l->length(), l->separator());
+    union Sass_Value* v = sass_make_list(l->length(), l->separator(), l->is_bracketed());
     for (size_t i = 0, L = l->length(); i < L; ++i) {
       sass_list_set_value(v, i, (*l)[i]->perform(this));
     }
@@ -57,7 +57,7 @@ namespace Sass {
 
   union Sass_Value* To_C::operator()(Arguments_Ptr a)
   {
-    union Sass_Value* v = sass_make_list(a->length(), SASS_COMMA);
+    union Sass_Value* v = sass_make_list(a->length(), SASS_COMMA, false);
     for (size_t i = 0, L = a->length(); i < L; ++i) {
       sass_list_set_value(v, i, (*a)[i]->perform(this));
     }

src/libsass/src/util.cpp

@@ -445,7 +445,7 @@ namespace Sass {
 
       Block_Obj b = r->block();
 
-      Selector_List_Ptr sl = SASS_MEMORY_CAST(Selector_List, r->selector());
+      Selector_List_Ptr sl = Cast<Selector_List>(r->selector());
       bool hasSelectors = sl ? sl->length() > 0 : false;
 
       if (!hasSelectors) {
@@ -456,16 +456,16 @@ namespace Sass {
       bool hasPrintableChildBlocks = false;
       for (size_t i = 0, L = b->length(); i < L; ++i) {
         Statement_Obj stm = b->at(i);
-        if (dynamic_cast<Directive_Ptr>(&stm)) {
+        if (Cast<Directive>(stm)) {
           return true;
-        } else if (Declaration_Ptr d = dynamic_cast<Declaration_Ptr>(&stm)) {
+        } else if (Declaration_Ptr d = Cast<Declaration>(stm)) {
           return isPrintable(d, style);
-        } else if (dynamic_cast<Has_Block_Ptr>(&stm)) {
-          Block_Obj pChildBlock = ((Has_Block_Ptr)&stm)->block();
-          if (isPrintable(&pChildBlock, style)) {
+        } else if (Has_Block_Ptr p = Cast<Has_Block>(stm)) {
+          Block_Obj pChildBlock = p->block();
+          if (isPrintable(pChildBlock, style)) {
             hasPrintableChildBlocks = true;
           }
-        } else if (Comment_Ptr c = dynamic_cast<Comment_Ptr>(&stm)) {
+        } else if (Comment_Ptr c = Cast<Comment>(stm)) {
           // keep for uncompressed
           if (style != COMPRESSED) {
             hasDeclarations = true;
@@ -499,8 +499,8 @@ namespace Sass {
     bool isPrintable(Declaration_Ptr d, Sass_Output_Style style)
     {
       Expression_Obj val = d->value();
-      if (String_Quoted_Obj sq = SASS_MEMORY_CAST(String_Quoted, val)) return isPrintable(&sq, style);
-      if (String_Constant_Obj sc = SASS_MEMORY_CAST(String_Constant, val)) return isPrintable(&sc, style);
+      if (String_Quoted_Obj sq = Cast<String_Quoted>(val)) return isPrintable(sq.ptr(), style);
+      if (String_Constant_Obj sc = Cast<String_Constant>(val)) return isPrintable(sc.ptr(), style);
       return true;
     }
 
@@ -511,18 +511,16 @@ namespace Sass {
 
       Block_Obj b = f->block();
 
-//      bool hasSelectors = f->selector() && static_cast<Selector_List_Ptr>(f->selector())->length() > 0;
-
       bool hasDeclarations = false;
       bool hasPrintableChildBlocks = false;
       for (size_t i = 0, L = b->length(); i < L; ++i) {
         Statement_Obj stm = b->at(i);
-        if (dynamic_cast<Declaration_Ptr>(&stm) || dynamic_cast<Directive_Ptr>(&stm)) {
+        if (Cast<Declaration>(stm) || Cast<Directive>(stm)) {
           hasDeclarations = true;
         }
-        else if (dynamic_cast<Has_Block_Ptr>(&stm)) {
-          Block_Obj pChildBlock = ((Has_Block_Ptr)&stm)->block();
-          if (isPrintable(&pChildBlock, style)) {
+        else if (Has_Block_Ptr b = Cast<Has_Block>(stm)) {
+          Block_Obj pChildBlock = b->block();
+          if (isPrintable(pChildBlock, style)) {
             hasPrintableChildBlocks = true;
           }
         }
@@ -542,36 +540,34 @@ namespace Sass {
       if (b == 0) return false;
       for (size_t i = 0, L = b->length(); i < L; ++i) {
         Statement_Obj stm = b->at(i);
-        if (dynamic_cast<Directive_Ptr>(&stm)) return true;
-        else if (dynamic_cast<Declaration_Ptr>(&stm)) return true;
-        else if (dynamic_cast<Comment_Ptr>(&stm)) {
-          Comment_Ptr c = (Comment_Ptr) &stm;
+        if (Cast<Directive>(stm)) return true;
+        else if (Cast<Declaration>(stm)) return true;
+        else if (Comment_Ptr c = Cast<Comment>(stm)) {
           if (isPrintable(c, style)) {
             return true;
           }
         }
-        else if (dynamic_cast<Ruleset_Ptr>(&stm)) {
-          Ruleset_Ptr r = (Ruleset_Ptr) &stm;
+        else if (Ruleset_Ptr r = Cast<Ruleset>(stm)) {
           if (isPrintable(r, style)) {
             return true;
           }
         }
-        else if (dynamic_cast<Supports_Block_Ptr>(&stm)) {
-          Supports_Block_Ptr f = (Supports_Block_Ptr) &stm;
+        else if (Supports_Block_Ptr f = Cast<Supports_Block>(stm)) {
           if (isPrintable(f, style)) {
             return true;
           }
         }
-        else if (dynamic_cast<Media_Block_Ptr>(&stm)) {
-          Media_Block_Ptr m = (Media_Block_Ptr) &stm;
+        else if (Media_Block_Ptr m = Cast<Media_Block>(stm)) {
           if (isPrintable(m, style)) {
             return true;
           }
         }
-        else if (dynamic_cast<Has_Block_Ptr>(&stm) && isPrintable(((Has_Block_Ptr)&stm)->block(), style)) {
+        else if (Has_Block_Ptr b = Cast<Has_Block>(stm)) {
+          if (isPrintable(b->block(), style)) {
             return true;
           }
         }
+      }
       return false;
     }
 
@@ -596,37 +592,35 @@ namespace Sass {
 
       for (size_t i = 0, L = b->length(); i < L; ++i) {
         Statement_Obj stm = b->at(i);
-        if (dynamic_cast<Declaration_Ptr>(&stm) || dynamic_cast<Directive_Ptr>(&stm)) {
+        if (Cast<Declaration>(stm) || Cast<Directive>(stm)) {
           return true;
         }
-        else if (dynamic_cast<Comment_Ptr>(&stm)) {
-          Comment_Ptr c = (Comment_Ptr) &stm;
+        else if (Comment_Ptr c = Cast<Comment>(stm)) {
           if (isPrintable(c, style)) {
             return true;
           }
         }
-        else if (dynamic_cast<Ruleset_Ptr>(&stm)) {
-          Ruleset_Ptr r = (Ruleset_Ptr) &stm;
+        else if (Ruleset_Ptr r = Cast<Ruleset>(stm)) {
           if (isPrintable(r, style)) {
             return true;
           }
         }
-        else if (dynamic_cast<Supports_Block_Ptr>(&stm)) {
-          Supports_Block_Ptr f = (Supports_Block_Ptr) &stm;
+        else if (Supports_Block_Ptr f = Cast<Supports_Block>(stm)) {
           if (isPrintable(f, style)) {
             return true;
           }
         }
-        else if (dynamic_cast<Media_Block_Ptr>(&stm)) {
-          Media_Block_Ptr m = (Media_Block_Ptr) &stm;
+        else if (Media_Block_Ptr m = Cast<Media_Block>(stm)) {
           if (isPrintable(m, style)) {
             return true;
           }
         }
-        else if (dynamic_cast<Has_Block_Ptr>(&stm) && isPrintable(((Has_Block_Ptr)&stm)->block(), style)) {
+        else if (Has_Block_Ptr b = Cast<Has_Block>(stm)) {
+          if (isPrintable(b->block(), style)) {
             return true;
           }
         }
+      }
 
       return false;
     }

src/libsass/src/values.cpp

@@ -11,32 +11,32 @@ namespace Sass {
   {
     if (val->concrete_type() == Expression::NUMBER)
     {
-      Number_Ptr_Const res = dynamic_cast<Number_Ptr_Const>(val);
+      Number_Ptr_Const res = Cast<Number>(val);
       return sass_make_number(res->value(), res->unit().c_str());
     }
     else if (val->concrete_type() == Expression::COLOR)
     {
-      Color_Ptr_Const col = dynamic_cast<Color_Ptr_Const>(val);
+      Color_Ptr_Const col = Cast<Color>(val);
       return sass_make_color(col->r(), col->g(), col->b(), col->a());
     }
     else if (val->concrete_type() == Expression::LIST)
     {
-      List_Ptr_Const l = dynamic_cast<List_Ptr_Const>(val);
-      union Sass_Value* list = sass_make_list(l->size(), l->separator());
+      List_Ptr_Const l = Cast<List>(val);
+      union Sass_Value* list = sass_make_list(l->size(), l->separator(), l->is_bracketed());
       for (size_t i = 0, L = l->length(); i < L; ++i) {
         Expression_Obj obj = l->at(i);
-        auto val = ast_node_to_sass_value(&obj);
+        auto val = ast_node_to_sass_value(obj);
         sass_list_set_value(list, i, val);
       }
       return list;
     }
     else if (val->concrete_type() == Expression::MAP)
     {
-      Map_Ptr_Const m = dynamic_cast<Map_Ptr_Const>(val);
+      Map_Ptr_Const m = Cast<Map>(val);
       union Sass_Value* map = sass_make_map(m->length());
       size_t i = 0; for (Expression_Obj key : m->keys()) {
-        sass_map_set_key(map, i, ast_node_to_sass_value(&key));
-        sass_map_set_value(map, i, ast_node_to_sass_value(&m->at(key)));
+        sass_map_set_key(map, i, ast_node_to_sass_value(key));
+        sass_map_set_value(map, i, ast_node_to_sass_value(m->at(key)));
         ++ i;
       }
       return map;
@@ -47,16 +47,16 @@ namespace Sass {
     }
     else if (val->concrete_type() == Expression::BOOLEAN)
     {
-      Boolean_Ptr_Const res = dynamic_cast<Boolean_Ptr_Const>(val);
+      Boolean_Ptr_Const res = Cast<Boolean>(val);
       return sass_make_boolean(res->value());
     }
     else if (val->concrete_type() == Expression::STRING)
     {
-      if (String_Quoted_Ptr_Const qstr = dynamic_cast<String_Quoted_Ptr_Const>(val))
+      if (String_Quoted_Ptr_Const qstr = Cast<String_Quoted>(val))
       {
         return sass_make_qstring(qstr->value().c_str());
       }
-      else if (String_Constant_Ptr_Const cstr = dynamic_cast<String_Constant_Ptr_Const>(val))
+      else if (String_Constant_Ptr_Const cstr = Cast<String_Constant>(val))
       {
         return sass_make_string(cstr->value().c_str());
       }
@@ -106,6 +106,7 @@ namespace Sass {
         for (size_t i = 0, L = sass_list_get_length(val); i < L; ++i) {
           l->append(sass_value_to_ast_node(sass_list_get_value(val, i)));
         }
+        l->is_bracketed(sass_list_get_is_bracketed(val));
         return l;
       }
       break;

src/libsass/win/libsass.targets

@@ -69,6 +69,7 @@
   <ItemGroup Label="LibSass Sources">
     <ClCompile Include="$(LIBSASS_SRC_DIR)\ast.cpp" />
     <ClCompile Include="$(LIBSASS_SRC_DIR)\memory\SharedPtr.cpp" />
+    <ClCompile Include="$(LIBSASS_SRC_DIR)\ast_fwd_decl.cpp" />
     <ClCompile Include="$(LIBSASS_SRC_DIR)\base64vlq.cpp" />
     <ClCompile Include="$(LIBSASS_SRC_DIR)\bind.cpp" />
     <ClCompile Condition="$(VisualStudioVersion) &lt; 14.0" Include="$(LIBSASS_SRC_DIR)\c99func.c" />

src/libsass/win/libsass.vcxproj.filters

@@ -218,6 +218,9 @@
     <ClCompile Include="$(LIBSASS_SRC_DIR)\memory\SharedPtr.cpp">
       <Filter>Sources</Filter>
     </ClCompile>
+    <ClCompile Include="$(LIBSASS_SRC_DIR)\ast_fwd_decl.cpp">
+      <Filter>Sources</Filter>
+    </ClCompile>
     <ClCompile Include="$(LIBSASS_SRC_DIR)\base64vlq.cpp">
       <Filter>Sources</Filter>
     </ClCompile>

src/sass_types/list.cpp

@@ -8,6 +8,7 @@ namespace SassTypes
   Sass_Value* List::construct(const std::vector<v8::Local<v8::Value>> raw_val, Sass_Value **out) {
     size_t length = 0;
     bool comma = true;
+    bool is_bracketed = false;
 
     if (raw_val.size() >= 1) {
       if (!raw_val[0]->IsNumber()) {
@@ -25,7 +26,7 @@ namespace SassTypes
       }
     }
 
-    return *out = sass_make_list(length, comma ? SASS_COMMA : SASS_SPACE);
+    return *out = sass_make_list(length, comma ? SASS_COMMA : SASS_SPACE, is_bracketed);
   }
 
   void List::initPrototype(v8::Local<v8::FunctionTemplate> proto) {