Renaming a variable/method.

document.cpp

@@ -16,7 +16,7 @@ namespace Sass {
     source(doc.source),
     position(doc.position),
     end(doc.end),
-    line_number(doc.line_number),
+    line(doc.line),
     own_source(doc.own_source),
     context(doc.context),
     root(doc.root),
@@ -44,7 +44,7 @@ namespace Sass {
 
     Document doc(ctx);
     doc.path        = path;
-    doc.line_number = 1;
+    doc.line = 1;
     doc.root        = ctx.new_Node(Node::root, path, 1, 0);
     doc.lexed       = Token::make();
     doc.own_source  = true;
@@ -60,7 +60,7 @@ namespace Sass {
   {
     Document doc(ctx);
     doc.path = path;
-    doc.line_number = 1;
+    doc.line = 1;
     doc.root = ctx.new_Node(Node::root, path, 1, 0);
     doc.lexed = Token::make();
     doc.own_source = false;
@@ -75,7 +75,7 @@ namespace Sass {
   {
     Document doc(ctx);
     doc.path = path;
-    doc.line_number = line_number;
+    doc.line = line_number;
     doc.root = ctx.new_Node(Node::root, path, 1, 0);
     doc.lexed = Token::make();
     doc.own_source = false;
@@ -87,10 +87,10 @@ namespace Sass {
   }
   
   void Document::throw_syntax_error(string message, size_t ln)
-  { throw Error(Error::syntax, ln ? ln : line_number, path, message); }
+  { throw Error(Error::syntax, ln ? ln : line, path, message); }
   
   void Document::throw_read_error(string message, size_t ln)
-  { throw Error(Error::read, ln ? ln : line_number, path, message); }
+  { throw Error(Error::read, ln ? ln : line, path, message); }
   
   using std::string;
   using std::stringstream;

document.hpp

@@ -20,7 +20,7 @@ namespace Sass {
     char* source;
     const char* position;
     const char* end;
-    size_t line_number;
+    size_t line;
     bool own_source;
 
     Context& context;
@@ -89,7 +89,7 @@ namespace Sass {
       else if (mx == spaces) {
         after_whitespace = spaces(position);
         if (after_whitespace) {
-          line_number += count_interval<'\n'>(position, after_whitespace);
+          line += count_interval<'\n'>(position, after_whitespace);
           lexed = Token::make(position, after_whitespace);
           return position = after_whitespace;
         }
@@ -105,7 +105,7 @@ namespace Sass {
       }
       const char* after_token = mx(after_whitespace);
       if (after_token) {
-        line_number += count_interval<'\n'>(position, after_token);
+        line += count_interval<'\n'>(position, after_token);
         lexed = Token::make(after_whitespace, after_token);
         return position = after_token;
       }

document_parser.cpp

@@ -12,7 +12,7 @@ namespace Sass {
     lex< optional_spaces >();
     while (position < end) {
       if (lex< block_comment >()) {
-        root << context.new_Node(Node::comment, path, line_number, lexed);
+        root << context.new_Node(Node::comment, path, line, lexed);
       }
       else if (peek< import >()) {
         Node importee(parse_import());
@@ -52,7 +52,7 @@ namespace Sass {
     {
       if (peek< string_constant >()) {
         Node schema(parse_string());
-        Node importee(context.new_Node(Node::css_import, path, line_number, 1));
+        Node importee(context.new_Node(Node::css_import, path, line, 1));
         importee << schema;
         if (!lex< exactly<')'> >()) throw_syntax_error("unterminated url in @import directive");
         return importee;
@@ -61,8 +61,8 @@ namespace Sass {
         const char* beg = position;
         const char* end = find_first< exactly<')'> >(position);
         if (!end) throw_syntax_error("unterminated url in @import directive");
-        Node path_node(context.new_Node(Node::identifier, path, line_number, Token::make(beg, end)));
-        Node importee(context.new_Node(Node::css_import, path, line_number, 1));
+        Node path_node(context.new_Node(Node::identifier, path, line, Token::make(beg, end)));
+        Node importee(context.new_Node(Node::css_import, path, line, 1));
         importee << path_node;
         position = end;
         lex< exactly<')'> >();
@@ -94,18 +94,18 @@ namespace Sass {
   {
     lex< mixin >() || lex< exactly<'='> >();
     if (!lex< identifier >()) throw_syntax_error("invalid name in @mixin directive");
-    Node name(context.new_Node(Node::identifier, path, line_number, lexed));
+    Node name(context.new_Node(Node::identifier, path, line, lexed));
     Node params(parse_mixin_parameters());
     if (!peek< exactly<'{'> >()) throw_syntax_error("body for mixin " + name.token().to_string() + " must begin with a '{'");
     Node body(parse_block(true));
-    Node the_mixin(context.new_Node(Node::mixin, path, line_number, 3));
+    Node the_mixin(context.new_Node(Node::mixin, path, line, 3));
     the_mixin << name << params << body;
     return the_mixin;
   }
 
   Node Document::parse_mixin_parameters()
   {
-    Node params(context.new_Node(Node::parameters, path, line_number, 0));
+    Node params(context.new_Node(Node::parameters, path, line, 0));
     Token name(lexed);
     if (lex< exactly<'('> >()) {
       if (peek< variable >()) {
@@ -123,10 +123,10 @@ namespace Sass {
 
   Node Document::parse_parameter() {
     lex< variable >();
-    Node var(context.new_Node(Node::variable, path, line_number, lexed));
+    Node var(context.new_Node(Node::variable, path, line, lexed));
     if (lex< exactly<':'> >()) { // default value
       Node val(parse_space_list());
-      Node par_and_val(context.new_Node(Node::assignment, path, line_number, 2));
+      Node par_and_val(context.new_Node(Node::assignment, path, line, 2));
       par_and_val << var << val;
       return par_and_val;
     }
@@ -141,9 +141,9 @@ namespace Sass {
   {
     lex< include >() || lex< exactly<'+'> >();
     if (!lex< identifier >()) throw_syntax_error("invalid name in @include directive");
-    Node name(context.new_Node(Node::identifier, path, line_number, lexed));
+    Node name(context.new_Node(Node::identifier, path, line, lexed));
     Node args(parse_arguments());
-    Node the_call(context.new_Node(Node::expansion, path, line_number, 2));
+    Node the_call(context.new_Node(Node::expansion, path, line, 2));
     the_call << name << args;
     return the_call;
   }
@@ -151,7 +151,7 @@ namespace Sass {
   Node Document::parse_arguments()
   {
     Token name(lexed);
-    Node args(context.new_Node(Node::arguments, path, line_number, 0));
+    Node args(context.new_Node(Node::arguments, path, line, 0));
     if (lex< exactly<'('> >()) {
       if (!peek< exactly<')'> >(position)) {
         Node arg(parse_argument());
@@ -172,10 +172,10 @@ namespace Sass {
   {
     if (peek< sequence < variable, spaces_and_comments, exactly<':'> > >()) {
       lex< variable >();
-      Node var(context.new_Node(Node::variable, path, line_number, lexed));
+      Node var(context.new_Node(Node::variable, path, line, lexed));
       lex< exactly<':'> >();
       Node val(parse_space_list());
-      Node assn(context.new_Node(Node::assignment, path, line_number, 2));
+      Node assn(context.new_Node(Node::assignment, path, line, 2));
       assn << var << val;
       return assn;
     }
@@ -187,10 +187,10 @@ namespace Sass {
   Node Document::parse_assignment()
   {
     lex< variable >();
-    Node var(context.new_Node(Node::variable, path, line_number, lexed));
+    Node var(context.new_Node(Node::variable, path, line, lexed));
     if (!lex< exactly<':'> >()) throw_syntax_error("expected ':' after " + lexed.to_string() + " in assignment statement");
     Node val(parse_list());
-    Node assn(context.new_Node(Node::assignment, path, line_number, 2));
+    Node assn(context.new_Node(Node::assignment, path, line, 2));
     assn << var << val;
     return assn;
   }
@@ -198,10 +198,10 @@ namespace Sass {
   Node Document::parse_propset()
   {
     lex< identifier >();
-    Node property_segment(context.new_Node(Node::identifier, path, line_number, lexed));
+    Node property_segment(context.new_Node(Node::identifier, path, line, lexed));
     lex< exactly<':'> >();
     lex< exactly<'{'> >();
-    Node block(context.new_Node(Node::block, path, line_number, 1));
+    Node block(context.new_Node(Node::block, path, line, 1));
     while (!lex< exactly<'}'> >()) {
       if (peek< sequence< identifier, optional_spaces, exactly<':'>, optional_spaces, exactly<'{'> > >(position)) {
         block << parse_propset();
@@ -212,7 +212,7 @@ namespace Sass {
       }
     }
     if (block.empty()) throw_syntax_error("namespaced property cannot be empty");
-    Node propset(context.new_Node(Node::propset, path, line_number, 2));
+    Node propset(context.new_Node(Node::propset, path, line, 2));
     propset << property_segment;
     propset << block;
     return propset;
@@ -220,7 +220,7 @@ namespace Sass {
 
   Node Document::parse_ruleset(bool definition)
   {
-    Node ruleset(context.new_Node(Node::ruleset, path, line_number, 2));
+    Node ruleset(context.new_Node(Node::ruleset, path, line, 2));
     ruleset << parse_selector_group();
     if (!peek< exactly<'{'> >()) throw_syntax_error("expected a '{' after the selector");
     ruleset << parse_block(definition);
@@ -232,7 +232,7 @@ namespace Sass {
     Node sel1(parse_selector());
     if (!peek< exactly<','> >()) return sel1;
     
-    Node group(context.new_Node(Node::selector_group, path, line_number, 2));
+    Node group(context.new_Node(Node::selector_group, path, line, 2));
     group << sel1;
     while (lex< exactly<','> >()) group << parse_selector();
     return group;
@@ -245,7 +245,7 @@ namespace Sass {
         peek< exactly<')'> >() ||
         peek< exactly<'{'> >()) return seq1;
     
-    Node selector(context.new_Node(Node::selector, path, line_number, 2));
+    Node selector(context.new_Node(Node::selector, path, line, 2));
     selector << seq1;
 
     while (!peek< exactly<'{'> >() && !peek< exactly<','> >()) {
@@ -260,15 +260,15 @@ namespace Sass {
     if (lex< exactly<'+'> >() ||
         lex< exactly<'~'> >() ||
         lex< exactly<'>'> >())
-    { return context.new_Node(Node::selector_combinator, path, line_number, lexed); }
+    { return context.new_Node(Node::selector_combinator, path, line, lexed); }
     
     // check for backref or type selector, which are only allowed at the front
     Node simp1;
     if (lex< exactly<'&'> >()) {
-      simp1 = context.new_Node(Node::backref, path, line_number, lexed);
+      simp1 = context.new_Node(Node::backref, path, line, lexed);
     }
     else if (lex< alternatives< type_selector, universal > >()) {
-      simp1 = context.new_Node(Node::simple_selector, path, line_number, lexed);
+      simp1 = context.new_Node(Node::simple_selector, path, line, lexed);
     }
     else {
       simp1 = parse_simple_selector();
@@ -282,7 +282,7 @@ namespace Sass {
     { return simp1; }
 
     // otherwise, we have a sequence of simple selectors
-    Node seq(context.new_Node(Node::simple_selector_sequence, path, line_number, 2));
+    Node seq(context.new_Node(Node::simple_selector_sequence, path, line, 2));
     seq << simp1;
     
     while (!peek< spaces >(position) &&
@@ -301,13 +301,13 @@ namespace Sass {
   {
     lex< exactly<'+'> >() || lex< exactly<'~'> >() ||
     lex< exactly<'>'> >() || lex< ancestor_of >();
-    return context.new_Node(Node::selector_combinator, path, line_number, lexed);
+    return context.new_Node(Node::selector_combinator, path, line, lexed);
   }
   
   Node Document::parse_simple_selector()
   {
     if (lex< id_name >() || lex< class_name >()) {
-      return context.new_Node(Node::simple_selector, path, line_number, lexed);
+      return context.new_Node(Node::simple_selector, path, line, lexed);
     }
     else if (peek< exactly<':'> >(position)) {
       return parse_pseudo();
@@ -324,39 +324,39 @@ namespace Sass {
   
   Node Document::parse_pseudo() {
     if (lex< pseudo_not >()) {
-      Node ps_not(context.new_Node(Node::pseudo_negation, path, line_number, 2));
-      ps_not << context.new_Node(Node::value, path, line_number, lexed);
+      Node ps_not(context.new_Node(Node::pseudo_negation, path, line, 2));
+      ps_not << context.new_Node(Node::value, path, line, lexed);
       ps_not << parse_selector_group();
       lex< exactly<')'> >();
       return ps_not;
     }
     else if (lex< sequence< pseudo_prefix, functional > >()) {
-      Node pseudo(context.new_Node(Node::functional_pseudo, path, line_number, 2));
+      Node pseudo(context.new_Node(Node::functional_pseudo, path, line, 2));
       Token name(lexed);
-      pseudo << context.new_Node(Node::value, path, line_number, name);
+      pseudo << context.new_Node(Node::value, path, line, name);
       if (lex< alternatives< even, odd > >()) {
-        pseudo << context.new_Node(Node::value, path, line_number, lexed);
+        pseudo << context.new_Node(Node::value, path, line, lexed);
       }
       else if (peek< binomial >(position)) {
         lex< coefficient >();
-        pseudo << context.new_Node(Node::value, path, line_number, lexed);
+        pseudo << context.new_Node(Node::value, path, line, lexed);
         lex< exactly<'n'> >();
-        pseudo << context.new_Node(Node::value, path, line_number, lexed);
+        pseudo << context.new_Node(Node::value, path, line, lexed);
         lex< sign >();
-        pseudo << context.new_Node(Node::value, path, line_number, lexed);
+        pseudo << context.new_Node(Node::value, path, line, lexed);
         lex< digits >();
-        pseudo << context.new_Node(Node::value, path, line_number, lexed);
+        pseudo << context.new_Node(Node::value, path, line, lexed);
       }
       else if (lex< sequence< optional<sign>,
                               optional<digits>,
                               exactly<'n'> > >()) {
-        pseudo << context.new_Node(Node::value, path, line_number, lexed);
+        pseudo << context.new_Node(Node::value, path, line, lexed);
       }
       else if (lex< sequence< optional<sign>, digits > >()) {
-        pseudo << context.new_Node(Node::value, path, line_number, lexed);
+        pseudo << context.new_Node(Node::value, path, line, lexed);
       }
       else if (lex< string_constant >()) {
-        pseudo << context.new_Node(Node::string_constant, path, line_number, lexed);
+        pseudo << context.new_Node(Node::string_constant, path, line, lexed);
       }
       else {
         throw_syntax_error("invalid argument to " + name.to_string() + "...)");
@@ -365,7 +365,7 @@ namespace Sass {
       return pseudo;
     }
     else if (lex < sequence< pseudo_prefix, identifier > >()) {
-      return context.new_Node(Node::pseudo, path, line_number, lexed);
+      return context.new_Node(Node::pseudo, path, line, lexed);
     }
     else {
       throw_syntax_error("unrecognized pseudo-class or pseudo-element");
@@ -376,19 +376,19 @@ namespace Sass {
   
   Node Document::parse_attribute_selector()
   {
-    Node attr_sel(context.new_Node(Node::attribute_selector, path, line_number, 3));
+    Node attr_sel(context.new_Node(Node::attribute_selector, path, line, 3));
     lex< exactly<'['> >();
     if (!lex< type_selector >()) throw_syntax_error("invalid attribute name in attribute selector");
     Token name(lexed);
-    attr_sel << context.new_Node(Node::value, path, line_number, name);
+    attr_sel << context.new_Node(Node::value, path, line, name);
     if (lex< exactly<']'> >()) return attr_sel;
     if (!lex< alternatives< exact_match, class_match, dash_match,
                             prefix_match, suffix_match, substring_match > >()) {
       throw_syntax_error("invalid operator in attribute selector for " + name.to_string());
     }
-    attr_sel << context.new_Node(Node::value, path, line_number, lexed);
+    attr_sel << context.new_Node(Node::value, path, line, lexed);
     if (!lex< string_constant >()) throw_syntax_error("expected a quoted string constant in attribute selector for " + name.to_string());
-    attr_sel << context.new_Node(Node::value, path, line_number, lexed);
+    attr_sel << context.new_Node(Node::value, path, line, lexed);
     if (!lex< exactly<']'> >()) throw_syntax_error("unterminated attribute selector for " + name.to_string());
     return attr_sel;
   }
@@ -397,18 +397,18 @@ namespace Sass {
   {
     lex< exactly<'{'> >();
     bool semicolon = false;
-    Node block(context.new_Node(Node::block, path, line_number, 0));
+    Node block(context.new_Node(Node::block, path, line, 0));
     while (!lex< exactly<'}'> >()) {
       if (semicolon) {
         if (!lex< exactly<';'> >()) throw_syntax_error("non-terminal statement or declaration must end with ';'");
         semicolon = false;
         while (lex< block_comment >()) {
-          block << context.new_Node(Node::comment, path, line_number, lexed);
+          block << context.new_Node(Node::comment, path, line, lexed);
         }
         if (lex< exactly<'}'> >()) break;
       }
       if (lex< block_comment >()) {
-        block << context.new_Node(Node::comment, path, line_number, lexed);
+        block << context.new_Node(Node::comment, path, line, lexed);
       }
       else if (peek< import >(position)) {
         if (definition) {
@@ -449,9 +449,9 @@ namespace Sass {
         // check for lbrace; if it's there, we have a namespace property with a value
         if (peek< exactly<'{'> >()) {
           Node inner(parse_block());
-          Node propset(context.new_Node(Node::propset, path, line_number, 2));
+          Node propset(context.new_Node(Node::propset, path, line, 2));
           propset << rule[0];
-          rule[0] = context.new_Node(Node::property, path, line_number, Token::make());
+          rule[0] = context.new_Node(Node::property, path, line, Token::make());
           // inner[0] = rule;
           inner.push_front(rule);
           propset << inner;
@@ -465,19 +465,19 @@ namespace Sass {
       }
       else lex< exactly<';'> >();
       while (lex< block_comment >()) {
-        block << context.new_Node(Node::comment, path, line_number, lexed);
+        block << context.new_Node(Node::comment, path, line, lexed);
       }
     }
     return block;
   }
 
   Node Document::parse_rule() {
-    Node rule(context.new_Node(Node::rule, path, line_number, 2));
+    Node rule(context.new_Node(Node::rule, path, line, 2));
     if (!lex< sequence< optional< exactly<'*'> >, identifier > >()) {
       lex< spaces_and_comments >(); // get the line number right
       throw_syntax_error("invalid property name");
     }
-    rule << context.new_Node(Node::property, path, line_number, lexed);
+    rule << context.new_Node(Node::property, path, line, lexed);
     if (!lex< exactly<':'> >()) throw_syntax_error("property \"" + lexed.to_string() + "\" must be followed by a ':'");
     rule << parse_list();
     return rule;
@@ -494,12 +494,12 @@ namespace Sass {
         peek< exactly<'}'> >(position) ||
         peek< exactly<'{'> >(position) ||
         peek< exactly<')'> >(position))
-    { return context.new_Node(Node::nil, path, line_number, 0); }
+    { return context.new_Node(Node::nil, path, line, 0); }
     Node list1(parse_space_list());
     // if it's a singleton, return it directly; don't wrap it
     if (!peek< exactly<','> >(position)) return list1;
     
-    Node comma_list(context.new_Node(Node::comma_list, path, line_number, 2));
+    Node comma_list(context.new_Node(Node::comma_list, path, line, 2));
     comma_list << list1;
     comma_list.should_eval() |= list1.should_eval();
     
@@ -524,7 +524,7 @@ namespace Sass {
         peek< exactly<','> >(position))
     { return disj1; }
     
-    Node space_list(context.new_Node(Node::space_list, path, line_number, 2));
+    Node space_list(context.new_Node(Node::space_list, path, line, 2));
     space_list << disj1;
     space_list.should_eval() |= disj1.should_eval();
     
@@ -548,7 +548,7 @@ namespace Sass {
     // if it's a singleton, return it directly; don't wrap it
     if (!peek< sequence< or_kwd, negate< identifier > > >()) return conj1;
     
-    Node disjunction(context.new_Node(Node::disjunction, path, line_number, 2));
+    Node disjunction(context.new_Node(Node::disjunction, path, line, 2));
     disjunction << conj1;
     while (lex< sequence< or_kwd, negate< identifier > > >()) disjunction << parse_conjunction();
     disjunction.should_eval() = true;
@@ -562,7 +562,7 @@ namespace Sass {
     // if it's a singleton, return it directly; don't wrap it
     if (!peek< sequence< and_kwd, negate< identifier > > >()) return rel1;
     
-    Node conjunction(context.new_Node(Node::conjunction, path, line_number, 2));
+    Node conjunction(context.new_Node(Node::conjunction, path, line, 2));
     conjunction << rel1;
     while (lex< sequence< and_kwd, negate< identifier > > >()) conjunction << parse_relation();
     conjunction.should_eval() = true;
@@ -581,16 +581,16 @@ namespace Sass {
           peek< lte_op >(position)))
     { return expr1; }
     
-    Node relation(context.new_Node(Node::relation, path, line_number, 3));
+    Node relation(context.new_Node(Node::relation, path, line, 3));
     expr1.should_eval() = true;
     relation << expr1;
         
-    if (lex< eq_op >()) relation << context.new_Node(Node::eq, path, line_number, lexed);
-    else if (lex< neq_op >()) relation << context.new_Node(Node::neq, path, line_number, lexed);
-    else if (lex< gte_op >()) relation << context.new_Node(Node::gte, path, line_number, lexed);
-    else if (lex< lte_op >()) relation << context.new_Node(Node::lte, path, line_number, lexed);
-    else if (lex< gt_op >()) relation << context.new_Node(Node::gt, path, line_number, lexed);
-    else if (lex< lt_op >()) relation << context.new_Node(Node::lt, path, line_number, lexed);
+    if (lex< eq_op >()) relation << context.new_Node(Node::eq, path, line, lexed);
+    else if (lex< neq_op >()) relation << context.new_Node(Node::neq, path, line, lexed);
+    else if (lex< gte_op >()) relation << context.new_Node(Node::gte, path, line, lexed);
+    else if (lex< lte_op >()) relation << context.new_Node(Node::lte, path, line, lexed);
+    else if (lex< gt_op >()) relation << context.new_Node(Node::gt, path, line, lexed);
+    else if (lex< lt_op >()) relation << context.new_Node(Node::lt, path, line, lexed);
         
     Node expr2(parse_expression());
     expr2.should_eval() = true;
@@ -608,16 +608,16 @@ namespace Sass {
           peek< sequence< negate< number >, exactly<'-'> > >(position)))
     { return term1; }
     
-    Node expression(context.new_Node(Node::expression, path, line_number, 3));
+    Node expression(context.new_Node(Node::expression, path, line, 3));
     term1.should_eval() = true;
     expression << term1;
     
     while (lex< exactly<'+'> >() || lex< sequence< negate< number >, exactly<'-'> > >()) {
       if (lexed.begin[0] == '+') {
-        expression << context.new_Node(Node::add, path, line_number, lexed);
+        expression << context.new_Node(Node::add, path, line, lexed);
       }
       else {
-        expression << context.new_Node(Node::sub, path, line_number, lexed);
+        expression << context.new_Node(Node::sub, path, line, lexed);
       }
       Node term(parse_term());
       term.should_eval() = true;
@@ -636,17 +636,17 @@ namespace Sass {
           peek< exactly<'/'> >(position)))
     { return fact1; }
 
-    Node term(context.new_Node(Node::term, path, line_number, 3));
+    Node term(context.new_Node(Node::term, path, line, 3));
     term << fact1;
     if (fact1.should_eval()) term.should_eval() = true;
 
     while (lex< exactly<'*'> >() || lex< exactly<'/'> >()) {
       if (lexed.begin[0] == '*') {
-        term << context.new_Node(Node::mul, path, line_number, lexed);
+        term << context.new_Node(Node::mul, path, line, lexed);
         term.should_eval() = true;
       }
       else {
-        term << context.new_Node(Node::div, path, line_number, lexed);
+        term << context.new_Node(Node::div, path, line, lexed);
       }
       Node fact(parse_factor());
       term.should_eval() |= fact.should_eval();
@@ -668,13 +668,13 @@ namespace Sass {
       return value;
     }
     else if (lex< sequence< exactly<'+'>, negate< number > > >()) {
-      Node plus(context.new_Node(Node::unary_plus, path, line_number, 1));
+      Node plus(context.new_Node(Node::unary_plus, path, line, 1));
       plus << parse_factor();
       plus.should_eval() = true;
       return plus;
     }
     else if (lex< sequence< exactly<'-'>, negate< number> > >()) {
-      Node minus(context.new_Node(Node::unary_minus, path, line_number, 1));
+      Node minus(context.new_Node(Node::unary_minus, path, line, 1));
       minus << parse_factor();
       minus.should_eval() = true;
       return minus;
@@ -693,48 +693,48 @@ namespace Sass {
       if (!rparen) throw_syntax_error("URI is missing ')'");
       Token contents(Token::make(value, rparen));
       // lex< string_constant >();
-      Node result(context.new_Node(Node::uri, path, line_number, contents));
+      Node result(context.new_Node(Node::uri, path, line, contents));
       position = rparen;
       lex< exactly<')'> >();
       return result;
     }
     
     if (lex< value_schema >())
-    { return Document::make_from_token(context, lexed, path, line_number).parse_value_schema(); }
+    { return Document::make_from_token(context, lexed, path, line).parse_value_schema(); }
     
     if (lex< sequence< true_kwd, negate< identifier > > >())
-    { return context.new_Node(Node::boolean, path, line_number, true); }
+    { return context.new_Node(Node::boolean, path, line, true); }
     
     if (lex< sequence< false_kwd, negate< identifier > > >())
-    { return context.new_Node(Node::boolean, path, line_number, false); }
+    { return context.new_Node(Node::boolean, path, line, false); }
     
     if (peek< functional >())
     { return parse_function_call(); }
     
     if (lex< important >())
-    { return context.new_Node(Node::important, path, line_number, lexed); }
+    { return context.new_Node(Node::important, path, line, lexed); }
 
     if (lex< identifier >())
-    { return context.new_Node(Node::identifier, path, line_number, lexed); }
+    { return context.new_Node(Node::identifier, path, line, lexed); }
 
     if (lex< percentage >())
-    { return context.new_Node(Node::textual_percentage, path, line_number, lexed); }
+    { return context.new_Node(Node::textual_percentage, path, line, lexed); }
 
     if (lex< dimension >())
-    { return context.new_Node(Node::textual_dimension, path, line_number, lexed); }
+    { return context.new_Node(Node::textual_dimension, path, line, lexed); }
 
     if (lex< number >())
-    { return context.new_Node(Node::textual_number, path, line_number, lexed); }
+    { return context.new_Node(Node::textual_number, path, line, lexed); }
 
     if (lex< hex >())
-    { return context.new_Node(Node::textual_hex, path, line_number, lexed); }
+    { return context.new_Node(Node::textual_hex, path, line, lexed); }
 
     if (peek< string_constant >())
     { return parse_string(); } 
 
     if (lex< variable >())
     {
-      Node var(context.new_Node(Node::variable, path, line_number, lexed));
+      Node var(context.new_Node(Node::variable, path, line, lexed));
       var.should_eval() = true;
       return var;
     }
@@ -756,23 +756,23 @@ namespace Sass {
     // see if there any interpolants
     const char* p = find_first_in_interval< sequence< negate< exactly<'\\'> >, exactly<hash_lbrace> > >(str.begin, str.end);
     if (!p) {
-      return context.new_Node(Node::string_constant, path, line_number, str);
+      return context.new_Node(Node::string_constant, path, line, str);
     }
     
-    Node schema(context.new_Node(Node::string_schema, path, line_number, 1));
+    Node schema(context.new_Node(Node::string_schema, path, line, 1));
     while (i < str.end) {
       p = find_first_in_interval< sequence< negate< exactly<'\\'> >, exactly<hash_lbrace> > >(i, str.end);
       if (p) {
         if (i < p) {
-          schema << context.new_Node(Node::identifier, path, line_number, Token::make(i, p-2)); // accumulate the preceding segment if it's nonempty
+          schema << context.new_Node(Node::identifier, path, line, Token::make(i, p-2)); // accumulate the preceding segment if it's nonempty
           // cerr << '[' << Token::make(i,p-2).to_string() << ']' << endl;
         }
         const char* j = find_first_in_interval< exactly<rbrace> >(p, str.end); // find the closing brace
         if (j) {
           // parse the interpolant and accumulate it
           // cerr << '[' << Token::make(p, j-1).to_string() << ']' << endl;
-          // Document interp_doc(path, line_number, Token::make(p,j-1), context);
-          Node interp_node(Document::make_from_token(context, Token::make(p, j-1), path, line_number).parse_list());
+          // Document interp_doc(path, line, Token::make(p,j-1), context);
+          Node interp_node(Document::make_from_token(context, Token::make(p, j-1), path, line).parse_list());
           // Node interp_node(interp_doc.parse_list());
           interp_node.should_eval() = true;
           schema << interp_node;
@@ -784,7 +784,7 @@ namespace Sass {
         }
       }
       else { // no interpolants left; add the last segment if nonempty
-        if (i < str.end) schema << context.new_Node(Node::identifier, path, line_number, Token::make(i, str.end));
+        if (i < str.end) schema << context.new_Node(Node::identifier, path, line, Token::make(i, str.end));
         break;
       }
     }
@@ -793,36 +793,36 @@ namespace Sass {
   
   Node Document::parse_value_schema()
   {    
-    Node schema(context.new_Node(Node::value_schema, path, line_number, 1));
+    Node schema(context.new_Node(Node::value_schema, path, line, 1));
     
     while (position < end) {
       if (lex< interpolant >()) {
         Token insides(Token::make(lexed.begin + 2, lexed.end - 1));
-        // Document interp_doc(path, line_number, insides, context);
+        // Document interp_doc(path, line, insides, context);
         // Node interp_node(interp_doc.parse_list());
-        Node interp_node(Document::make_from_token(context, insides, path, line_number).parse_list());
+        Node interp_node(Document::make_from_token(context, insides, path, line).parse_list());
         schema << interp_node;
       }
       else if (lex< identifier >()) {
-        schema << context.new_Node(Node::identifier, path, line_number, lexed);
+        schema << context.new_Node(Node::identifier, path, line, lexed);
       }
       else if (lex< percentage >()) {
-        schema << context.new_Node(Node::textual_percentage, path, line_number, lexed);
+        schema << context.new_Node(Node::textual_percentage, path, line, lexed);
       }
       else if (lex< dimension >()) {
-        schema << context.new_Node(Node::textual_dimension, path, line_number, lexed);
+        schema << context.new_Node(Node::textual_dimension, path, line, lexed);
       }
       else if (lex< number >()) {
-        schema << context.new_Node(Node::textual_number, path, line_number, lexed);
+        schema << context.new_Node(Node::textual_number, path, line, lexed);
       }
       else if (lex< hex >()) {
-        schema << context.new_Node(Node::textual_hex, path, line_number, lexed);
+        schema << context.new_Node(Node::textual_hex, path, line, lexed);
       }
       else if (lex< string_constant >()) {
-        schema << context.new_Node(Node::string_constant, path, line_number, lexed);
+        schema << context.new_Node(Node::string_constant, path, line, lexed);
       }
       else if (lex< variable >()) {
-        schema << context.new_Node(Node::variable, path, line_number, lexed);
+        schema << context.new_Node(Node::variable, path, line, lexed);
       }
       else {
         throw_syntax_error("error parsing interpolated value");
@@ -835,9 +835,9 @@ namespace Sass {
   Node Document::parse_function_call()
   {
     lex< identifier >();
-    Node name(context.new_Node(Node::identifier, path, line_number, lexed));
+    Node name(context.new_Node(Node::identifier, path, line, lexed));
     Node args(parse_arguments());
-    Node call(context.new_Node(Node::function_call, path, line_number, 2));
+    Node call(context.new_Node(Node::function_call, path, line, 2));
     call << name << args;
     call.should_eval() = true;
     return call;

eval_apply.cpp

@@ -6,7 +6,7 @@
 namespace Sass {
   using std::cerr; using std::endl;
   
-  static void eval_error(string message, size_t line_number, const char* file_name)
+  static void throw_eval_error(string message, size_t line_number, const char* file_name)
   {
     string fn;
     if (file_name) {

eval_apply.hpp

@@ -11,10 +11,10 @@
 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);
+  Node eval(Node& expr, Environment& env, map<pair<string, size_t>, Function>& f_env, Node_Factory& new_Node);
+  Node accumulate(Node::Type op, Node& acc, Node& rhs, Node_Factory& new_Node);
   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);
+  Node apply_mixin(Node& mixin, const Node& args, Environment& env, map<pair<string, size_t>, Function>& f_env, Node_Factory& new_Node);
+  Node apply_function(const Function& f, const Node& args, Environment& env, map<pair<string, size_t>, Function>& f_env, Node_Factory& new_Node);
 }
\ No newline at end of file

node.cpp

@@ -82,11 +82,11 @@ namespace Sass {
         return numeric_value() < rhs.numeric_value();
       }
       else {
-        throw Error(Error::evaluation, line_number(), file_name(), "incompatible units");
+        throw Error(Error::evaluation, line(), path(), "incompatible units");
       }
     }
     else {
-      throw Error(Error::evaluation, line_number(), file_name(), "incomparable types");
+      throw Error(Error::evaluation, line(), path(), "incomparable types");
     }
   }
   

node.hpp

@@ -163,8 +163,8 @@ namespace Sass {
     bool is_unquoted() const;
     bool is_numeric() const;
 
-    string& file_name() const;
-    size_t line_number() const;
+    string& path() const;
+    size_t line() const;
     size_t size() const;
     bool empty() const;
 
@@ -200,8 +200,8 @@ namespace Sass {
     // TO DO: look into using a custom allocator in the Node_Factory class
     vector<Node> children; // Can't be in the union because it has non-trivial constructors!
 
-    string file_name;
-    size_t line_number;
+    string path;
+    size_t line;
 
     Node::Type type;
 
@@ -296,8 +296,8 @@ namespace Sass {
   inline bool Node::is_unquoted() const    { return ip_->is_unquoted; }
   inline bool Node::is_numeric() const     { return ip_->is_numeric(); }
   
-  inline string& Node::file_name() const   { return ip_->file_name; }
-  inline size_t  Node::line_number() const { return ip_->line_number; }
+  inline string& Node::path() const        { return ip_->path; }
+  inline size_t  Node::line() const { return ip_->line; }
   inline size_t  Node::size() const        { return ip_->size(); }
   inline bool    Node::empty() const       { return ip_->empty(); }
   

node_factory.cpp

@@ -2,13 +2,13 @@
 
 namespace Sass {
   
-  Node_Impl* Node_Factory::alloc_Node_Impl(Node::Type type, string file, size_t line)
+  Node_Impl* Node_Factory::alloc_Node_Impl(Node::Type type, string path, size_t line)
   {
     Node_Impl* ip = new Node_Impl();
     ip->type = type;
     if (type == Node::backref) ip->has_backref = true;
-    ip->file_name = file;
-    ip->line_number = line;
+    ip->path = path;
+    ip->line = line;
     pool_.push_back(ip);
     return ip;
   }
@@ -35,17 +35,17 @@ namespace Sass {
   }
 
   // for making leaf nodes out of terminals/tokens
-  Node Node_Factory::operator()(Node::Type type, string file, size_t line, Token& t)
+  Node Node_Factory::operator()(Node::Type type, string path, size_t line, Token& t)
   {
-    Node_Impl* ip = alloc_Node_Impl(type, file, line);
+    Node_Impl* ip = alloc_Node_Impl(type, path, line);
     ip->value.token = t;
     return Node(ip);
   }
 
   // for making boolean values or interior nodes that have children
-  Node Node_Factory::operator()(Node::Type type, string file, size_t line, size_t size)
+  Node Node_Factory::operator()(Node::Type type, string path, size_t line, size_t size)
   {
-    Node_Impl* ip = alloc_Node_Impl(type, file, line);
+    Node_Impl* ip = alloc_Node_Impl(type, path, line);
 
     if (type == Node::boolean) ip->value.boolean = size;
     else                       ip->children.reserve(size);
@@ -53,38 +53,38 @@ namespace Sass {
     return Node(ip);
   }
 
-  // Node Node_Factory::operator()(Node::Type type, string file, size_t line, bool b)
+  // Node Node_Factory::operator()(Node::Type type, string path, size_t line, bool b)
   // {
-  //   Node_Impl* ip = alloc_Node_Impl(type, file, line);
+  //   Node_Impl* ip = alloc_Node_Impl(type, path, line);
   //   ip->content.boolean_value = b;
   //   return Node(ip);
   // }
 
   // for making nodes representing numbers
-  Node Node_Factory::operator()(string file, size_t line, double v)
+  Node Node_Factory::operator()(string path, size_t line, double v)
   {
-    Node_Impl* ip = alloc_Node_Impl(Node::number, file, line);
+    Node_Impl* ip = alloc_Node_Impl(Node::number, path, line);
     ip->value.numeric = v;
     return Node(ip);
   }
 
   // for making nodes representing numeric dimensions (e.g. 5px, 3em)
-  Node Node_Factory::operator()(string file, size_t line, double v, const Token& t)
+  Node Node_Factory::operator()(string path, size_t line, double v, const Token& t)
   {
-    Node_Impl* ip = alloc_Node_Impl(Node::numeric_dimension, file, line);
+    Node_Impl* ip = alloc_Node_Impl(Node::numeric_dimension, path, line);
     ip->value.dimension.numeric = v;
     ip->value.dimension.unit = t;
     return Node(ip);
   }
   
   // for making nodes representing rgba color quads
-  Node Node_Factory::operator()(string file, size_t line, double r, double g, double b, double a)
+  Node Node_Factory::operator()(string path, size_t line, double r, double g, double b, double a)
   {
-    Node color((*this)(Node::numeric_color, file, line, 4));
-    color << (*this)(file, line, r)
-          << (*this)(file, line, g)
-          << (*this)(file, line, b)
-          << (*this)(file, line, a);
+    Node color((*this)(Node::numeric_color, path, line, 4));
+    color << (*this)(path, line, r)
+          << (*this)(path, line, g)
+          << (*this)(path, line, b)
+          << (*this)(path, line, a);
     return color;
   }
 

sass_interface.cpp

@@ -40,7 +40,7 @@ extern "C" {
     using namespace Sass;
     doc.parse_scss();
     // cerr << "PARSED" << endl;
-    eval(doc.root, doc.context.global_env, doc.context.function_env, doc.context.registry);
+    eval(doc.root, doc.context.global_env, doc.context.function_env, doc.context.new_Node);
     // cerr << "EVALUATED" << endl;
     string output(doc.emit_css(static_cast<Document::CSS_Style>(style)));
     // cerr << "EMITTED" << endl;