/// <summary>
		/// Converts identifiers to compound symbols (strings in double quotes),
		/// expands character strings (in single quotes) to arrays of characters
		/// </summary>
		public static void InitNode(AstContext context, ParseTreeNode parseNode)
		{
			foreach (var node in parseNode.ChildNodes)
			{
				if (node.AstNode is LiteralValueNode)
				{
					if (node.Term.Name == "Char")
					{
						var literal = node.AstNode as LiteralValueNode;
						literal.Value = literal.Value.ToString().ToCharArray();
					}

					parseNode.AstNode = node.AstNode;
				}
				else
				{
					// identifiers in expressions are treated as strings (True is same as "True")
					parseNode.AstNode = new LiteralValueNode()
					{
						Value = node.FindTokenAndGetText(),
						Span = node.Span
					};
				}
			}
		}

        /// <summary>Initializes the current AST node with the specified <paramref name="context" /> and <paramref name="treeNode" />.</summary>
        /// <param name="context">The AST context.</param>
        /// <param name="treeNode">The parse tree node associated with the current AST node.</param>
        public override void Init(AstContext context, ParseTreeNode treeNode)
        {
            base.Init(context, treeNode);

            AsString=treeNode.ChildNodes[0].Token.Text;
            _GeometryType=(GeometryType)Enum.Parse(typeof(GeometryType), AsString, true);
        }

        public override void Init(AstContext context, ParseTreeNode treeNode)
        {
            base.Init(context, treeNode);
            Text = treeNode.Token.Text;

            AsString = "StringValue";
        }

        public override void Init(AstContext context, ParseTreeNode treeNode)
        {
            base.Init(context, treeNode);

            AstNode sn=AddChild("from", treeNode.ChildNodes[0]);
            AstNode en=AddChild("to", treeNode.ChildNodes[2]);

            var dtsn=sn as DateTimeLiteralNode;
            var dten=en as DateTimeLiteralNode;
            if (dtsn!=null)
            {
                _StartDate=dtsn.Value;

                if (dten!=null)
                    _EndDate=dten.Value;
                else
                    _EndDate=_StartDate+((DurationLiteralNode)en).Value;
            } else
            {
                _EndDate=dten.Value;
                _StartDate=_EndDate-((DurationLiteralNode)sn).Value;
            }

            AsString="period";
        }

 // this is where data is initially passed to the item
 public override void Init(AstContext context, ParseTreeNode treeNode)
 {
     string sVal = treeNode.FindTokenAndGetText();
     base.Init(context, treeNode);
     var nodes = treeNode.GetMappedChildNodes();
     var functionOrProperty = AddChild("FunctionOrId", nodes[0]);
     if (functionOrProperty is SelectFunctionNode)
     {
         _TheFunction = (SelectFunctionNode)functionOrProperty;
     }
     else if (functionOrProperty is SelectPropertyNode)
     {
         _PropNode = (SelectPropertyNode)functionOrProperty;
     }
     else
     {
         throw new Exception("Unmanaged type in selectmemberaccessnode");
     }
     if (nodes.Count > 1)
     {
         var child = AddChild("Queue", nodes[1]);
         string sval = nodes[1].FindTokenAndGetText();
         if (child is LeftObjectNode)
         {
             _queue = (LeftObjectNode)child;
         }
     }
 }

 public override void Init(AstContext context, ParseTreeNode treeNode) {
   base.Init(context, treeNode);
   var nodes = treeNode.GetMappedChildNodes();
   _target = AddChild("Target", nodes.First());
   _index = AddChild("Index", nodes.Last()); 
   AsString = "[" + _index + "]";
 }

 public override void Init(AstContext context, ParseTreeNode treeNode) {
   base.Init(context, treeNode);
   foreach (var child in treeNode.ChildNodes) {
       AddChild(NodeUseType.Parameter, "expr", child); 
   }
   AsString = "Expression list";
 }

        public override void Init(AstContext context, ParseTreeNode treeNode)
        {
            base.Init(context, treeNode);

            foreach (var node in treeNode.ChildNodes)
            {
                // linearize AuxiliaryNode children
                if (node.AstNode is AuxiliaryNode)
                {
                    var auxNode = node.AstNode as AuxiliaryNode;

                    foreach (var n in auxNode.ChildNodes)
                        ChildNodes.Add(n);

                    foreach (var n in auxNode.ChildParseNodes)
                        ChildParseNodes.Add(n);

                    continue;
                }

                // copy AstNode nodes
                if (node.AstNode is AstNode)
                {
                    ChildNodes.Add(node.AstNode as AstNode);
                    continue;
                }

                // otherwise, save parse nodes
                ChildParseNodes.Add(node);
            }
        }

        public override void Init(AstContext context, ParseTreeNode treeNode)
        {
            base.Init(context, treeNode);

            var node = treeNode.GetMappedChildNodes()[0];
            this.Label = node.Token.ValueString;
        }

 public override void Init(AstContext context, ParseTreeNode treeNode)
 {
     base.Init(context, treeNode);
     var term = TerminalFactory.CreateCSharpIdentifier("text");
     var tok = new Token(term, Location, "text", System.String.Join("_", treeNode.ChildNodes.Select(cn => cn.Term.Name)));
     treeNode.Token = tok;
 }

    public override void Init(AstContext context, ParseTreeNode parseNode)
		{
			base.Init(context, parseNode);

			foreach (var node in parseNode.ChildNodes)
			{
				if (node.AstNode is Expression)
				{
					Expression = (node.AstNode as Expression);
				}
				else if (node.AstNode is AuxiliaryNode)
				{
					var nodes = (node.AstNode as AuxiliaryNode).ChildNodes;
					Pattern = nodes.OfType<Pattern>().FirstOrDefault();
					Block = nodes.OfType<Block>().FirstOrDefault();
					MoreConditions = nodes.OfType<Conditions>().FirstOrDefault();
					ResultExpression = nodes.OfType<Expression>().FirstOrDefault();
				}

				foreach (var astNode in new AstNode[] { Expression, Pattern, Block, MoreConditions, ResultExpression })
				{
					if (astNode != null)
						astNode.Parent = this;
				}
			}

			AsString = Block != null ? "with-clause" : "where-clause";
		}

    public override void Init(AstContext context, ParseTreeNode parseNode)
		{
			base.Init(context, parseNode);

			foreach (var node in parseNode.ChildNodes)
			{
				if (node.AstNode is Function)
				{
					AddFunction(node.AstNode as Function);
				}
				else if (node.AstNode is AuxiliaryNode)
				{
					var ids = (node.AstNode as AuxiliaryNode).ChildNodes.OfType<IdentifierNode>();

					foreach (var id in ids)
					{
						ExternalFunction ef = new ExternalFunction();
						ef.SetSpan(id.Span);
						ef.Name = id.Symbol;
						AddFunction(ef);
					}
				}
			}

			AsString = "Refal-5 program";
		}

 public override void Init(AstContext context, ParseTreeNode treeNode)
 {
     base.Init(context, treeNode);
       foreach (var child in treeNode.ChildNodes)
     AddChild(NodeUseType.Parameter, "param", child);
       AsString = "param_list[" + ChildNodes.Count + "]";
 }

 public override void Init(AstContext context, ParseTreeNode treeNode) {
   base.Init(context, treeNode); 
   Value = treeNode.Token.Value;
   AsString = Value == null ? "null" : Value.ToString();
   if (Value is string)
     AsString = "\"" + AsString + "\"";
 }

 private void InitImpl(AstContext context, ParseTreeNode parseNode, ParseTreeNode parametersNode, ParseTreeNode bodyNode) {
   base.Init(context, parseNode);
   Parameters = AddChild("Parameters", parametersNode);
   Body = AddChild("Body", bodyNode);
   AsString = "Lambda[" + Parameters.ChildNodes.Count + "]";
   Body.SetIsTail(); //this will be propagated to the last statement
 }

    public override void Init(AstContext context, ParseTreeNode parseNode)
		{
			base.Init(context, parseNode);
			
			foreach (var node in parseNode.ChildNodes)
			{
				if (node.AstNode is Pattern)
				{
					Pattern = node.AstNode as Pattern;
				}
				else if (node.AstNode is AuxiliaryNode)
				{
					var nodes = (node.AstNode as AuxiliaryNode).ChildNodes;
					Conditions = nodes.OfType<Conditions>().FirstOrDefault();
					Expression = nodes.OfType<Expression>().FirstOrDefault();
				}
			}

			foreach (var astNode in new AstNode[] { Pattern, Conditions, Expression })
			{
				if (astNode != null)
				{
					astNode.Parent = this;
				}
			}

			AsString = "match";
		}

 public virtual void BuildAst(LanguageData language, ParseTree parseTree)
 {
     if (!LanguageFlags.IsSet(LanguageFlags.CreateAst))
         return;
     var astContext = new AstContext(language);
     var astBuilder = new AstBuilder(astContext);
     astBuilder.BuildAst(parseTree);
 }

 public override void Init(AstContext Context, ParseTreeNode ParseNode)
 {
     IsDefault = (ParseNode.ChildNodes[0].FindTokenAndGetText() == "default");
     if (!IsDefault)
     {
         Value = ParseNode.ChildNodes[1];
     }
 }

        public override void Init(AstContext context, ParseTreeNode treeNode)
        {
            base.Init(context, treeNode);

            _eventEmitter = AddChild(string.Empty, treeNode.ChildNodes[0]) as AstNode;
            _eventName = (treeNode.ChildNodes[1].AstNode as AstNode).AsString;
            _listener = AddChild(string.Empty, treeNode.ChildNodes[2]) as AstNode;
        }

 public override void Init(AstContext context, ParseTreeNode parseNode)
 {
     Debug.Assert("for" == parseNode.ChildNodes[0].FindTokenAndGetText());
     InitialSentence = parseNode.ChildNodes[1];
     ConditionExpresion = parseNode.ChildNodes[2];
     PostSentence = parseNode.ChildNodes[3];
     LoopSentence = parseNode.ChildNodes[4];
 }