added libsass

libsass/.gitignore

+src/Makefile
+.DS_Store
+tmp/
+.sass-cache
+sassc
+build/*
+*.o
+*.a
+a.out
+bin/*
+*.gem

libsass/LICENSE

+
+Copyright (C) 2012 by Hampton Catlin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+
+The following files in the spec were taken from the original Ruby Sass project which
+is copyright Hampton Catlin, Nathan Weizenbaum, and Chris Eppstein and under
+the same license.

libsass/Makefile

+
+CPP_FILES = \
+	context.cpp \
+	functions.cpp \
+	document.cpp \
+	document_parser.cpp \
+	eval_apply.cpp \
+	node.cpp \
+	node_comparisons.cpp \
+	values.cpp \
+	prelexer.cpp
+
+libsass: libsass_objs
+	ar rvs libsass.a \
+			sass_interface.o \
+			context.o \
+			functions.o \
+			document.o \
+			document_parser.o \
+			eval_apply.o \
+			node.o \
+			node_comparisons.o \
+			values.o \
+			prelexer.o
+
+libsass_objs: sass_interface.cpp $(CPP_FILES)
+	g++ -O2 -c -combine sass_interface.cpp $(CPP_FILES)
+
+clean:
+	rm -rf *.o *.a
\ No newline at end of file

libsass/Readme.md

+Libsass
+=======
+
+by Aaron Leung and Hampton Catlin (@hcatlin)
+
+http://github.com/hcatlin/libsass
+
+Libsass is just a library, but if you want to RUN libsass,
+then go to http://github.com/hcatlin/sassc or
+http://github.com/hcatlin/sassruby or find your local 
+implementer.
+
+About
+-----
+
+Libsass is a C/C++ port of the Sass CSS precompiler. The original version was written in Ruby, but this version is meant for efficiency and portability.
+
+This library strives to be light, simple, and easy to build and integrate with a variety of platforms and languages.
+
+Usage
+-----
+
+While libsass is primarily implemented in C++, it provides a simple
+C interface that is defined in [sass_inteface.h]. Its usage is pretty
+straight forward.
+
+First, you create a sass context struct. We use these objects to define
+different execution parameters for the library. There are three 
+different context types. 
+
+    sass_context        //string-in-string-out compilation
+    sass_file_context   //file-based compilation
+    sass_folder_context //full-folder multi-file 
+
+Each of the context's have slightly different behavior and are
+implemented seperately. This does add extra work to implementing
+a wrapper library, but we felt that a mixed-use context object
+provides for too much implicit logic. What if you set "input_string"
+AND "input_file"... what do we do? This would introduce bugs into
+wrapper libraries that would be difficult to debug. 
+
+We anticipate that most adapters in most languages will define
+their own logic for how to separate these use cases based on the
+language. For instance, the original Ruby interface has a combined
+interface, but is backed by three different processes.
+
+To generate a context, use one of the following methods.
+
+    new_sass_context()
+    new_sass_file_context()
+    new_sass_folder_context()
+
+Again, please see the sass_interface.h for more information.
+
+And, to get even more information, then please see the implementations
+in SassC and SassC-Ruby.
+
+About Sass
+----------
+
+Sass is a CSS pre-processor language to add on exciting, new, 
+awesome features to CSS. Sass was the first language of its kind
+and by far the most mature and up to date codebase.
+
+Sass was originally created by the co-creator of this library, 
+Hampton Catlin (@hcatlin). The extension and continuing evolution
+of the language has all been the result of years of work by Nathan
+Weizenbaum (@nex3) and Chris Eppstein (@chriseppstein). 
+
+For more information about Sass itself, please visit http://sass-lang.com
+
+Contribution Agreement
+----------------------
+
+Any contribution to the project are seen as copyright assigned to Hampton Catlin. Your contribution warrants that you have the right to assign copyright on your work. This is to ensure that the project remains free and open -- similar to the Apache Foundation.
+
+Our license is designed to be as simple as possible.
+
+

libsass/context.cpp

+#include "context.hpp"
+#include <iostream>
+using std::cerr; using std::endl;
+
+namespace Sass {
+  using std::pair;
+  
+  void Context::collect_include_paths(const char* paths_str)
+  {
+    const size_t wd_len = 1024;
+    char wd[wd_len];
+    include_paths.push_back(getcwd(wd, wd_len));
+    if (*include_paths.back().rbegin() != '/') include_paths.back() += '/';
+
+    if (paths_str) {
+      const char* beg = paths_str;
+      const char* end = Prelexer::find_first<':'>(beg);
+
+      while (end) {
+        string path(beg, end - beg);
+        if (!path.empty()) {
+          if (*path.rbegin() != '/') path += '/';
+          include_paths.push_back(path);
+        }
+        beg = end + 1;
+        end = Prelexer::find_first<':'>(beg);
+      }
+
+      string path(beg);
+      if (!path.empty()) {
+        if (*path.rbegin() != '/') path += '/';
+        include_paths.push_back(path);
+      }
+    }
+
+    // for (int i = 0; i < include_paths.size(); ++i) {
+    //   cerr << include_paths[i] << endl;
+    // }
+  }
+  
+  Context::Context(const char* paths_str)
+  : global_env(Environment()),
+    function_env(map<pair<string, size_t>, Function>()),
+    source_refs(vector<char*>()),
+    registry(vector<vector<Node>*>()),
+    include_paths(vector<string>()),
+    ref_count(0)
+  {
+    register_functions();
+    collect_include_paths(paths_str);
+  }
+  
+  Context::~Context()
+  {
+    int i;
+    for (i = 0; i < source_refs.size(); ++i) {
+      delete[] source_refs[i];
+    }
+    // cerr << "Deallocated " << i << " source string(s)." << endl;
+  }
+  
+  inline void Context::register_function(Function_Descriptor d, Implementation ip)
+  {
+    Function f(d, ip);
+    function_env[pair<string, size_t>(f.name, f.parameters.size())] = f;
+  }
+  
+  inline void Context::register_function(Function_Descriptor d, Implementation ip, size_t arity)
+  {
+    Function f(d, ip);
+    function_env[pair<string, size_t>(f.name, arity)] = f;
+  }
+  
+  void Context::register_functions()
+  {
+    using namespace Functions;
+    // RGB Functions
+    register_function(rgb_descriptor,  rgb);
+    register_function(rgba_4_descriptor, rgba_4);
+    register_function(rgba_2_descriptor, rgba_2);
+    register_function(red_descriptor, red);
+    register_function(green_descriptor, green);
+    register_function(blue_descriptor, blue);
+    register_function(mix_2_descriptor, mix_2);
+    register_function(mix_3_descriptor, mix_3);
+    // HSL Functions
+    register_function(hsla_descriptor, hsla);
+    register_function(hsl_descriptor, hsl);
+    register_function(invert_descriptor, invert);
+    // Opacity Functions
+    register_function(alpha_descriptor, alpha);
+    register_function(opacity_descriptor, alpha);
+    register_function(opacify_descriptor, opacify);
+    register_function(fade_in_descriptor, opacify);
+    register_function(transparentize_descriptor, transparentize);
+    register_function(fade_out_descriptor, transparentize);
+    // String Functions
+    register_function(unquote_descriptor, unquote);
+    register_function(quote_descriptor, quote);
+    // Number Functions
+    register_function(percentage_descriptor, percentage);
+    register_function(round_descriptor, round);
+    register_function(ceil_descriptor, ceil);
+    register_function(floor_descriptor, floor);
+    register_function(abs_descriptor, abs);
+    // List Functions
+    register_function(length_descriptor, length);
+    register_function(nth_descriptor, nth);
+    register_function(join_2_descriptor, join_2);
+    register_function(join_3_descriptor, join_3);
+    // Introspection Functions
+    register_function(type_of_descriptor, type_of);
+    register_function(unit_descriptor, unit);
+    register_function(unitless_descriptor, unitless);
+    register_function(comparable_descriptor, comparable);
+    // Boolean Functions
+    register_function(not_descriptor, not_impl);
+  }
+  
+}
\ No newline at end of file

libsass/context.hpp

+#define SASS_CONTEXT_INCLUDED
+
+
+#include <utility>
+#include <map>
+#include "functions.hpp"
+
+namespace Sass {
+  using std::pair;
+  using std::map;
+  
+  struct Environment {
+    map<Token, Node> current_frame;
+    Environment* parent;
+    Environment* global;
+    
+    Environment()
+    : current_frame(map<Token, Node>()), parent(0), global(0)
+    { }
+    
+    void link(Environment& env)
+    {
+      parent = &env;
+      global = parent->global ? parent->global : parent;
+    }
+    
+    bool query(const Token& key) const
+    {
+      if (current_frame.count(key)) return true;
+      else if (parent)              return parent->query(key);
+      else                          return false;
+    }
+    
+    Node& operator[](const Token& key)
+    {
+      if (current_frame.count(key)) return current_frame[key];
+      else if (parent)              return (*parent)[key];
+      else                          return current_frame[key];
+    }
+  };
+
+  struct Context {
+    string sass_path;
+    string css_path;
+    vector<string> include_paths;
+    Environment global_env;
+    map<pair<string, size_t>, Function> function_env;
+    vector<char*> source_refs; // all the source c-strings
+    vector<vector<Node>*> registry; // all the child vectors
+    size_t ref_count;
+    
+    void collect_include_paths(const char* paths_str);
+    Context(const char* paths_str = 0);
+    ~Context();
+    
+    void register_function(Function_Descriptor d, Implementation ip);
+    void register_function(Function_Descriptor d, Implementation ip, size_t arity);
+    void register_functions();
+  };
+
+}

libsass/css_color_names.txt

+AliceBlue 		#F0F8FF
+AntiqueWhite 		#FAEBD7
+Aqua 			#00FFFF
+Aquamarine 		#7FFFD4
+Azure 			#F0FFFF
+Beige 			#F5F5DC
+Bisque 			#FFE4C4
+Black 			#000000
+BlanchedAlmond	 	#FFEBCD
+Blue 			#0000FF
+BlueViolet 		#8A2BE2
+Brown 			#A52A2A
+BurlyWood 		#DEB887
+CadetBlue 		#5F9EA0
+Chartreuse 		#7FFF00
+Chocolate 		#D2691E
+Coral 			#FF7F50
+CornflowerBlue 		#6495ED
+Cornsilk 		#FFF8DC
+Crimson 		#DC143C
+Cyan 			#00FFFF
+DarkBlue 		#00008B
+DarkCyan 		#008B8B
+DarkGoldenRod 		#B8860B
+DarkGray 		#A9A9A9
+DarkGrey 		#A9A9A9
+DarkGreen 		#006400
+DarkKhaki 		#BDB76B
+DarkMagenta 		#8B008B
+DarkOliveGreen	 	#556B2F
+Darkorange 		#FF8C00
+DarkOrchid 		#9932CC
+DarkRed 		#8B0000
+DarkSalmon 		#E9967A
+DarkSeaGreen 		#8FBC8F
+DarkSlateBlue 		#483D8B
+DarkSlateGray 		#2F4F4F
+DarkSlateGrey 		#2F4F4F
+DarkTurquoise 		#00CED1
+DarkViolet 		#9400D3
+DeepPink 		#FF1493
+DeepSkyBlue 		#00BFFF
+DimGray 		#696969
+DimGrey 		#696969
+DodgerBlue 		#1E90FF
+FireBrick 		#B22222
+FloralWhite 		#FFFAF0
+ForestGreen 		#228B22
+Fuchsia 		#FF00FF
+Gainsboro 		#DCDCDC
+GhostWhite 		#F8F8FF
+Gold 			#FFD700
+GoldenRod 		#DAA520
+Gray 			#808080
+Grey 			#808080
+Green 			#008000
+GreenYellow 		#ADFF2F
+HoneyDew 		#F0FFF0
+HotPink 		#FF69B4
+IndianRed  		#CD5C5C
+Indigo  		#4B0082
+Ivory 			#FFFFF0
+Khaki 			#F0E68C
+Lavender 		#E6E6FA
+LavenderBlush 		#FFF0F5
+LawnGreen 		#7CFC00
+LemonChiffon 		#FFFACD
+LightBlue 		#ADD8E6
+LightCoral 		#F08080
+LightCyan 		#E0FFFF
+LightGoldenRodYellow 	#FAFAD2
+LightGray 		#D3D3D3
+LightGrey 		#D3D3D3
+LightGreen 		#90EE90
+LightPink 		#FFB6C1
+LightSalmon 		#FFA07A
+LightSeaGreen 		#20B2AA
+LightSkyBlue 		#87CEFA
+LightSlateGray 		#778899
+LightSlateGrey 		#778899
+LightSteelBlue 		#B0C4DE
+LightYellow 		#FFFFE0
+Lime 			#00FF00
+LimeGreen 		#32CD32
+Linen 			#FAF0E6
+Magenta 		#FF00FF
+Maroon 			#800000
+MediumAquaMarine 	#66CDAA
+MediumBlue 		#0000CD
+MediumOrchid 		#BA55D3
+MediumPurple 		#9370D8
+MediumSeaGreen 		#3CB371
+MediumSlateBlue 	#7B68EE
+MediumSpringGreen 	#00FA9A
+MediumTurquoise 	#48D1CC
+MediumVioletRed 	#C71585
+MidnightBlue 		#191970
+MintCream 		#F5FFFA
+MistyRose 		#FFE4E1
+Moccasin 		#FFE4B5
+NavajoWhite 		#FFDEAD
+Navy 			#000080
+OldLace 		#FDF5E6
+Olive 			#808000
+OliveDrab 		#6B8E23
+Orange 			#FFA500
+OrangeRed 		#FF4500
+Orchid		 	#DA70D6
+PaleGoldenRod 		#EEE8AA
+PaleGreen 		#98FB98
+PaleTurquoise 		#AFEEEE
+PaleVioletRed 		#D87093
+PapayaWhip 		#FFEFD5
+PeachPuff 		#FFDAB9
+Peru 			#CD853F
+Pink 			#FFC0CB
+Plum 			#DDA0DD
+PowderBlue 		#B0E0E6
+Purple 			#800080
+Red 			#FF0000
+RosyBrown 		#BC8F8F
+RoyalBlue 		#4169E1
+SaddleBrown 		#8B4513
+Salmon 			#FA8072
+SandyBrown 		#F4A460
+SeaGreen 		#2E8B57
+SeaShell 		#FFF5EE
+Sienna 			#A0522D
+Silver 			#C0C0C0
+SkyBlue 		#87CEEB
+SlateBlue 		#6A5ACD
+SlateGray 		#708090
+SlateGrey 		#708090
+Snow 			#FFFAFA
+SpringGreen 		#00FF7F
+SteelBlue 		#4682B4
+Tan 			#D2B48C
+Teal 			#008080
+Thistle 		#D8BFD8
+Tomato 			#FF6347
+Turquoise 		#40E0D0
+Violet 			#EE82EE
+Wheat 			#F5DEB3
+White 			#FFFFFF
+WhiteSmoke 		#F5F5F5
+Yellow 			#FFFF00
+YellowGreen 		#9ACD32
\ No newline at end of file

libsass/document.cpp

+#include <cstdio>
+#include <cstring>
+#include "document.hpp"
+#include "eval_apply.hpp"
+#include "error.hpp"
+#include <iostream>
+
+namespace Sass {
+  
+  Document::Document(char* path_str, char* source_str, Context& ctx)
+  : path(string()),
+    source(source_str),
+    line_number(1),
+    context(ctx),
+    root(Node(Node::root, context.registry, 1)),
+    lexed(Token::make())
+  {
+    if (source_str) {
+      own_source = false;
+      position = source;
+      end = position + std::strlen(source);
+    }
+    else if (path_str) {
+      path = string(path_str);
+      std::FILE *f;
+      // TO DO: CHECK f AGAINST NULL/0
+      f = std::fopen(path.c_str(), "rb");
+      std::fseek(f, 0, SEEK_END);
+      int len = std::ftell(f);
+      std::rewind(f);
+      // TO DO: WRAP THE new[] IN A TRY/CATCH BLOCK
+      source = new char[len + 1];
+      std::fread(source, sizeof(char), len, f);
+      source[len] = '\0';
+      end = source + len;
+      std::fclose(f);
+      own_source = true;
+      position = source;
+      context.source_refs.push_back(source);
+    }
+    else {
+      // report an error
+    }
+    ++context.ref_count;
+  }
+      
+
+  Document::Document(string path, char* source)
+  : path(path), source(source),
+    line_number(1), own_source(false),
+    context(*(new Context())),
+    root(Node(Node::root, context.registry, 1)),
+    lexed(Token::make())
+  {
+    if (!source) {
+      std::FILE *f;
+      f = std::fopen(path.c_str(), "rb");
+      if (!f) throw path;
+      if (std::fseek(f, 0, SEEK_END)) throw path;
+      int len = std::ftell(f);
+      if (len < 0) throw path;
+      std::rewind(f);
+      // TO DO: CATCH THE POTENTIAL badalloc EXCEPTION
+      source = new char[len + 1];
+      std::fread(source, sizeof(char), len, f);
+      if (std::ferror(f)) throw path;
+      source[len] = '\0';
+      end = source + len;
+      if (std::fclose(f)) throw path;
+      own_source = true;
+    }
+    position = source;
+    context.source_refs.push_back(source);
+    ++context.ref_count;
+  }
+  
+  Document::Document(string path, Context& context)
+  : path(path), source(0),
+    line_number(1), own_source(false),
+    context(context),
+    root(Node(Node::root, context.registry, 1)),
+    lexed(Token::make())
+  {
+    std::FILE *f;
+    f = std::fopen(path.c_str(), "rb");
+    if (!f) throw path;
+    if (std::fseek(f, 0, SEEK_END)) throw path;
+    int len = std::ftell(f);
+    if (len < 0) throw path;
+    std::rewind(f);
+    // TO DO: CATCH THE POTENTIAL badalloc EXCEPTION
+    source = new char[len + 1];
+    std::fread(source, sizeof(char), len, f);
+    if (std::ferror(f)) throw path;
+    source[len] = '\0';
+    end = source + len;
+    if (std::fclose(f)) throw path;
+    position = source;
+    context.source_refs.push_back(source);
+    ++context.ref_count;
+  }
+  
+  Document::Document(const string& path, size_t line_number, Token t, Context& context)
+  : path(path),
+    source(const_cast<char*>(t.begin)),
+    position(t.begin),
+    end(t.end),
+    line_number(line_number),
+    own_source(false),
+    context(context),
+    root(Node(Node::root, context.registry, 1)),
+    lexed(Token::make())
+  { }
+
+  Document::~Document() {
+    --context.ref_count;
+    // if (context.ref_count == 0) delete &context;
+  }
+  
+  void Document::syntax_error(string message, size_t ln)
+  { throw Error(Error::syntax, ln ? ln : line_number, path, message); }
+  
+  void Document::read_error(string message, size_t ln)
+  { throw Error(Error::read, ln ? ln : line_number, path, message); }
+  
+  using std::string;
+  using std::stringstream;
+  using std::endl;
+  
+  string Document::emit_css(CSS_Style style) {
+    stringstream output;
+    switch (style) {
+    case echo:
+      root.echo(output);
+      break;
+    case nested:
+      root.emit_nested_css(output, 0, vector<string>());
+      break;
+    case expanded:
+      root.emit_expanded_css(output, "");
+      break;
+    }
+    string retval(output.str());
+    if (!retval.empty()) retval.resize(retval.size()-1);
+    return retval;
+  }
+}
\ No newline at end of file

libsass/document.hpp

+#include <map>
+
+#ifndef SASS_NODE_INCLUDED
+#include "node.hpp"
+#endif
+
+#include "context.hpp"
+
+namespace Sass {
+  using std::string;
+  using std::vector;
+  using std::map;
+  using namespace Prelexer;
+
+  struct Document {
+    enum CSS_Style { nested, expanded, compact, compressed, echo };
+    
+    string path;
+    char* source;
+    const char* position;
+    const char* end;
+    size_t line_number;
+    bool own_source;
+
+    Context& context;
+    
+    Node root;
+    Token lexed;
+    
+    Document(char* path_str, char* source_str, Context& ctx);
+    Document(string path, char* source = 0);
+    Document(string path, Context& context);
+    Document(const string& path, size_t line_number, Token t, Context& context);
+    ~Document();
+    
+    template <prelexer mx>
+    const char* peek(const char* start = 0)
+    {
+      if (!start) start = position;
+      const char* after_whitespace;
+      if (mx == block_comment) {
+        after_whitespace = // start;
+          zero_plus< alternatives<spaces, line_comment> >(start);
+      }
+      else if (/*mx == ancestor_of ||*/ mx == no_spaces) {
+        after_whitespace = position;
+      }
+      else if (mx == spaces || mx == ancestor_of) {
+        after_whitespace = mx(start);
+        if (after_whitespace) {
+          return after_whitespace;
+        }
+        else {
+          return 0;
+        }
+      }
+      else if (mx == optional_spaces) {
+        after_whitespace = optional_spaces(start);
+      }
+      else {
+        after_whitespace = spaces_and_comments(start);
+      }
+      const char* after_token = mx(after_whitespace);
+      if (after_token) {
+        return after_token;
+      }
+      else {
+        return 0;
+      }
+    }
+    
+    template <prelexer mx>
+    const char* lex()
+    {
+      const char* after_whitespace;
+      if (mx == block_comment) {
+        after_whitespace = // position;
+          zero_plus< alternatives<spaces, line_comment> >(position);
+      }
+      else if (mx == ancestor_of || mx == no_spaces) {
+        after_whitespace = position;
+      }
+      else if (mx == spaces) {
+        after_whitespace = spaces(position);
+        if (after_whitespace) {
+          line_number += count_interval<'\n'>(position, after_whitespace);
+          lexed = Token::make(position, after_whitespace);
+          return position = after_whitespace;
+        }
+        else {
+          return 0;
+        }
+      }
+      else if (mx == optional_spaces) {
+        after_whitespace = optional_spaces(position);
+      }
+      else {
+        after_whitespace = spaces_and_comments(position);
+      }
+      const char* after_token = mx(after_whitespace);
+      if (after_token) {
+        line_number += count_interval<'\n'>(position, after_token);
+        lexed = Token::make(after_whitespace, after_token);
+        return position = after_token;
+      }
+      else {
+        return 0;
+      }
+    }
+    
+    void parse_scss();
+    Node parse_import();
+    Node parse_include();
+    Node parse_mixin_definition();
+    Node parse_mixin_parameters();
+    Node parse_parameter();
+    Node parse_mixin_call();
+    Node parse_arguments();
+    Node parse_argument();
+    Node parse_assignment();
+    Node parse_propset();
+    Node parse_ruleset(bool definition = false);
+    Node parse_selector_group();
+    Node parse_selector();
+    Node parse_selector_combinator();
+    Node parse_simple_selector_sequence();
+    Node parse_simple_selector();
+    Node parse_pseudo();
+    Node parse_attribute_selector();
+    Node parse_block(bool definition = false);
+    Node parse_rule();
+    Node parse_values();
+    Node parse_list();
+    Node parse_comma_list();
+    Node parse_space_list();
+    Node parse_disjunction();
+    Node parse_conjunction();
+    Node parse_relation();
+    Node parse_expression();
+    Node parse_term();
+    Node parse_factor();
+    Node parse_value();
+    Node parse_identifier();
+    Node parse_variable();
+    Node parse_function_call();
+    Node parse_string();
+    Node parse_value_schema();
+    
+    const char* lookahead_for_selector(const char* start = 0);
+    
+    const char* look_for_rule(const char* start = 0);
+    const char* look_for_values(const char* start = 0);
+    
+    const char* look_for_selector_group(const char* start = 0);
+    const char* look_for_selector(const char* start = 0);
+    const char* look_for_simple_selector_sequence(const char* start = 0);
+    const char* look_for_simple_selector(const char* start = 0);
+    const char* look_for_pseudo(const char* start = 0);
+    const char* look_for_attrib(const char* start = 0);
+    
+    void syntax_error(string message, size_t ln = 0);
+    void read_error(string message, size_t ln = 0);
+    
+    string emit_css(CSS_Style style);
+
+  };
+}
\ No newline at end of file

