protected override Node Evaluate(Env env)
        {
            Guard.ExpectMinArguments(2, Arguments.Count, this, Index);
            Guard.ExpectMaxArguments(3, Arguments.Count, this, Index);
            Guard.ExpectAllNodes<Color>(Arguments.Take(2), this, Index);

            double weight = 50;
            if (Arguments.Count == 3)
            {
                Guard.ExpectNode<Number>(Arguments[2], this, Index);

                weight = ((Number) Arguments[2]).Value;
            }

            var colors = Arguments.Take(2).Cast<Color>().ToArray();

            // Note: this algorithm taken from http://github.com/nex3/haml/blob/0e249c844f66bd0872ed68d99de22b774794e967/lib/sass/script/functions.rb

            var p = weight/100.0;
            var w = p*2 - 1;
            var a = colors[0].Alpha - colors[1].Alpha;

            var w1 = (((w*a == -1) ? w : (w + a)/(1 + w*a)) + 1)/2.0;
            var w2 = 1 - w1;

            var rgb = colors[0].RGB.Select((x, i) => x*w1 + colors[1].RGB[i]*w2).ToArray();

            var alpha = colors[0].Alpha*p + colors[1].Alpha*(1 - p);

            var color = new Color(rgb[0], rgb[1], rgb[2], alpha);
            return color;
        }

        public override Node Evaluate(Env env)
        {
            int blockIndex = env.MediaBlocks.Count;
            env.MediaBlocks.Add(this);
            env.MediaPath.Push(this);

            env.Frames.Push(Ruleset);
            NodeHelper.ExpandNodes<Import>(env, Ruleset.Rules);
            env.Frames.Pop();

            var features = Features.Evaluate(env);
            var ruleset = Ruleset.Evaluate(env) as Ruleset;

            var media = new Media(features, ruleset,Extensions).ReducedFrom<Media>(this);

            env.MediaPath.Pop();
            env.MediaBlocks[blockIndex] = media;

            if (env.MediaPath.Count == 0)
            {
                return media.EvalTop(env);
            }
            else
            {
                return media.EvalNested(env, features, ruleset);
            }
        }

        public override Node Evaluate(Env env)
        {
            if(Evaluated) return this;

            try
            {
                env = env ?? new Env();

                env.Frames.Push(this);
                NodeHelper.ExpandNodes<Import>(env, Rules);
                env.Frames.Pop();

                var clone = new Root(new NodeList(Rules), Error, OriginalRuleset);

                clone = DoVisiting(clone, env, VisitorPluginType.BeforeEvaluation);

                clone.ReducedFrom<Root>(this);
                clone.EvaluateRules(env);
                clone.Evaluated = true;

                clone = DoVisiting(clone, env, VisitorPluginType.AfterEvaluation);
                return clone;
            }
            catch (ParsingException e)
            {
                throw Error(e);
            }
        }

 public override void AppendCSS(Env env)
 {
     env.Output
         .Append('(')
         .Append(Value)
         .Append(')');
 }

        public override Node Evaluate(Env env)
        {
            var a = First.Evaluate(env);
            var b = Second.Evaluate(env);

            if (a is Number && b is Color)
            {
                if (Operator == "*" || Operator == "+")
                {
                    var temp = b;
                    b = a;
                    a = temp;
                }
                else
                    throw new ParsingException("Can't substract or divide a color from a number", Index);
            }

            try
            {
                var operable = a as IOperable;
                if (operable != null)
                    return operable.Operate(this, b).ReducedFrom<Node>(this);

                throw new ParsingException(string.Format("Cannot apply operator {0} to the left hand side: {1}", Operator, a.ToCSS(env)), Index);
            }
            catch (DivideByZeroException e)
            {
                throw new ParsingException(e, Index);
            }
            catch (InvalidOperationException e)
            {
                throw new ParsingException(e, Index);
            }
        }

        protected override Node Evaluate(Env env)
        {
            if (Arguments.Count == 0)
                return new Quoted("", false);

            Func<Node, string> stringValue = n => n is Quoted ? ((Quoted)n).Value : n.ToCSS(env);

            var str = stringValue(Arguments[0]);

            var args = Arguments.Skip(1).ToArray();
            var i = 0;

            MatchEvaluator replacement = m =>
                                             {
                                                 var value = (m.Value == "%s") ?
                                                                stringValue(args[i++]) :
                                                                args[i++].ToCSS(env);

                                                 return char.IsUpper(m.Value[1]) ?
                                                     Uri.EscapeDataString(value) :
                                                     value;
                                             };

            str = Regex.Replace(str, "%[sda]", replacement, RegexOptions.IgnoreCase);

            var quote = Arguments[0] is Quoted ? (Arguments[0] as Quoted).Quote : null;

            return new Quoted(str, quote);
        }

        public override Node Evaluate(Env env)
        {
            if (Values.Count == 1 && string.IsNullOrEmpty(Important))
                return Values[0].Evaluate(env);

            return new Value(Values.Select(n => n.Evaluate(env)), Important);
        }

        protected override Node Evaluate(Env env)
        {
            Guard.ExpectNumArguments(1, Arguments.Count, this, Location);
            var color = Guard.ExpectNode<Color>(Arguments[0], this, Location);

            return new TextNode(color.ToArgb());
        }

		public BDB43(string file, string table, bool create, DBFormat format, bool allowDuplicates, Env environment) {
			this.env = environment;
			
			db_create(out dbp, environment.envptr, 0);
			funcs = (dbstruct)Marshal.PtrToStructure((IntPtr)((int)dbp+268), typeof(dbstruct));
			
			uint dbflags = DB_DIRECT_DB;
			if (allowDuplicates)
				dbflags |= DB_DUP; // DB_DUPSORT; 
			
			funcs.set_flags(dbp, dbflags);
			
			int type = (int)format;
			uint flags = DB_DIRTY_READ; // | DB_AUTO_COMMIT;
			int chmod_mode = 0;
			
			if (create)
				flags |= DB_CREATE;
			
			// if file & database are null, db is held in-memory
			// on file is taken as UTF8 (is this call right?)
			int ret = funcs.open(dbp, env.Txn, file, table, type, flags, chmod_mode);
			CheckError(ret);
			
			binfmt = new Serializer();
		}

        protected override void AppendCSS(Env env, Context context)
        {
            env.Output.Append(Name);

            if (Rules != null)
            {
                env.Output
                    .Append(env.Compress ? "{" : " {\n")

                    .Push()
                    .AppendMany(Rules, "\n")
                    .Trim()
                    .Indent(env.Compress ? 0 : 2)
                    .PopAndAppend()

                    .Append(env.Compress ? "}" : "\n}\n");

                return;
            }

            env.Output
                .Append(" ")
                .Append(Value)
                .Append(";\n");
        }

        public List<Closure> Find(Env env, Selector selector, Ruleset self)
        {
            self = self ?? this;
            var rules = new List<Closure>();
            var key = selector.ToCSS(env);

            if (_lookups.ContainsKey(key))
                return _lookups[key];

            foreach (var rule in Rulesets().Where(rule => rule != self))
            {
                if (rule.Selectors && rule.Selectors.Any(selector.Match))
                {
                    if (selector.Elements.Count > 1)
                    {
                        var remainingSelectors = new Selector(new NodeList<Element>(selector.Elements.Skip(1)));
                        var closures = rule.Find(env, remainingSelectors, self);

                        foreach (var closure in closures)
                        {
                            closure.Context.Insert(0, rule);
                        }

                        rules.AddRange(closures);
                    }
                    else
                        rules.Add(new Closure { Ruleset = rule, Context = new List<Ruleset> { rule } });
                }
            }
            return _lookups[key] = rules;
        }

        public override void AppendCSS(Env env)
        {
            if (!Rules.Any())
                return;

            ((Ruleset) Evaluate(env)).AppendCSS(env, new Context());
        }

 private UtilsManager(Env env, string serverName, string catalog)
 {
     _serverName = serverName;
     _catalog = catalog;
     this._env = env;
     _valuesForCombo = new Dictionary<string, IEnumerable<string>>();
 }

        protected override Node Evaluate(Env env)
        {
            Guard.ExpectNumArguments(1, Arguments.Count, this, Location);
            Guard.ExpectNode<TextNode>(Arguments[0], this, Location);

            var argument = ((TextNode) Arguments[0]);

            string rgb;
            if (!argument.Value.StartsWith("#")) {
                var color = Color.GetColorFromKeyword(argument.Value);
                if (color != null) {
                    return color;
                }

                rgb = argument.Value;
            } else {
                rgb = argument.Value.TrimStart('#');
            }

            try
            {
                return new Color(rgb);
            }
            catch (FormatException ex)
            {
                throw new ParsingException(string.Format("Invalid RGB color string '{0}'", rgb), ex, Location, null);
            }
        }

 public override void AppendCSS(Env env)
 {
     env.Output
         .Append(First)
         .Append("/")
         .Append(Second);
 }

        public override Node Evaluate(Env env)
        {
            if (env == null)
            {
                throw new ArgumentNullException("env");
            }

            var args = Arguments.Select(a => a.Evaluate(env));

            var function = env.GetFunction(Name);

            if (function != null)
            {
                function.Name = Name;
                function.Location = Location;
                return function.Call(env, args).ReducedFrom<Node>(this);
            }

            env.Output.Push();
            
            env.Output
                .Append(Name)
                .Append("(")
                .AppendMany(args, env.Compress ? "," : ", ")
                .Append(")");

            var css = env.Output.Pop();

            return new TextNode(css.ToString()).ReducedFrom<Node>(this);
        }

 public override EvaluationResult Evaluate(Env env)
 {
     int left = (int)Left.Evaluate(env).Result;
     int right = (int)Right.Evaluate(env).Result;
     bool result;
     switch (RELOP) {
         case "==":
             result = left == right;
             break;
         case "!=":
             result = left != right;
             break;
         case ">":
             result = left > right;
             break;
         case "<":
             result = left < right;
             break;
         case ">=":
             result = left >= right;
             break;
         case "<=":
             result = left <= right;
             break;
         default:
             throw new InvalidOperationException("Unknown operator: " + RELOP);
     }
     return new EvaluationResult {
         Result = result
     };
 }

        public override string ToCSS(Env env)
        {
            if (Variable)
                return "";

            return Name + (env.Compress ? ":" : ": ") + Value.ToCSS(env) + ";";
        }

        protected override Node Evaluate(Env env)
        {
            Guard.ExpectNumArguments(1, Arguments.Count, this, Location);
            Guard.ExpectNode<TextNode>(Arguments[0], this, Location);

            return new Color(((TextNode)Arguments[0]).Value.TrimStart('#'));
        }

        public override string ToCSS(Env env)
        {
            if (!string.IsNullOrEmpty(_css))
                return _css;

            return _css = Elements.Select(e => e.ToCSS(env)).JoinStrings("");
        }