Updated libsass

libsass/Makefile

@@ -11,7 +11,7 @@ CPP_FILES = \
 	prelexer.cpp
 
 libsass: libsass_objs
-	ar rs libsass.a \
+	ar rvs libsass.a \
 			sass_interface.o \
 			context.o \
 			functions.o \
@@ -24,7 +24,7 @@ libsass: libsass_objs
 			prelexer.o
 
 libsass_objs: sass_interface.cpp $(CPP_FILES)
-	g++ -O2 -c -combine sass_interface.cpp $(CPP_FILES)
+	g++ -O2 -Wall -c -combine sass_interface.cpp $(CPP_FILES)
 
 clean:
 	rm -rf *.o *.a
\ No newline at end of file

libsass/context.cpp

@@ -52,8 +52,7 @@ namespace Sass {
   
   Context::~Context()
   {
-    int i;
-    for (i = 0; i < source_refs.size(); ++i) {
+    for (size_t i = 0; i < source_refs.size(); ++i) {
       delete[] source_refs[i];
     }
     // cerr << "Deallocated " << i << " source string(s)." << endl;
@@ -117,4 +116,4 @@ namespace Sass {
     register_function(not_descriptor, not_impl);
   }
   
-}
+}
\ No newline at end of file

libsass/context.hpp

@@ -40,14 +40,14 @@ namespace Sass {
   };
 
   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
+    vector<string> include_paths;
     size_t ref_count;
+    string sass_path;
+    string css_path;
     
     void collect_include_paths(const char* paths_str);
     Context(const char* paths_str = 0);

libsass/document.cpp

@@ -139,9 +139,11 @@ namespace Sass {
     case expanded:
       root.emit_expanded_css(output, "");
       break;
+    default:
+      break;
     }
     string retval(output.str());
     if (!retval.empty()) retval.resize(retval.size()-1);
     return retval;
   }
-}
+}
\ No newline at end of file

libsass/document_parser.cpp

@@ -85,6 +85,8 @@ namespace Sass {
     catch (string& path) {
       read_error("error reading file \"" + path + "\"");
     }
+    // unreached statement
+    return Node(Node::none); 
   }
 
   Node Document::parse_mixin_definition()