libsass/error.hpp

+namespace Sass {
+  
+  struct Error {
+    enum Type { read, write, syntax, evaluation };
+    
+    Type type;
+    size_t line_number;
+    string file_name;
+    string message;
+    
+    Error(Type type, size_t line_number, string file_name, string message)
+    : type(type), line_number(line_number), file_name(file_name), message(message)
+    { }
+
+  };
+  
+}
\ No newline at end of file

libsass/eval_apply.hpp

+#include <map>
+
+#ifndef SASS_NODE_INCLUDED
+#include "node.hpp"
+#endif
+
+#ifndef SASS_CONTEXT_INCLUDED
+#include "context.hpp"
+#endif
+
+namespace Sass {
+  using std::map;
+  
+  Node eval(Node& expr, Environment& env, map<pair<string, size_t>, Function>& f_env, vector<vector<Node>*>& registry);
+  Node accumulate(Node::Type op, Node& acc, Node& rhs, vector<vector<Node>*>& registry);
+  double operate(Node::Type op, double lhs, double rhs);
+  
+  Node apply_mixin(Node& mixin, const Node& args, Environment& env, map<pair<string, size_t>, Function>& f_env, vector<vector<Node>*>& registry);
+  Node apply_function(const Function& f, const Node& args, Environment& env, map<pair<string, size_t>, Function>& f_env, vector<vector<Node>*>& registry);
+}
\ No newline at end of file

