sassc 1.11.4 → 1.12.0

data/ext/libsass/appveyor.yml

@@ -7,8 +7,13 @@ environment:
   matrix:
   - Compiler: msvc
     Config: Release
+    Platform: Win32
   - Compiler: msvc
     Config: Debug
+    Platform: Win32
+  - Compiler: msvc
+    Config: Release
+    Platform: Win64
   - Compiler: mingw
     Build: static
   - Compiler: mingw
@@ -38,7 +43,7 @@ build_script:
       if ($env:Compiler -eq "mingw") {
         mingw32-make -j4 sassc
       } else {
-        msbuild /m:4 /p:Configuration=$env:Config sassc\win\sassc.sln
+        msbuild /m:4 /p:"Configuration=$env:Config;Platform=$env:Platform" sassc\win\sassc.sln
       }
 
       # print the branding art
@@ -65,7 +70,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
@@ -84,4 +89,3 @@ test_script:
       } else {
         echo "Success!"
       }
-

data/ext/libsass/configure.ac

@@ -9,6 +9,7 @@ AC_CONFIG_MACRO_DIR([m4])
 AC_CONFIG_HEADERS([src/config.h])
 AC_CONFIG_FILES([include/sass/version.h])
 AC_CONFIG_AUX_DIR([script])
+
 # These are flags passed to automake
 # Though they look like gcc flags!
 AM_INIT_AUTOMAKE([foreign parallel-tests -Wall])
@@ -93,21 +94,16 @@ the --with-sass-spec-dir=<dir> argument.
       ;;
   esac
   AC_SUBST(SASS_SPEC_PATH)
-
-  # TODO: Remove this when automake requirements are 1.12+
-  AC_MSG_CHECKING([whether we can use TAP mode])
-  tmp=`$AWK '/TEST_LOG_DRIVER/' $srcdir/GNUmakefile.in`
-  if test "x$tmp" != "x"; then
-    use_tap=yes
-  else
-    use_tap=no
-  fi
-  AC_MSG_RESULT([$use_tap])
-
+else
+  # we do not really need these paths for non test build
+  # but automake may error if we do not define them here
+  SASS_SPEC_PATH=sass-spec
+  SASS_SASSC_PATH=sassc
+  AC_SUBST(SASS_SPEC_PATH)
+  AC_SUBST(SASS_SASSC_PATH)
 fi
 
 AM_CONDITIONAL(ENABLE_TESTS, test "x$enable_tests" = "xyes")
-AM_CONDITIONAL(USE_TAP, test "x$use_tap" = "xyes")
 
 AC_ARG_ENABLE([coverage],
   [AS_HELP_STRING([--enable-coverage],
@@ -121,8 +117,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)

data/ext/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;
 };
 ```
 

data/ext/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

data/ext/libsass/docs/api-doc.md

@@ -1,6 +1,9 @@
 ## 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,23 +176,36 @@ 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)
+2. [Go Example](https://godoc.org/github.com/wellington/go-libsass#example-Compiler--Stdin)
 3. [Node Example](https://github.com/sass/node-sass/blob/master/src/binding.cpp)
 
 ## 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
 

data/ext/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

data/ext/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

data/ext/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