@@ -370,10 +372,9 @@ namespace Sass {
     else if (peek< exactly<'['> >(position)) {
       return parse_attribute_selector();
     }
-    else {
-      syntax_error("invalid selector after " + lexed.to_string());
-    }
-  }
+    syntax_error("invalid selector after " + lexed.to_string());
+    // unreached statement
+    return Node(Node::none);}
   
   Node Document::parse_pseudo() {
     if (lex< pseudo_not >()) {
@@ -420,9 +421,9 @@ namespace Sass {
     else if (lex < sequence< pseudo_prefix, identifier > >()) {
       return Node(Node::pseudo, line_number, lexed);
     }
-    else {
-      syntax_error("unrecognized pseudo-class or pseudo-element");
-    }
+    syntax_error("unrecognized pseudo-class or pseudo-element");
+    // unreached statement
+    return Node(Node::none);
   }
   
   Node Document::parse_attribute_selector()
@@ -477,7 +478,7 @@ namespace Sass {
           block.has_statements = true;
         }
         else {
-          for (int i = 0; i < imported_tree.size(); ++i) {
+          for (size_t i = 0; i < imported_tree.size(); ++i) {
             if (imported_tree[i].type == Node::comment ||
                 imported_tree[i].type == Node::rule) {
               block[0].has_statements = true;
@@ -503,16 +504,7 @@ namespace Sass {
         block << parse_propset();
         block[0].has_statements = true;
       }
-      // else if (look_for_rule(position)) {
-      //   block << parse_rule();
-      //   block.has_statements = true;
-      //   semicolon = true;
-      // }
-      // else if (!peek< exactly<';'> >()) {
-      //   block << parse_ruleset();
-      //   block.has_blocks = true;
-      // }
-      else if (const char* p = lookahead_for_selector(position)) {
+      else if (lookahead_for_selector(position)) {
         block << parse_ruleset(definition);
         block[0].has_blocks = true;
       }
@@ -834,6 +826,8 @@ namespace Sass {
     }
     
     syntax_error("error reading values after " + lexed.to_string());
+    // unreached statement
+    return Node(Node::none);
   }
   
   extern const char hash_lbrace[] = "#{";
@@ -852,7 +846,8 @@ namespace Sass {
     
     Node schema(Node::string_schema, context.registry, line_number, 1);
     while (i < str.end) {
-      if (p = find_first_in_interval< sequence< negate< exactly<'\\'> >, exactly<hash_lbrace> > >(i, str.end)) {
+      p = find_first_in_interval< sequence< negate< exactly<'\\'> >, exactly<hash_lbrace> > >(i, str.end);
+      if (p) {
         if (i < p) schema << Node(Node::identifier, line_number, Token::make(i, p)); // accumulate the preceding segment if it's nonempty
         const char* j = find_first_in_interval< exactly<rbrace> >(p, str.end); // find the closing brace
         if (j) {
@@ -1122,4 +1117,4 @@ namespace Sass {
 //     
 //     return p;
 //   }
-// }
+// }
\ No newline at end of file

libsass/eval_apply.cpp

@@ -45,7 +45,7 @@ namespace Sass {
       } break;
       
       case Node::root: {
-        for (int i = 0; i < expr.size(); ++i) {
+        for (size_t i = 0; i < expr.size(); ++i) {
           eval(expr[i], env, f_env, registry);
         }
         return expr;
@@ -54,7 +54,7 @@ namespace Sass {
       case Node::block: {
         Environment current;
         current.link(env);
-        for (int i = 0; i < expr.size(); ++i) {
+        for (size_t i = 0; i < expr.size(); ++i) {
           eval(expr[i], current, f_env, registry);
         }
         return expr;
@@ -63,7 +63,7 @@ namespace Sass {
       case Node::assignment: {
         Node val(expr[1]);
         if (val.type == Node::comma_list || val.type == Node::space_list) {
-          for (int i = 0; i < val.size(); ++i) {
+          for (size_t i = 0; i < val.size(); ++i) {
             if (val[i].eval_me) val[i] = eval(val[i], env, f_env, registry);
           }
         }
@@ -83,7 +83,7 @@ namespace Sass {
       case Node::rule: {
         Node rhs(expr[1]);
         if (rhs.type == Node::comma_list || rhs.type == Node::space_list) {
-          for (int i = 0; i < rhs.size(); ++i) {
+          for (size_t i = 0; i < rhs.size(); ++i) {
             if (rhs[i].eval_me) rhs[i] = eval(rhs[i], env, f_env, registry);
           }
         }
@@ -104,7 +104,7 @@ namespace Sass {
       
       case Node::disjunction: {
         Node result;
-        for (int i = 0; i < expr.size(); ++i) {
+        for (size_t i = 0; i < expr.size(); ++i) {
           // if (expr[i].type == Node::relation ||
           //     expr[i].type == Node::function_call && expr[0].content.token.to_string() == "not") {
           result = eval(expr[i], env, f_env, registry);
@@ -116,7 +116,7 @@ namespace Sass {
       
       case Node::conjunction: {
         Node result;
-        for (int i = 0; i < expr.size(); ++i) {
+        for (size_t i = 0; i < expr.size(); ++i) {
           result = eval(expr[i], env, f_env, registry);
           if (result.type == Node::boolean && result.content.boolean_value == false) return result;
         }
@@ -142,6 +142,9 @@ namespace Sass {
           case Node::gte: return (lhs >= rhs) ? T : F;
           case Node::lt:  return (lhs < rhs)  ? T : F;
           case Node::lte: return (lhs <= rhs) ? T : F;
+          default:
+            eval_error("unknown comparison operator " + expr.content.token.to_string(), expr.line_number, expr.file_name);
+            return Node(Node::none);
         }
       } break;
 
@@ -150,7 +153,7 @@ namespace Sass {
         acc << eval(expr[0], env, f_env, registry);
         Node rhs(eval(expr[2], env, f_env, registry));
         accumulate(expr[1].type, acc, rhs, registry);
-        for (int i = 3; i < expr.size(); i += 2) {
+        for (size_t i = 3; i < expr.size(); i += 2) {
           Node rhs(eval(expr[i+1], env, f_env, registry));
           accumulate(expr[i].type, acc, rhs, registry);
         }
@@ -163,7 +166,7 @@ namespace Sass {
           acc << eval(expr[0], env, f_env, registry);
           Node rhs(eval(expr[2], env, f_env, registry));
           accumulate(expr[1].type, acc, rhs, registry);
-          for (int i = 3; i < expr.size(); i += 2) {
+          for (size_t i = 3; i < expr.size(); i += 2) {
             Node rhs(eval(expr[i+1], env, f_env, registry));
             accumulate(expr[i].type, acc, rhs, registry);
           }
@@ -248,7 +251,7 @@ namespace Sass {
       case Node::string_schema:
       case Node::value_schema: {
         // cerr << "evaluating schema of size " << expr.size() << endl;
-        for (int i = 0; i < expr.size(); ++i) {
+        for (size_t i = 0; i < expr.size(); ++i) {
           expr[i] = eval(expr[i], env, f_env, registry);
         }
         return expr;
@@ -258,6 +261,8 @@ namespace Sass {
         return expr;
       }
     }
+
+    return expr;
   }
 
   Node accumulate(Node::Type op, Node& acc, Node& rhs, vector<vector<Node>*>& registry)
@@ -367,13 +372,13 @@ namespace Sass {
     Node body(mixin[2].clone(registry));
     Environment bindings;
     // bind arguments
-    for (int i = 0, j = 0; i < args.size(); ++i) {
+    for (size_t i = 0, j = 0; i < args.size(); ++i) {
       if (args[i].type == Node::assignment) {
         Node arg(args[i]);
         Token name(arg[0].content.token);
         // check that the keyword arg actually names a formal parameter
         bool valid_param = false;
-        for (int k = 0; k < params.size(); ++k) {
+        for (size_t k = 0; k < params.size(); ++k) {
           Node param_k = params[k];
           if (param_k.type == Node::assignment) param_k = param_k[0];
           if (arg[0] == param_k) {
@@ -400,7 +405,7 @@ namespace Sass {
       }
     }
     // plug the holes with default arguments if any
-    for (int i = 0; i < params.size(); ++i) {
+    for (size_t i = 0; i < params.size(); ++i) {
       if (params[i].type == Node::assignment) {
         Node param(params[i]);
         Token name(param[0].content.token);
@@ -411,7 +416,7 @@ namespace Sass {
     }
     // lexically link the new environment and eval the mixin's body
     bindings.link(env.global ? *env.global : env);
-    for (int i = 0; i < body.size(); ++i) {
+    for (size_t i = 0; i < body.size(); ++i) {
       body[i] = eval(body[i], bindings, f_env, registry);
     }
     return body;
@@ -421,7 +426,7 @@ namespace Sass {
   {
     map<Token, Node> bindings;
     // bind arguments
-    for (int i = 0, j = 0; i < args.size(); ++i) {
+    for (size_t i = 0, j = 0; i < args.size(); ++i) {
       if (args[i].type == Node::assignment) {
         Node arg(args[i]);
         Token name(arg[0].content.token);
@@ -436,4 +441,4 @@ namespace Sass {
     return f(bindings, registry);
   }
 
-}
+}
\ No newline at end of file

libsass/functions.cpp

@@ -568,12 +568,11 @@ namespace Sass {
       else if (!n1.is_numeric() && !n2.is_numeric()) {
         eval_error("arguments to comparable must be numeric", n1.line_number, n1.file_name);
       }
-      else {
-        Node F(Node::boolean);
-        F.line_number = n1.line_number;
-        F.content.boolean_value = false;
-        return F;
-      }
+      
+      Node F(Node::boolean);
+      F.line_number = n1.line_number;
+      F.content.boolean_value = false;
+      return F;
     }
     
     // Boolean Functions ///////////////////////////////////////////////////
@@ -597,4 +596,4 @@ namespace Sass {
     
     
   }
-}
+}
\ No newline at end of file

libsass/functions.hpp

@@ -30,7 +30,7 @@ namespace Sass {
       while (d[len+1]) ++len;
       
       parameters.reserve(len);
-      for (int i = 0; i < len; ++i) {
+      for (size_t i = 0; i < len; ++i) {
         const char* p = d[i+1];
         Token name(Token::make(p, p + std::strlen(p)));
         parameters.push_back(name);

libsass/node.cpp

@@ -23,7 +23,7 @@ namespace Sass {
       n.content.children = new vector<Node>;
       ++allocations;
       n.content.children->reserve(size());
-      for (int i = 0; i < size(); ++i) {
+      for (size_t i = 0; i < size(); ++i) {
         n << at(i).clone(registry);
       }
       registry.push_back(n.content.children);
@@ -37,7 +37,7 @@ namespace Sass {
     {
       case selector_group: { // really only needed for arg to :not
         string result(at(0).to_string(""));
-        for (int i = 1; i < size(); ++i) {
+        for (size_t i = 1; i < size(); ++i) {
           result += ", ";
           result += at(i).to_string("");
         }
@@ -60,11 +60,9 @@ namespace Sass {
         //   result += at(0).to_string(t == backref ? prefix : "");
         // }
         
-        Node::Type t = at(0).type;
         result += at(0).to_string(at(0).has_backref ? prefix : "");
 
-        for (int i = 1; i < size(); ++i) {
-          Node::Type t = at(i).type;
+        for (size_t i = 1; i < size(); ++i) {
           result += " ";
           result += at(i).to_string(at(i).has_backref ? prefix : "");
         }
@@ -86,7 +84,7 @@ namespace Sass {
           result += prefix;
           result += " ";
         }
-        for (int i = 0; i < size(); ++i) {
+        for (size_t i = 0; i < size(); ++i) {
           Node::Type t = at(i).type;
           result += at(i).to_string(t == backref ? prefix : "");
         }
@@ -114,7 +112,7 @@ namespace Sass {
         string result(prefix);
         if (!prefix.empty()) result += " ";
         result += at(0).to_string("");
-        for (int i = 1; i < size(); ++i) {
+        for (size_t i = 1; i < size(); ++i) {
           result += at(i).to_string("");
         }
         result += ')';
@@ -125,7 +123,7 @@ namespace Sass {
         string result(prefix);
         if (!prefix.empty()) result += " ";
         result += "[";
-        for (int i = 0; i < size(); ++i)
+        for (size_t i = 0; i < size(); ++i)
         { result += at(i).to_string(prefix); }
         result += ']';
         return result;
@@ -137,7 +135,7 @@ namespace Sass {
       
       case comma_list: {
         string result(at(0).to_string(prefix));
-        for (int i = 1; i < size(); ++i) {
+        for (size_t i = 1; i < size(); ++i) {
           if (at(i).type == nil) continue;
           result += ", ";
           result += at(i).to_string(prefix);
@@ -147,7 +145,7 @@ namespace Sass {
       
       case space_list: {
         string result(at(0).to_string(prefix));
-        for (int i = 1; i < size(); ++i) {
+        for (size_t i = 1; i < size(); ++i) {
           if (at(i).type == nil) continue;
           result += " ";
           result += at(i).to_string(prefix);
@@ -158,7 +156,7 @@ namespace Sass {
       case expression:
       case term: {
         string result(at(0).to_string(prefix));
-        for (int i = 1; i < size(); ++i) {
+        for (size_t i = 1; i < size(); ++i) {
           if (!(at(i).type == add ||
                 // at(i).type == sub ||  // another edge case -- consider uncommenting
                 at(i).type == mul)) {
@@ -199,7 +197,7 @@ namespace Sass {
         stringstream ss;
         if (size() > 0) {
           ss << at(0).to_string("");
-          for (int i = 1; i < size(); ++i) {
+          for (size_t i = 1; i < size(); ++i) {
             ss << ", ";
             ss << at(i).to_string("");
           }
@@ -269,7 +267,7 @@ namespace Sass {
           {
             stringstream ss;
             ss << '#' << std::setw(2) << std::setfill('0') << std::hex;
-            for (int i = 0; i < 3; ++i) {
+            for (size_t i = 0; i < 3; ++i) {
               double x = at(i).content.numeric_value;
               if (x > 0xff) x = 0xff;
               else if (x < 0) x = 0;
@@ -281,7 +279,7 @@ namespace Sass {
         else {
           stringstream ss;
           ss << "rgba(" << static_cast<unsigned long>(at(0).content.numeric_value);
-          for (int i = 1; i < 3; ++i) {
+          for (size_t i = 1; i < 3; ++i) {
             ss << ", " << static_cast<unsigned long>(at(i).content.numeric_value);
           }
           ss << ", " << at(3).content.numeric_value << ')';
@@ -321,13 +319,13 @@ namespace Sass {
       
       case value_schema: {
         string result;
-        for (int i = 0; i < size(); ++i) result += at(i).to_string("");
+        for (size_t i = 0; i < size(); ++i) result += at(i).to_string("");
         return result;
       } break;
       
       case string_schema: {
         string result;
-        for (int i = 0; i < size(); ++i) result += at(i).to_string("");
+        for (size_t i = 0; i < size(); ++i) result += at(i).to_string("");
         return result;
       } break;
       
@@ -352,13 +350,13 @@ namespace Sass {
       break;
     case selector_group:
       at(0).echo(buf, depth);
-      for (int i = 1; i < size(); ++i) {
+      for (size_t i = 1; i < size(); ++i) {
         buf << ", ";
         at(i).echo(buf, depth);
       }
       break;
     case selector:
-      for (int i = 0; i < size(); ++i) {
+      for (size_t i = 0; i < size(); ++i) {
         at(i).echo(buf, depth);
       }
       break;
@@ -367,7 +365,7 @@ namespace Sass {
       else buf << ' ' << string(content.token) << ' ';
       break;
     case simple_selector_sequence:
-      for (int i = 0; i < size(); ++i) {
+      for (size_t i = 0; i < size(); ++i) {
         buf << at(i).to_string(string());
       }
       break;
@@ -376,7 +374,7 @@ namespace Sass {
       break;
     case block:
       buf << " {" << endl;
-      for (int i = 0; i < size(); at(i++).echo(buf, depth+1)) ;
+      for (size_t i = 0; i < size(); at(i++).echo(buf, depth+1)) ;
       buf << indentation << "}" << endl;
       break;
     case rule:
@@ -390,11 +388,13 @@ namespace Sass {
       buf << string(content.token);
       break;
     case values:
-      for (int i = 0; i < size(); at(i++).echo(buf, depth)) ;
+      for (size_t i = 0; i < size(); at(i++).echo(buf, depth)) ;
       break;
     case value:
       buf << ' ' << string(content.token);
       break;
+    default:
+      break;
     }
   }
 
@@ -408,7 +408,7 @@ namespace Sass {
       if (at(0).has_expansions) {
         flatten();
       }
-      for (int i = 0; i < size(); ++i) {
+      for (size_t i = 0; i < size(); ++i) {
         at(i).emit_nested_css(buf, depth, prefixes);
         if (at(i).type == css_import) buf << endl;
       }
@@ -421,14 +421,14 @@ namespace Sass {
       vector<string> new_prefixes;
       if (prefixes.empty()) {
         new_prefixes.reserve(sel_group_size);
-        for (int i = 0; i < sel_group_size; ++i) {
+        for (size_t i = 0; i < sel_group_size; ++i) {
           new_prefixes.push_back(sel_group_size > 1 ? sel_group[i].to_string(string()) : sel_group.to_string(string()));
         }
       }
       else {
         new_prefixes.reserve(prefixes.size() * sel_group_size);
-        for (int i = 0; i < prefixes.size(); ++i) {
-          for (int j = 0; j < sel_group_size; ++j) {
+        for (size_t i = 0; i < prefixes.size(); ++i) {
+          for (size_t j = 0; j < sel_group_size; ++j) {
             new_prefixes.push_back(sel_group_size > 1 ? sel_group[j].to_string(prefixes[i]) : sel_group.to_string(prefixes[i]));
           }
         }
@@ -437,11 +437,11 @@ namespace Sass {
       if (block[0].has_expansions) block.flatten();
       if (block[0].has_statements) {
         buf << string(2*depth, ' ') << new_prefixes[0];
-        for (int i = 1; i < new_prefixes.size(); ++i) {
+        for (size_t i = 1; i < new_prefixes.size(); ++i) {
           buf << ", " << new_prefixes[i];
         }
         buf << " {";
-        for (int i = 0; i < block.size(); ++i) {
+        for (size_t i = 0; i < block.size(); ++i) {
           Type stm_type = block[i].type;
           if (stm_type == comment || stm_type == rule || stm_type == css_import || stm_type == propset) {
             block[i].emit_nested_css(buf, depth+1); // NEED OVERLOADED VERSION FOR COMMENTS AND RULES
@@ -454,7 +454,7 @@ namespace Sass {
         ++depth; // if we printed content at this level, we need to indent any nested rulesets
       }
       if (block[0].has_blocks) {
-        for (int i = 0; i < block.size(); ++i) {
+        for (size_t i = 0; i < block.size(); ++i) {
           if (block[i].type == ruleset) {
             block[i].emit_nested_css(buf, depth, new_prefixes);
           }
@@ -496,7 +496,7 @@ namespace Sass {
       break;
 
     case values:
-      for (int i = 0; i < size(); ++i) {
+      for (size_t i = 0; i < size(); ++i) {
         buf << " " << string(at(i).content.token);
       }
       break;
@@ -527,7 +527,7 @@ namespace Sass {
       has_prefix = true;
     }
     Node rules(at(1));
-    for (int i = 0; i < rules.size(); ++i) {
+    for (size_t i = 0; i < rules.size(); ++i) {
       if (rules[i].type == propset) {
         rules[i].emit_propset(buf, depth+1, new_prefix);
       }
@@ -556,7 +556,7 @@ namespace Sass {
     //   buf << string(token) << ":";
     //   break;
     // case values:
-    //   for (int i = 0; i < children.size(); ++i) {
+    //   for (size_t i = 0; i < children.size(); ++i) {
     //     buf << " " << string(children[i].token);
     //   }
     //   break;
@@ -569,11 +569,11 @@ namespace Sass {
     // case clauses:
     //   if (children.size() > 0) {
     //     buf << " {" << endl;
-    //     for (int i = 0; i < children.size(); ++i)
+    //     for (size_t i = 0; i < children.size(); ++i)
     //       children[i].emit_expanded_css(buf, prefix);
     //     buf << "}" << endl;
     //   }
-    //   for (int i = 0; i < opt_children.size(); ++i)
+    //   for (size_t i = 0; i < opt_children.size(); ++i)
     //     opt_children[i].emit_expanded_css(buf, prefix);
     //   break;
     // case ruleset:
@@ -593,7 +593,7 @@ namespace Sass {
   void Node::flatten()
   {
     if (type != block && type != expansion && type != root) return;
-    for (int i = 0; i < size(); ++i) {
+    for (size_t i = 0; i < size(); ++i) {
       if (at(i).type == expansion) {
         Node expn = at(i);
         if (expn[0].has_expansions) expn.flatten();
@@ -611,7 +611,7 @@ namespace Sass {
   // void flatten_block(Node& block)
   // {
   //   
-  //   for (int i = 0; i < block.size(); ++i) {
+  //   for (size_t i = 0; i < block.size(); ++i) {
   //     
   //     if (block[i].type == Node::expansion
   //     
@@ -621,4 +621,4 @@ namespace Sass {
   //   
   // }
 
-}
+}
\ No newline at end of file

libsass/node.hpp

@@ -190,7 +190,7 @@ namespace Sass {
     
     Node& operator+=(const Node& n)
     {
-      for (int i = 0; i < n.size(); ++i) {
+      for (size_t i = 0; i < n.size(); ++i) {
         content.children->push_back(n[i]);
       }
       return *this;
@@ -278,4 +278,4 @@ namespace Sass {
     
     ~Node() { ++destructed; }
   };
-}
+}
\ No newline at end of file

libsass/node_comparisons.cpp

@@ -25,7 +25,7 @@ namespace Sass {
       case space_list:
       case expression:
       case term: {
-        for (int i = 0; i < size(); ++i) {
+        for (size_t i = 0; i < size(); ++i) {
           if (at(i) == rhs[i]) continue;
           else return false;
         }
@@ -101,4 +101,4 @@ namespace Sass {
   bool Node::operator>=(const Node& rhs) const
   { return !(*this < rhs); }
   
-}
+}
\ No newline at end of file

libsass/prelexer.hpp

@@ -388,8 +388,8 @@ namespace Sass {
     template<prelexer mx>
     const char* find_first_in_interval(const char* beg, const char* end) {
       while ((beg < end) && *beg) {
-        const char* p;
-        if (p = mx(beg)) return p;
+        const char* p = mx(beg);
+        if (p) return p;
         ++beg;
       }
       return 0;

libsass/sass_interface.cpp

@@ -13,26 +13,28 @@ extern "C" {
 
   using namespace std;
   sass_context* sass_new_context()
-    { return (sass_context*) malloc(sizeof(sass_context)); }
+    { return (sass_context*) calloc(1, sizeof(sass_context)); }
   
   void sass_free_context(sass_context* ctx)
   { 
-    free(ctx->output_string);
+    if (ctx->output_string)
+      free(ctx->output_string);
     free(ctx);
   }
 
   sass_file_context* sass_new_file_context()
-    { return (sass_file_context*) malloc(sizeof(sass_file_context)); }
+    { return (sass_file_context*) calloc(1, sizeof(sass_file_context)); }
   
   void sass_free_file_context(sass_file_context* ctx)
   { 
-    free(ctx->output_string);
+    if (ctx->output_string)
+      free(ctx->output_string);
     free(ctx);
   }
   
   sass_folder_context* sass_new_folder_context()
-    { return (sass_folder_context*) malloc(sizeof(sass_folder_context)); }
-  
+    { return (sass_folder_context*) calloc(1, sizeof(sass_folder_context)); }
+
   static char* process_document(Sass::Document& doc, int style)
   {
     using namespace Sass;
@@ -47,8 +49,7 @@ extern "C" {
     // 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) {
+    for (size_t i = 0; i < doc.context.registry.size(); ++i) {
       delete doc.context.registry[i];
     }
     // cerr << "Deallocations:\t" << i << endl;
@@ -133,4 +134,4 @@ extern "C" {
     return 1;
   }
 
-}
+}
\ No newline at end of file

libsass/sass_interface.h

@@ -2,10 +2,10 @@
 extern "C" {
 #endif
 
-#define SASS_STYLE_NESTED     0;
-#define SASS_STYLE_EXPANDED   1;
-#define SASS_STYLE_COMPACT    2;
-#define SASS_STYLE_COMPRESSED 3;
+#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;
@@ -36,9 +36,9 @@ struct sass_folder_context {
   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 ();
+struct sass_context*        sass_new_context        (void);
+struct sass_file_context*   sass_new_file_context   (void);
+struct sass_folder_context* sass_new_folder_context (void);
 
 void sass_free_context        (struct sass_context* ctx);
 void sass_free_file_context   (struct sass_file_context* ctx);