libsass/extconf.rb

+require 'mkmf'
+# .. more stuff
+#$LIBPATH.push(Config::CONFIG['libdir'])
+$CFLAGS << " #{ENV["CFLAGS"]}"
+$LIBS << " #{ENV["LIBS"]}"
+create_makefile("libsass")

libsass/functions.hpp

+#include <cstring>
+#include <map>
+
+#ifndef SASS_NODE_INCLUDED
+#include "node.hpp"
+#endif
+
+namespace Sass {
+  using std::map;
+  
+  typedef Node (*Implementation)(const vector<Token>&, map<Token, Node>&, vector<vector<Node>*>& registry);
+  typedef const char* str;
+  typedef str Function_Descriptor[];
+  
+  struct Function {
+    
+    string name;
+    vector<Token> parameters;
+    Implementation implementation;
+    
+    Function()
+    { /* TO DO: set up the generic callback here */ }
+    
+    Function(Function_Descriptor d, Implementation ip)
+    : name(d[0]),
+      parameters(vector<Token>()),
+      implementation(ip)
+    {
+      size_t len = 0;
+      while (d[len+1]) ++len;
+      
+      parameters.reserve(len);
+      for (int i = 0; i < len; ++i) {
+        const char* p = d[i+1];
+        Token name(Token::make(p, p + std::strlen(p)));
+        parameters.push_back(name);
+      }
+    }
+    
+    Node operator()(map<Token, Node>& bindings, vector<vector<Node>*>& registry) const
+    { return implementation(parameters, bindings, registry); }
+
+  };
+  
+  namespace Functions {
+
+    // RGB Functions ///////////////////////////////////////////////////////
+
+    extern Function_Descriptor rgb_descriptor;
+    Node rgb(const vector<Token>& parameters, map<Token, Node>& bindings, vector<vector<Node>*>& registry);
+
+    extern Function_Descriptor rgba_4_descriptor;
+    Node rgba_4(const vector<Token>& parameters, map<Token, Node>& bindings, vector<vector<Node>*>& registry);
+    
+    extern Function_Descriptor rgba_2_descriptor;
+    Node rgba_2(const vector<Token>& parameters, map<Token, Node>& bindings, vector<vector<Node>*>& registry);
+    
+    extern Function_Descriptor red_descriptor;
+    Node red(const vector<Token>& parameters, map<Token, Node>& bindings, vector<vector<Node>*>& registry);
+    
+    extern Function_Descriptor green_descriptor;
+    Node green(const vector<Token>& parameters, map<Token, Node>& bindings, vector<vector<Node>*>& registry);
+    
+    extern Function_Descriptor blue_descriptor;
+    Node blue(const vector<Token>& parameters, map<Token, Node>& bindings, vector<vector<Node>*>& registry);
+    
+    extern Function_Descriptor mix_2_descriptor;
+    Node mix_2(const vector<Token>& parameters, map<Token, Node>& bindings, vector<vector<Node>*>& registry);
+    
+    extern Function_Descriptor mix_3_descriptor;
+    Node mix_3(const vector<Token>& parameters, map<Token, Node>& bindings, vector<vector<Node>*>& registry);
+    
+    // HSL Functions ///////////////////////////////////////////////////////
+    
+    extern Function_Descriptor hsla_descriptor;
+    Node hsla(const vector<Token>& parameters, map<Token, Node>& bindings, vector<vector<Node>*>& registry);
+    
+    extern Function_Descriptor hsl_descriptor;
+    Node hsl(const vector<Token>& parameters, map<Token, Node>& bindings, vector<vector<Node>*>& registry);
+
+    extern Function_Descriptor invert_descriptor;
+    Node invert(const vector<Token>& parameters, map<Token, Node>& bindings, vector<vector<Node>*>& registry);
+    
+    // Opacity Functions ///////////////////////////////////////////////////
+
+    extern Function_Descriptor alpha_descriptor;
+    extern Function_Descriptor opacity_descriptor;
+    Node alpha(const vector<Token>& parameters, map<Token, Node>& bindings, vector<vector<Node>*>& registry);
+    
+    extern Function_Descriptor opacify_descriptor;
+    extern Function_Descriptor fade_in_descriptor;
+    Node opacify(const vector<Token>& parameters, map<Token, Node>& bindings, vector<vector<Node>*>& registry);
+    
+    extern Function_Descriptor transparentize_descriptor;
+    extern Function_Descriptor fade_out_descriptor;
+    Node transparentize(const vector<Token>& parameters, map<Token, Node>& bindings, vector<vector<Node>*>& registry);
+    
+    // String Functions ////////////////////////////////////////////////////
+
+    extern Function_Descriptor unquote_descriptor;
+    Node unquote(const vector<Token>& parameters, map<Token, Node>& bindings, vector<vector<Node>*>& registry);
+    
+    extern Function_Descriptor quote_descriptor;
+    Node quote(const vector<Token>& parameters, map<Token, Node>& bindings, vector<vector<Node>*>& registry);
+    
+    // Number Functions ////////////////////////////////////////////////////
+
+    extern Function_Descriptor percentage_descriptor;
+    Node percentage(const vector<Token>& parameters, map<Token, Node>& bindings, vector<vector<Node>*>& registry);
+
+    extern Function_Descriptor round_descriptor;
+    Node round(const vector<Token>& parameters, map<Token, Node>& bindings, vector<vector<Node>*>& registry);
+
+    extern Function_Descriptor ceil_descriptor;
+    Node ceil(const vector<Token>& parameters, map<Token, Node>& bindings, vector<vector<Node>*>& registry);
+
+    extern Function_Descriptor floor_descriptor;
+    Node floor(const vector<Token>& parameters, map<Token, Node>& bindings, vector<vector<Node>*>& registry);
+
+    extern Function_Descriptor abs_descriptor;    
+    Node abs(const vector<Token>& parameters, map<Token, Node>& bindings, vector<vector<Node>*>& registry);
+    
+    // List Functions //////////////////////////////////////////////////////
+    
+    extern Function_Descriptor length_descriptor;
+    Node length(const vector<Token>& parameters, map<Token, Node>& bindings, vector<vector<Node>*>& registry);
+
+    extern Function_Descriptor nth_descriptor;
+    Node nth(const vector<Token>& parameters, map<Token, Node>& bindings, vector<vector<Node>*>& registry);
+
+    extern Function_Descriptor join_2_descriptor;    
+    Node join_2(const vector<Token>& parameters, map<Token, Node>& bindings, vector<vector<Node>*>& registry);
+    
+    extern Function_Descriptor join_3_descriptor;    
+    Node join_3(const vector<Token>& parameters, map<Token, Node>& bindings, vector<vector<Node>*>& registry);
+    
+    // Introspection Functions /////////////////////////////////////////////
+    
+    extern Function_Descriptor type_of_descriptor;
+    Node type_of(const vector<Token>& parameters, map<Token, Node>& bindings, vector<vector<Node>*>& registry);
+
+    extern Function_Descriptor unit_descriptor;
+    Node unit(const vector<Token>& parameters, map<Token, Node>& bindings, vector<vector<Node>*>& registry);
+    
+    extern Function_Descriptor unitless_descriptor;    
+    Node unitless(const vector<Token>& parameters, map<Token, Node>& bindings, vector<vector<Node>*>& registry);
+    
+    extern Function_Descriptor comparable_descriptor;    
+    Node comparable(const vector<Token>& parameters, map<Token, Node>& bindings, vector<vector<Node>*>& registry);
+    
+    // Boolean Functions ///////////////////////////////////////////////////
+    
+    extern Function_Descriptor not_descriptor;
+    Node not_impl(const vector<Token>& parameters, map<Token, Node>& bindings, vector<vector<Node>*>& registry);
+
+  }
+  
+}

