public override void Visit(AST.MethodDeclNode node)
        {
            MethodBeingVisited = ClassBeingVisited.Methods.Lookup(node.methodName.name);

            if (node.paramDeclList != null)
                foreach (AST.ParamDeclNode paramDecl in node.paramDeclList)
                    paramDecl.Accept(this);

            if (node.variableDeclList != null)
                foreach (AST.VariableDeclNode variableDecl in node.variableDeclList)
                    variableDecl.Accept(this);

            if (node.statementList != null)
            {
                var reverseList = node.statementList.statementList;
                reverseList.Reverse();

                HashSet<AST.IdentifierNode> afterLiveness = new HashSet<AST.IdentifierNode>();

                foreach (AST.StatementNode statement in reverseList)
                {
                    m_R.Clear();
                    m_W.Clear();
                    statement.Accept(this);
                    afterLiveness.ExceptWith(m_W);
                    afterLiveness.UnionWith(m_R);

                    m_livenessAtNode[statement] = new HashSet<AST.IdentifierNode>(afterLiveness);
                }
            }
        }

        public override bool VisitFunctionDecl(AST.Function function)
        {
            if (!VisitDeclaration(function))
                return false;

            if (function.IsAmbiguous)
                return false;

            var overloads = function.Namespace.GetOverloads(function);

            foreach (var overload in overloads)
            {
                if (function.OperatorKind == CXXOperatorKind.Conversion)
                    continue;
                if (function.OperatorKind == CXXOperatorKind.ExplicitConversion)
                    continue;

                if (overload == function) continue;

                if (!overload.IsGenerated) continue;

                if (CheckConstnessForAmbiguity(function, overload) ||
                    CheckDefaultParametersForAmbiguity(function, overload))
                {
                    function.IsAmbiguous = true;
                    overload.IsAmbiguous = true;
                }
            }

            if (function.IsAmbiguous)
                Driver.Diagnostics.Debug("Found ambiguous overload: {0}",
                    function.QualifiedOriginalName);

            return true;
        }

        /// <summary>
        /// Reports function overload resolution error.
        /// </summary>
        internal static void ReportFunctionOverloadError(AST.MethodExpr functionExpr, EdmFunction functionType, List<TypeUsage> argTypes)
        {
            string strDelim = "";
            System.Text.StringBuilder sb = new System.Text.StringBuilder();
            sb.Append(functionType.Name).Append("(");
            for (int i = 0 ; i < argTypes.Count ; i++)
            {
                sb.Append(strDelim);
                sb.Append(argTypes[i] != null ? argTypes[i].EdmType.FullName : "NULL");
                strDelim = ", ";
            }
            sb.Append(")");

            Func<object, object, object, string> formatString;
            if (TypeSemantics.IsAggregateFunction(functionType))
            {
                formatString = TypeHelpers.IsCanonicalFunction(functionType) ? 
                                            (Func<object, object, object, string>)System.Data.Entity.Strings.NoCanonicalAggrFunctionOverloadMatch :
                                            (Func<object, object, object, string>)System.Data.Entity.Strings.NoAggrFunctionOverloadMatch;
            }
            else
            {
                formatString = TypeHelpers.IsCanonicalFunction(functionType) ?
                                            (Func<object, object, object, string>)System.Data.Entity.Strings.NoCanonicalFunctionOverloadMatch :
                                            (Func<object, object, object, string>)System.Data.Entity.Strings.NoFunctionOverloadMatch;
            }

            throw EntityUtil.EntitySqlError(functionExpr.ErrCtx.CommandText,
                                 formatString(functionType.NamespaceName, functionType.Name, sb.ToString()),
                                 functionExpr.ErrCtx.InputPosition,
                                 System.Data.Entity.Strings.CtxFunction(functionType.Name),
                                 false /* loadContextInfoFromResource */);
        }

 public LogEntry(AnalysisType procedure,
     string filename,
     AST.Address address,
     string original_value,
     string erroneous_value,
     double output_error_magnitude,
     double num_input_error_magnitude,
     double str_input_error_magnitude,
     bool was_flagged,
     bool was_error,
     double significance,
     double threshold)
 {
     _filename = filename;
     _procedure = procedure;
     _address = address;
     _original_value = original_value;
     _erroneous_value = erroneous_value;
     _output_error_magnitude = output_error_magnitude;
     _num_input_error_magnitude = num_input_error_magnitude;
     _str_input_error_magnitude = str_input_error_magnitude;
     _was_flagged = was_flagged;
     _was_error = was_error;
     _significance = significance;
     _threshold = threshold;
 }

		public virtual void resetState()
		{
			traceDepth  = 0;
			returnAST	= null;
			retTree_	= null;
			inputState.reset();
		}

        private INode Emit(AST a, IGraph to)
        {
            String text = a.getText();
            int iType = a.Type;
            String type = parserpackage.GetTypeName(iType);
            NodeType currentNodeType = GetNodeType(type, to);
            INode currentNode = to.AddNode(currentNodeType);
            currentNode.SetAttribute("value", text);

            if (a.getNumberOfChildren() > 0)
            {
                List<AST> l = GetChildren(a);
                INode previousChild = null;
                foreach (AST current in l)
                {
                    INode childNode = Emit(current, to);
                    EdgeType childType = GetEdgeType("child", to);
                    to.AddEdge(childType, currentNode, childNode);

                    if (previousChild != null)
                    {
                        EdgeType nextType = GetEdgeType("next", to);
                        to.AddEdge(nextType, previousChild, childNode);
                    }
                    previousChild = childNode;
                }
            }
            return currentNode;
        }

        public FunctionOutput<string>[] FastReplace(Excel.Range com, DAG dag, InputSample original, InputSample sample, AST.Address[] outputs, bool replace_original)
        {
            FunctionOutput<string>[] fo_arr;
            if (!_d.TryGetValue(sample, out fo_arr))
            {
                // replace the COM value
                ReplaceExcelRange(com, sample);

                // initialize array
                fo_arr = new FunctionOutput<string>[outputs.Length];

                // grab all outputs
                for (var k = 0; k < outputs.Length; k++)
                {
                    // save the output
                    fo_arr[k] = new FunctionOutput<string>(dag.readCOMValueAtAddress(outputs[k]), sample.GetExcludes());
                }

                // Add function values to cache
                // Don't care about return value
                _d.Add(sample, fo_arr);

                // restore the COM value
                if (replace_original)
                {
                    ReplaceExcelRange(com, original);
                }
            }
            return fo_arr;
        }

        private static AST.Clause DcgClauseToNormalClause (AST.DcgClause dcgClause)
        {
            var dcgGoalConverter = new AST.DcgGoalConverter ();

            var body = dcgClause.Body.Select (dcgGoalConverter.DcgGoalToNormalGoal).ToArray ();

            return new AST.Clause 
            {
                Head = new AST.Goal 
                {
                    PredicateName = dcgClause.Head.PredicateName, 
                    Arguments = new []
                                    {
                                        dcgClause.Head.Arguments,
                                        new [] // add 2 extra arguments, L0 and Ln
                                            {
                                                new Variable ("L0"),
                                                new Variable ("L" + dcgGoalConverter.DcgSubgoalCount)
                                            }
                                    }.SelectMany (a => a).ToArray ()
                },

                Body = body
            };
        }

        public override bool VisitFunctionDecl(AST.Function function)
        {
            if (AlreadyVisited(function))
                return false;

            if (function.IsAmbiguous)
                return false;

            var overloads = function.Namespace.GetFunctionOverloads(function);

            foreach (var overload in overloads)
            {
                if (function.OperatorKind == CXXOperatorKind.Conversion)
                    continue;

                if (overload == function) continue;

                if (overload.Ignore) continue;

                if (!CheckDefaultParameters(function, overload))
                    continue;

                if (!CheckConstness(function, overload))
                    continue;

                function.IsAmbiguous = true;
                overload.IsAmbiguous = true;
            }

            if (function.IsAmbiguous)
                Driver.Diagnostics.EmitWarning("Found ambiguous overload: {0}",
                    function.QualifiedOriginalName);

            return true;
        }

        /// <summary>
        /// Compiles AST clauses into an executable program understood by the <see cref="Runtime.Engine"/> .
        /// The input clauses are not required to be in any particular order.
        /// </summary>
        public static Compiled.Program Compile (AST.Program program)
        {
            var allClauses = new []
                                 {
                                     program.DcgClauses.Select (DcgClauseToNormalClause),
                                     program.Clauses
                                 }.SelectMany (a => a);

            var clauseGroups = allClauses.GroupBy (c => Tuple.Create (c.Head.PredicateName, c.Head.Arguments.Length), c => c).ToArray ();

            var prologPredicates = clauseGroups.ToDictionary (p => p.Key, p => new Compiled.PrologPredicate {Name = p.Key.Item1});

            // Dictionary is not covariant so it takes a new dictionary to get a dictionary of base types (Predicate).
            var predicates = prologPredicates.ToDictionary (p => p.Key, CastPrologPredicateToBasePredicate); 

            if (program.ExternalPredicates != null)
            {
                foreach (var externalPredicate in program.ExternalPredicates)
                {
                    predicates.Add (Tuple.Create(externalPredicate.Name, externalPredicate.Arity), new Compiled.ExternalPredicate (externalPredicate.Name));
                }
            }

            foreach (var clauseGroup in clauseGroups)
            {
                var prologPredicate = prologPredicates [clauseGroup.Key];

                prologPredicate.Clauses = clauseGroup.Select (c => new Compiled.Clause {Head = new Compiled.Goal {Predicate = prologPredicate, Arguments = c.Head.Arguments},
                                                                                      Body = Compile (c.Body, predicates)}).ToArray ();
            }

            return new Compiled.Program (predicates);
        }

 internal override void Accept(AST ast)
 {
     ast.nodes.ForEach(node =>
     {
         node.isResultRequired = false;
         node.Visit(this);
     });
 }

        public CSharpGen(AST.AstNode topNode, string name_space)
        {
            if (!(topNode is AST.GrammarFile))
                throw new Exception("Unable to generate.");

            this.gNamespace = name_space;
            this.grammar = topNode as AST.GrammarFile;
        }

		protected internal virtual void  match(AST t, int ttype)
		{
			//System.out.println("match("+ttype+"); cursor is "+t);
			if (t == null || t == ASTNULL || t.Type != ttype)
			{
				throw new MismatchedTokenException(getTokenNames(), t, ttype, false);
			}
		}

        // Used by a labelstatement
        public LabelEntry(string stName, AST.LabelStatement node)
        {
            Debug.Assert(node != null);
            Debug.Assert(stName != null);

            m_strName = stName;
            m_node = node;
        }

 public void Nested_Content_Of_TagNode_As_Raw()
 {
     const string TEMPLATE = @"<c:out>Hello <c:out>${Stranger}</c:out></c:out>";
     var formatter = new Formatter(TEMPLATE).Parse();
     var ast = new AST(formatter.ParsedTemplate, AST.Options.DontTrackContext);
     var raw = (((TagNode)ast.Nodes[0]).Raw);
     Assert.That(raw, Is.EqualTo("Hello <c:out>${Stranger}</c:out>"));
 }

        private static IEnumerable <Dictionary <string, Runtime.IConcreteValue>> CallConcat (AST.Goal makeGoal)
        {
            var program = Compiler.Compile (new AST.Program {ExternalPredicates = Helper.GetConcatDeclaration ()});

            program.SetExternalPredicateCallbacks (Helper.GetConcat ());

            return Helper.GetSolutions (makeGoal, program);
        }

 public override Tuple<AST.Env, List<Tuple<AST.Env, AST.ExternDecln>>> GetExternDecln(AST.Env env)
 {
     Tuple<AST.Env, AST.FuncDef> r_def = GetFuncDef(env);
     return new Tuple<AST.Env, List<Tuple<AST.Env, AST.ExternDecln>>>(
         r_def.Item1,
         new List<Tuple<AST.Env, AST.ExternDecln>>() { Tuple.Create(r_def.Item1, (AST.ExternDecln)r_def.Item2) }
     );
 }

        public void AddAccess(AST.Identifier variable)
        {
            if (!this.Accessing.ContainsKey(variable.Name))
            {
                this.Accessing[variable.Name] = new List<AST.Identifier>();
            }

            this.Accessing[variable.Name].Add(variable);
        }

 public static AST.Address makeAddressForA1(string col, int row, AST.Env env)
 {
     return AST.Address.fromA1(
         row,
         col,
         env.WorksheetName,
         env.WorkbookName,
         env.Path
     );
 }

 public void Combined_Content_Of_TagNode_As_Raw()
 {
     const string TEMPLATE = @"<c:out>Hello ${Stranger}</c:out>";
     var formatter = new Formatter(TEMPLATE).Parse();
     var ast = new AST(formatter.ParsedTemplate, AST.Options.DontTrackContext);
     var expected = new AST()
         .Add(new TagNode("c", "out").Add(new TextNode("Hello world")));
     var raw = (((TagNode)ast.Nodes[0]).Raw);
     Assert.That(raw, Is.EqualTo("Hello ${Stranger}"));
 }