libsass/node.hpp

+#define SASS_NODE_INCLUDED
+
+#include <vector>
+#include <sstream>
+#include "values.hpp"
+#include <iostream>
+
+namespace Sass {
+  using std::string;
+  using std::vector;
+  using std::stringstream;
+  using std::cerr; using std::endl;
+
+  struct Node {
+    enum Type {
+      root,
+      ruleset,
+      propset,
+
+      selector_group,
+      selector,
+      selector_combinator,
+      simple_selector_sequence,
+      backref,
+      simple_selector,
+      type_selector,
+      class_selector,
+      id_selector,
+      pseudo,
+      pseudo_negation,
+      functional_pseudo,
+      attribute_selector,
+
+      block,
+      rule,
+      property,
+
+      nil,
+      comma_list,
+      space_list,
+      
+      disjunction,
+      conjunction,
+      
+      relation,
+      eq,
+      neq,
+      gt,
+      gte,
+      lt,
+      lte,
+
+      expression,
+      add,
+      sub,
+
+      term,
+      mul,
+      div,
+
+      factor,
+      unary_plus,
+      unary_minus,
+      values,
+      value,
+      identifier,
+      uri,
+      textual_percentage,
+      textual_dimension,
+      textual_number,
+      textual_hex,
+      color_name,
+      string_constant,
+      numeric_percentage,
+      numeric_dimension,
+      number,
+      numeric_color,
+      boolean,
+      important,
+      
+      value_schema,
+      string_schema,
+      
+      css_import,
+      function_call,
+      mixin,
+      parameters,
+      expansion,
+      arguments,
+
+      variable,
+      assignment,
+
+      comment,
+      none,
+      flags
+    };
+
+    Type type;
+    unsigned int line_number;
+
+    bool has_children;
+    bool has_statements;
+    bool has_blocks;
+    bool has_expansions;
+    bool has_backref;
+    bool from_variable;
+    bool eval_me;
+    bool unquoted;
+
+    union {
+      Token token;
+      mutable vector<Node>* children;
+      Dimension dimension;
+      double numeric_value;
+      bool boolean_value;
+    } content;
+    
+    const char* file_name;
+    
+    static size_t allocations;
+    static size_t destructed;
+    
+    void clear()
+    {
+      type           = none;  line_number    = 0;     file_name     = 0;
+      has_children   = false; has_statements = false; has_blocks    = false;
+      has_expansions = false; has_backref    = false; from_variable = false;
+      eval_me        = false; unquoted       = false;
+    }
+    
+    size_t size() const
+    { return content.children->size(); }
+    
+    Node& operator[](const size_t i) const
+    { return content.children->at(i); }
+    
+    Node& at(const size_t i) const
+    { return content.children->at(i); }
+    
+    Node& operator<<(const Node& n)
+    {
+      content.children->push_back(n);
+      return *this;
+    }
+    
+    bool is_numeric() const
+    {
+      switch (type)
+      {
+        case number:
+        case numeric_percentage:
+        case numeric_dimension:
+          return true;
+          break;
+        default:
+          return false;
+      }
+    }
+    
+    double numeric_value() const
+    {
+      switch (type)
+      {
+        case number:
+        case numeric_percentage:
+          return content.numeric_value;
+        case numeric_dimension:
+          return content.dimension.numeric_value;
+        default:
+          break;
+          // throw an exception?
+      }
+    }
+    
+    void set_numeric_value(double v)
+    {
+        switch (type)
+        {
+          case number:
+          case numeric_percentage:
+            content.numeric_value = v;
+          case numeric_dimension:
+            content.dimension.numeric_value = v;
+          default:
+            break;
+            // throw an exception?
+        }
+      }
+    
+    Node& operator+=(const Node& n)
+    {
+      for (int i = 0; i < n.size(); ++i) {
+        content.children->push_back(n[i]);
+      }
+      return *this;
+    }
+    
+    bool operator==(const Node& rhs) const;
+    bool operator!=(const Node& rhs) const;
+    bool operator<(const Node& rhs) const;
+    bool operator<=(const Node& rhs) const;
+    bool operator>(const Node& rhs) const;
+    bool operator>=(const Node& rhs) const;
+    
+    string to_string(const string& prefix) const;
+        
+    void echo(stringstream& buf, size_t depth = 0);
+    void emit_nested_css(stringstream& buf,
+                         size_t depth,
+                         const vector<string>& prefixes);
+    void emit_nested_css(stringstream& buf, size_t depth);
+    void emit_propset(stringstream& buf, size_t depth, const string& prefix);
+    void emit_expanded_css(stringstream& buf, const string& prefix);
+    
+    Node clone(vector<vector<Node>*>& registry) const;
+    void flatten();
+    
+    Node()
+    { clear(); }
+
+    Node(Type t) // flags or booleans
+    { clear(); type = t; }
+
+    Node(Type t, vector<vector<Node>*>& registry, unsigned int ln, size_t s = 0) // nodes with children
+    {
+      clear();
+      type = t;
+      line_number = ln;
+      content.children = new vector<Node>;
+      registry.push_back(content.children);
+      content.children->reserve(s);
+      has_children = true;
+      ++allocations;
+    }
+    
+    Node(Type t, unsigned int ln, const Token& tok) // nodes with a single token
+    {
+      clear();
+      type = t;
+      line_number = ln;
+      content.token = tok;
+    }
+    
+    Node(unsigned int ln, double val) // numeric values
+    {
+      clear();
+      type = number;
+      line_number = ln;
+      content.numeric_value = val;
+    }
+    
+    Node(unsigned int ln, double val, const Token& tok) // dimensions
+    {
+      clear();
+      type = numeric_dimension;
+      line_number = ln;
+      content.dimension = Dimension();
+      content.dimension.numeric_value = val;
+      content.dimension.unit = tok.begin;
+    }
+    
+    Node(vector<vector<Node>*>& registry, unsigned int ln, double r, double g, double b, double a = 1.0) // colors
+    {
+      clear();
+      type = numeric_color;
+      line_number = ln;
+      content.children = new vector<Node>;
+      registry.push_back(content.children);
+      content.children->reserve(4);
+      content.children->push_back(Node(ln, r));
+      content.children->push_back(Node(ln, g));
+      content.children->push_back(Node(ln, b));
+      content.children->push_back(Node(ln, a));
+      has_children = true;
+      ++allocations;
+    }
+    
+    ~Node() { ++destructed; }
+  };
+}
\ No newline at end of file

libsass/node_comparisons.cpp

+#include <iostream>
+#include <iomanip>
+#include <string>
+#include <cctype>
+#include <cstdlib>
+#include <cmath>
+#include "node.hpp"
+#include "error.hpp"
+
+using std::string;
+using std::stringstream;
+using std::cout;
+using std::cerr;
+using std::endl;
+
+namespace Sass {
+  
+  bool Node::operator==(const Node& rhs) const
+  {
+    if (type != rhs.type) return false;
+    
+    switch (type)
+    {
+      case comma_list:
+      case space_list:
+      case expression:
+      case term: {
+        for (int i = 0; i < size(); ++i) {
+          if (at(i) == rhs[i]) continue;
+          else return false;
+        }
+        return true;
+      } break;
+      
+      case variable:
+      case identifier:
+      case uri:
+      case textual_percentage:
+      case textual_dimension:
+      case textual_number:
+      case textual_hex:
+      case string_constant: {
+        return content.token.unquote() == rhs.content.token.unquote();
+      } break;
+      
+      case number:
+      case numeric_percentage: {
+        return numeric_value() == rhs.numeric_value();
+      } break;
+      
+      case numeric_dimension: {
+        if (Token::make(content.dimension.unit, Prelexer::identifier(content.dimension.unit)) ==
+            Token::make(rhs.content.dimension.unit, Prelexer::identifier(rhs.content.dimension.unit))) {
+          return numeric_value() == rhs.numeric_value();
+        }
+        else {
+          return false;
+        }
+      } break;
+      
+      case boolean: {
+        return content.boolean_value == rhs.content.boolean_value;
+      } break;
+      
+      default: {
+        return true;
+      } break;
+      
+    }
+  }
+  
+  bool Node::operator!=(const Node& rhs) const
+  { return !(*this == rhs); }
+  
+  bool Node::operator<(const Node& rhs) const
+  {
+    if (type == number && rhs.type == number ||
+        type == numeric_percentage && rhs.type == numeric_percentage) {
+      return numeric_value() < rhs.numeric_value();
+    }
+    else if (type == numeric_dimension && rhs.type == numeric_dimension) {
+      if (Token::make(content.dimension.unit, Prelexer::identifier(content.dimension.unit)) ==
+          Token::make(rhs.content.dimension.unit, Prelexer::identifier(rhs.content.dimension.unit))) {
+        return numeric_value() < rhs.numeric_value();
+      }
+      else {
+        throw Error(Error::evaluation, line_number, file_name, "incompatible units");
+      }
+    }
+    else {
+      throw Error(Error::evaluation, line_number, file_name, "incomparable types");
+    }
+  }
+  
+  bool Node::operator<=(const Node& rhs) const
+  { return *this < rhs || *this == rhs; }
+  
+  bool Node::operator>(const Node& rhs) const
+  { return !(*this <= rhs); }
+  
+  bool Node::operator>=(const Node& rhs) const
+  { return !(*this < rhs); }
+  
+}
\ No newline at end of file

libsass/sass_interface.cpp

+#include <iostream>
+#include <sstream>
+#include <string>
+#include <cstdlib>
+#include <unistd.h>
+#include <iostream>
+#include "document.hpp"
+#include "eval_apply.hpp"
+#include "error.hpp"
+#include "sass_interface.h"
+
+extern "C" {
+
+  using namespace std;
+  sass_context* sass_new_context()
+    { return (sass_context*) malloc(sizeof(sass_context)); }
+  
+  void sass_free_context(sass_context* ctx)
+  { 
+    free(ctx->output_string);
+    free(ctx);
+  }
+
+  sass_file_context* sass_new_file_context()
+    { return (sass_file_context*) malloc(sizeof(sass_file_context)); }
+  
+  void sass_free_file_context(sass_file_context* ctx)
+  { 
+    free(ctx->output_string);
+    free(ctx);
+  }
+  
+  sass_folder_context* sass_new_folder_context()
+    { return (sass_folder_context*) malloc(sizeof(sass_folder_context)); }
+  
+  static char* process_document(Sass::Document& doc, int style)
+  {
+    using namespace Sass;
+    doc.parse_scss();
+    // cerr << "PARSED" << endl;
+    eval(doc.root, doc.context.global_env, doc.context.function_env, doc.context.registry);
+    // cerr << "EVALUATED" << endl;
+    string output(doc.emit_css(static_cast<Document::CSS_Style>(style)));
+    // cerr << "EMITTED" << endl;
+    
+    // cerr << "Allocations:\t" << Node::allocations << endl;
+    // cerr << "Destructions:\t" << Node::destructed << endl;
+    // cerr << "Registry size:\t" << doc.context.registry.size() << endl;
+    
+    int i;
+    for (i = 0; i < doc.context.registry.size(); ++i) {
+      delete doc.context.registry[i];
+    }
+    // cerr << "Deallocations:\t" << i << endl;
+    
+    char* c_output = (char*) malloc(output.size() + 1);
+    strcpy(c_output, output.c_str());
+    return c_output;
+  }
+
+  int sass_compile(sass_context* c_ctx)
+  {
+    using namespace Sass;
+    try {
+      Context cpp_ctx(c_ctx->options.include_paths);
+      Document doc(0, c_ctx->input_string, cpp_ctx);
+      c_ctx->output_string = process_document(doc, c_ctx->options.output_style);
+      c_ctx->error_message = 0;
+      c_ctx->error_status = 0;
+    }
+    catch (Error& e) {
+      stringstream msg_stream;
+      msg_stream << "ERROR -- " << e.file_name << ", line " << e.line_number << ": " << e.message << endl;
+      string msg(msg_stream.str());
+      char* msg_str = (char*) malloc(msg.size() + 1);
+      strcpy(msg_str, msg.c_str());
+      c_ctx->error_status = 1;
+      c_ctx->output_string = 0;
+      c_ctx->error_message = msg_str;
+    }
+    catch(bad_alloc& ba) {
+      stringstream msg_stream;
+      msg_stream << "ERROR -- unable to allocate memory: " << ba.what() << endl;
+      string msg(msg_stream.str());
+      char* msg_str = (char*) malloc(msg.size() + 1);
+      strcpy(msg_str, msg.c_str());
+      c_ctx->error_status = 1;
+      c_ctx->output_string = 0;
+      c_ctx->error_message = msg_str;
+    }
+    // TO DO: CATCH EVERYTHING ELSE
+    return 0;
+  }
+  
+  int sass_compile_file(sass_file_context* c_ctx)
+  {
+    using namespace Sass;
+    try {
+      Context cpp_ctx(c_ctx->options.include_paths);
+      Document doc(c_ctx->input_path, 0, cpp_ctx);
+      // cerr << "MADE A DOC AND CONTEXT OBJ" << endl;
+      // cerr << "REGISTRY: " << doc.context.registry.size() << endl;
+      c_ctx->output_string = process_document(doc, c_ctx->options.output_style);
+      c_ctx->error_message = 0;
+      c_ctx->error_status = 0;
+    }
+    catch (Error& e) {
+      stringstream msg_stream;
+      msg_stream << "ERROR -- " << e.file_name << ", line " << e.line_number << ": " << e.message << endl;
+      string msg(msg_stream.str());
+      char* msg_str = (char*) malloc(msg.size() + 1);
+      strcpy(msg_str, msg.c_str());
+      c_ctx->error_status = 1;
+      c_ctx->output_string = 0;
+      c_ctx->error_message = msg_str;
+    }
+    catch(bad_alloc& ba) {
+      stringstream msg_stream;
+      msg_stream << "ERROR -- unable to allocate memory: " << ba.what() << endl;
+      string msg(msg_stream.str());
+      char* msg_str = (char*) malloc(msg.size() + 1);
+      strcpy(msg_str, msg.c_str());
+      c_ctx->error_status = 1;
+      c_ctx->output_string = 0;
+      c_ctx->error_message = msg_str;
+    }
+    // TO DO: CATCH EVERYTHING ELSE
+    return 0;
+  }
+  
+  int sass_compile_folder(sass_folder_context* c_ctx)
+  {
+    return 1;
+  }
+
+}
\ No newline at end of file

libsass/sass_interface.h

+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define SASS_STYLE_NESTED     0;
+#define SASS_STYLE_EXPANDED   1;
+#define SASS_STYLE_COMPACT    2;
+#define SASS_STYLE_COMPRESSED 3;
+
+struct sass_options {
+  int output_style;
+  char* include_paths;
+};
+
+struct sass_context {
+  char* input_string;
+  char* output_string;
+  struct sass_options options;
+  int error_status;
+  char* error_message;
+};
+
+struct sass_file_context {
+  char* input_path;
+  char* output_string;
+  struct sass_options options;
+  int error_status;
+  char* error_message;
+};
+
+struct sass_folder_context {
+  char* search_path;
+  char* output_path;
+  struct sass_options options;
+  int error_status;
+  char* error_message;
+};
+
+struct sass_context*        sass_new_context        ();
+struct sass_file_context*   sass_new_file_context   ();
+struct sass_folder_context* sass_new_folder_context ();
+
+void sass_free_context        (struct sass_context* ctx);
+void sass_free_file_context   (struct sass_file_context* ctx);
+void sass_free_folder_context (struct sass_folder_context* ctx);
+
+int sass_compile            (struct sass_context* ctx);
+int sass_compile_file       (struct sass_file_context* ctx);
+int sass_compile_folder     (struct sass_folder_context* ctx);
+
+#ifdef __cplusplus
+}
+#endif
\ No newline at end of file

libsass/values.cpp

+#include "values.hpp"
+
+namespace Sass {
+  // Token::Token() : begin(0), end(0) { }
+  // Token::Token(const char* begin, const char* end)
+  // : begin(begin), end(end) { }
+  
+  string Token::unquote() const {
+    string result;
+    const char* p = begin;
+    if (*begin == '\'' || *begin == '"') {
+      ++p;
+      while (p < end) {
+        if (*p == '\\') {
+          switch (*(++p)) {
+            case 'n':  result += '\n'; break;
+            case 't':  result += '\t'; break;
+            case 'b':  result += '\b'; break;
+            case 'r':  result += '\r'; break;
+            case 'f':  result += '\f'; break;
+            case 'v':  result += '\v'; break;
+            case 'a':  result += '\a'; break;
+            case '\\': result += '\\'; break;
+            default: result += *p; break;
+          }
+        }
+        else if (p == end - 1) {
+          return result;
+        }
+        else {
+          result += *p;
+        }
+        ++p;
+      }
+      return result;
+    }
+    else {
+      while (p < end) {
+        result += *(p++);
+      }
+      return result;
+    }
+  }
+  
+  void Token::unquote_to_stream(std::stringstream& buf) const {
+    const char* p = begin;
+    if (*begin == '\'' || *begin == '"') {
+      ++p;
+      while (p < end) {
+        if (*p == '\\') {
+          switch (*(++p)) {
+            case 'n':  buf << '\n'; break;
+            case 't':  buf << '\t'; break;
+            case 'b':  buf << '\b'; break;
+            case 'r':  buf << '\r'; break;
+            case 'f':  buf << '\f'; break;
+            case 'v':  buf << '\v'; break;
+            case 'a':  buf << '\a'; break;
+            case '\\': buf << '\\'; break;
+            default: buf << *p; break;
+          }
+        }
+        else if (p == end - 1) {
+          return;
+        }
+        else {
+          buf << *p;
+        }
+        ++p;
+      }
+      return;
+    }
+    else {
+      while (p < end) {
+        buf << *(p++);
+      }
+      return;
+    }
+  }
+  
+  bool Token::operator<(const Token& rhs) const
+  {
+    const char* first1 = begin;
+    const char* last1  = end;
+    const char* first2 = rhs.begin;
+    const char* last2  = rhs.end;
+    while (first1!=last1)
+    {
+      if (first2==last2 || *first2<*first1) return false;
+      else if (*first1<*first2) return true;
+      first1++; first2++;
+    }
+    return (first2!=last2);
+  }
+  
+  bool Token::operator==(const Token& rhs) const
+  {
+    if (length() != rhs.length()) return false;
+    
+    if ((begin[0]     == '"' || begin[0]     == '\'') &&
+        (rhs.begin[0] == '"' || rhs.begin[0] == '\''))
+    { return unquote() == rhs.unquote(); }
+    
+    const char* p = begin;
+    const char* q = rhs.begin;
+    for (; p < end; ++p, ++q) if (*p != *q) return false;
+    return true;
+  }
+    
+}
\ No newline at end of file

libsass/values.hpp

+#include <string>
+#include <sstream>
+#include <cstring>
+
+#ifndef SASS_PRELEXER_INCLUDED
+#include "prelexer.hpp"
+#endif
+
+namespace Sass {
+  using std::string;
+  
+  struct Token {
+    const char* begin;
+    const char* end;
+
+    // Token();
+    // Token(const char* begin, const char* end);
+    
+    size_t length() const
+    { return end - begin; }
+
+    inline operator string() const
+    { return string(begin, end - begin); }
+    
+    string to_string() const
+    { return string(begin, end - begin); }
+
+    string unquote() const;
+    void unquote_to_stream(std::stringstream& buf) const;
+    
+    bool operator<(const Token& rhs) const;
+    bool operator==(const Token& rhs) const;
+    
+    operator bool()
+    { return begin && end && begin >= end; }
+    
+    static Token make()
+    {
+      Token t;
+      t.begin = 0;
+      t.end = 0;
+      return t;
+    }
+    
+    static Token make(const char* s)
+    {
+      Token t;
+      t.begin = s;
+      t.end = s + std::strlen(s);
+      return t;
+    }
+    
+    static Token make(const char* b, const char* e)
+    {
+      Token t;
+      t.begin = b;
+      t.end = e;
+      return t;
+    }
+    
+    
+  };
+  
+  struct Dimension {
+    double numeric_value;
+    const char* unit;
+  };
+}
\ No newline at end of file