/// <summary>
		/// Computes the result of the division. Currently limited to Integers.
		/// </summary>
		/// <returns>Integer(value) or null</returns>
		public override Object Value(IInternalContextAdapter context)
		{
			// get the two args
			Object left = GetChild(0).Value(context);
			Object right = GetChild(1).Value(context);

			// if either is null, lets log and bail
			if (left == null || right == null)
			{
				runtimeServices.Error(
					string.Format(
						"{0} side ({1}) of division operation has null value. Operation not possible. {2} [line {3}, column {4}]",
						(left == null ? "Left" : "Right"), GetChild((left == null ? 0 : 1)).Literal, context.CurrentTemplateName, Line,
						Column));
				return null;
			}

			Type maxType = MathUtil.ToMaxType(left.GetType(), right.GetType());
			if (maxType == null)
			{
				return null;
			}

			try
			{
				return MathUtil.Div(maxType, left, right);
			}
			catch (DivideByZeroException)
			{
				runtimeServices.Error("Right side of division operation is zero. Must be non-zero. " + context.CurrentTemplateName + " [line " + Line + ", column " + Column + "]");
			}
			return null;
		}

        public override bool Evaluate(IInternalContextAdapter context)
        {
            // get the two args
            Object left = GetChild(0).Value(context);
            Object right = GetChild(1).Value(context);

            // if either is null, lets log and bail
            if (left == null || right == null)
            {
                runtimeServices.Error(
                    string.Format(
                        "{0} side ({1}) of '>=' operation has null value. Operation not possible. {2} [line {3}, column {4}]",
                        (left == null ? "Left" : "Right"), GetChild((left == null ? 0 : 1)).Literal, context.CurrentTemplateName, Line,
                        Column));
                return false;
            }

            try
            {
                return ObjectComparer.CompareObjects(left, right) >= 0;
            }
            catch(ArgumentException ae)
            {
                runtimeServices.Error(ae.Message);

                return false;
            }
        }

		/// <summary>
		/// Computes the sum of the two nodes.
		/// Currently only integer operations are supported.
		/// </summary>
		/// <returns>Integer object with value, or null</returns>
		public override Object Value(IInternalContextAdapter context)
		{
			// get the two addends
			Object left = GetChild(0).Value(context);
			Object right = GetChild(1).Value(context);

			// if either is null, lets log and bail
			if (left == null || right == null)
			{
				runtimeServices.Error(
					string.Format(
						"{0} side ({1}) of addition operation has null value. Operation not possible. {2} [line {3}, column {4}]",
						(left == null ? "Left" : "Right"), GetChild((left == null ? 0 : 1)).Literal, context.CurrentTemplateName, Line,
						Column));
				return null;
			}

			Type maxType = MathUtil.ToMaxType(left.GetType(), right.GetType());

			if (maxType == null)
			{
				return null;
			}

			return MathUtil.Add(maxType, left, right);

			// if not an Integer, not much we can do either
//			if (!(left is Int32) || !(right is Int32))
//			{
//				runtimeServices.Error((!(left is Int32) ? "Left" : "Right") + " side of addition operation is not a valid type. " + "Currently only integers (1,2,3...) and Integer type is supported. " + context.CurrentTemplateName + " [line " + Line + ", column " + Column + "]");
//
//				return null;
//			}
//			return ((Int32) left) + ((Int32) right);
		}

		public override bool Render(IInternalContextAdapter context, TextWriter writer, INode node)
		{
			if (node.ChildrenCount != 2)
			{
				throw new MonoRailException("#capturefor directive expects an id attribute and a template block");
			}

			var idNode = (ASTWord) node.GetChild(0);
			var bodyNode = (ASTBlock) node.GetChild(1);

			var id = idNode.Literal;

			var buffer = new StringWriter();
			var sb = buffer.GetStringBuilder();

			bodyNode.Render(context, buffer);

			var currentContent = context[id] as string;

			if( currentContent != null )
			{
				sb.Append(currentContent);
			}

			context[id] = sb.ToString();

			return true;
		}

		public override bool Render(IInternalContextAdapter context, TextWriter writer)
		{
			// Check if the #if(expression) construct evaluates to true:
			// if so render and leave immediately because there
			// is nothing left to do!
			if (GetChild(0).Evaluate(context))
			{
				GetChild(1).Render(context, writer);
				return true;
			}

			int totalNodes = ChildrenCount;

			// Now check the remaining nodes left in the
			// if construct. The nodes are either elseif
			// nodes or else nodes. Each of these node
			// types knows how to evaluate themselves. If
			// a node evaluates to true then the node will
			// render itself and this method will return
			// as there is nothing left to do.
			for(int i = 2; i < totalNodes; i++)
			{
				if (GetChild(i).Evaluate(context))
				{
					GetChild(i).Render(context, writer);
					return true;
				}
			}

			// This is reached when an ASTIfStatement
			// consists of an if/elseif sequence where
			// none of the nodes evaluate to true.
			return true;
		}

		public override bool Evaluate(IInternalContextAdapter context)
		{
			// get the two args
			Object left = GetChild(0).Value(context);
			Object right = GetChild(1).Value(context);

			// if either is null, lets log and bail
			if (left == null || right == null)
			{
				rsvc.Error((left == null ? "Left" : "Right") + " side (" + GetChild((left == null ? 0 : 1)).Literal +
				           ") of '>' operation has null value." + " Operation not possible. " + context.CurrentTemplateName +
				           " [line " + Line + ", column " + Column + "]");
				return false;
			}

			try
			{
				return ObjectComparer.CompareObjects(left, right) == ObjectComparer.Greater;
			}
			catch(ArgumentException ae)
			{
				rsvc.Error(ae.Message);

				return false;
			}
		}

		public override bool Evaluate(IInternalContextAdapter context)
		{
			if (GetChild(0).Evaluate(context))
				return false;
			else
				return true;
		}

		/// <summary>
		/// Computes the value of the subtraction.
		/// Currently limited to integers.
		/// </summary>
		/// <returns>Integer(value) or null</returns>
		public override Object Value(IInternalContextAdapter context)
		{
			// get the two args
			Object left = GetChild(0).Value(context);
			Object right = GetChild(1).Value(context);

			// if either is null, lets log and bail
			if (left == null || right == null)
			{
				rsvc.Error((left == null ? "Left" : "Right") + " side (" + GetChild((left == null ? 0 : 1)).Literal +
				           ") of subtraction operation has null value." + " Operation not possible. " + context.CurrentTemplateName +
				           " [line " + Line + ", column " + Column + "]");
				return null;
			}

			Type maxType = MathUtil.ToMaxType(left.GetType(), right.GetType());

			if (maxType == null)
			{
				return null;
			}

			return MathUtil.Sub(maxType, left, right);

			// if not an Integer, not much we can do either
//			if (!(left is Int32) || !(right is Int32))
//			{
//				rsvc.Error((!(left is Int32) ? "Left" : "Right") + " side of subtraction operation is not a valid type. " + "Currently only integers (1,2,3...) and Integer type is supported. " + context.CurrentTemplateName + " [line " + Line + ", column " + Column + "]");
//
//				return null;
//			}
//
//			return ((Int32) left) - ((Int32) right);
		}

		/// <summary>   puts the value of the RHS into the context under the key of the LHS
		/// </summary>
		public override bool Render(IInternalContextAdapter context, TextWriter writer)
		{
			/*
	    *  get the RHS node, and it's value
	    */

			Object value = right.Value(context);

			/*
	    * it's an error if we don't have a value of some sort
	    */

			if (value == null)
			{
				/*
				*  first, are we supposed to say anything anyway?
				*/
				if (blather)
				{
					EventCartridge eventCartridge = context.EventCartridge;

					bool doIt = true;

					/*
		    *  if we have an EventCartridge...
		    */
					if (eventCartridge != null)
					{
						doIt = eventCartridge.ShouldLogOnNullSet(left.Literal, right.Literal);
					}

					if (doIt)
					{
						runtimeServices.Error(
							string.Format("RHS of #set statement is null. Context will not be modified. {0} [line {1}, column {2}]",
							              context.CurrentTemplateName, Line, Column));
					}
				}

				return false;
			}

			/*
	    *  if the LHS is simple, just punch the value into the context
	    *  otherwise, use the setValue() method do to it.
	    *  Maybe we should always use setValue()
	    */

			if (left.ChildrenCount == 0)
			{
				context.Put(leftReference, value);
			}
			else
			{
				left.SetValue(context, value);
			}

			return true;
		}

		/// <summary>
		/// How this directive is to be initialized.
		/// </summary>
		public virtual void Init(IRuntimeServices rs, IInternalContextAdapter context, INode node)
		{
			runtimeServices = rs;

//			int i, k = node.jjtGetNumChildren();
//			for (i = 0; i < k; i++)
//				node.jjtGetChild(i).init(context, rs);
		}

		public override Object Init(IInternalContextAdapter context, Object data)
		{
			Token t = FirstToken;

			text = NodeUtils.tokenLiteral(t);

			return data;
		}

		/// <summary>
		/// simple init - don't do anything that is context specific.
		/// just get what we need from the AST, which is static.
		/// </summary>
		public override Object Init(IInternalContextAdapter context, Object data)
		{
			base.Init(context, data);

			identifier = FirstToken.Image;

			uberInfo = new Info(context.CurrentTemplateName, Line, Column);
			return data;
		}

		/// <summary>
		/// simple init - init our subtree and get what we can from
		/// the AST
		/// </summary>
		public override Object Init(IInternalContextAdapter context, Object data)
		{
			base.Init(context, data);

			methodName = FirstToken.Image;
			paramCount = ChildrenCount - 1;

			return data;
		}

		public override bool Render(IInternalContextAdapter context, TextWriter writer)
		{
			int i, k = ChildrenCount;

			for(i = 0; i < k; i++)
				GetChild(i).Render(context, writer);

			return true;
		}

		/// <summary>  init : we don't have to do much.  Init the tree (there
		/// shouldn't be one) and then see if interpolation is turned on.
		/// </summary>
		public override Object Init(IInternalContextAdapter context, Object data)
		{
			base.Init(context, data);

			/*
			*  the stringlit is set at template parse time, so we can 
			*  do this here for now.  if things change and we can somehow 
			* create stringlits at runtime, this must
			*  move to the runtime execution path
			*
			*  so, only if interpolation is turned on AND it starts 
			*  with a " AND it has a  directive or reference, then we 
			*  can  interpolate.  Otherwise, don't bother.
			*/

			interpolate = FirstToken.Image.StartsWith("\"") &&
			              ((FirstToken.Image.IndexOf('$') != - 1) ||
			               (FirstToken.Image.IndexOf('#') != - 1));

			/*
			*  get the contents of the string, minus the '/" at each end
			*/

			image = FirstToken.Image.Substring(1, (FirstToken.Image.Length - 1) - (1));
			/*
			* tack a space on the end (dreaded <MORE> kludge)
			*/

			interpolateimage = image + " ";

			if (interpolate)
			{
				/*
				*  now parse and init the nodeTree
				*/
				TextReader br = new StringReader(interpolateimage);

				/*
				* it's possible to not have an initialization context - or we don't
				* want to trust the caller - so have a fallback value if so
				*
				*  Also, do *not* dump the VM namespace for this template
				*/

				nodeTree = rsvc.Parse(br, (context != null) ? context.CurrentTemplateName : "StringLiteral", false);

				/*
				*  init with context. It won't modify anything
				*/

				nodeTree.Init(context, rsvc);
			}

			return data;
		}

		public override Object Value(IInternalContextAdapter context)
		{
			int size = ChildrenCount;

			ArrayList objectArray = new ArrayList(size);

			for(int i = 0; i < size; i++)
				objectArray.Add(GetChild(i).Value(context));

			return objectArray;
		}

		/// <summary>  Initialization method - doesn't do much but do the object
		/// creation.  We only need to do it once.
		/// </summary>
		public override Object Init(IInternalContextAdapter context, Object data)
		{
			/*
	    *  init the tree correctly
	    */

			base.Init(context, data);

			valueField = Int32.Parse(FirstToken.Image);

			return data;
		}

		/// <summary>
		/// simple init - init the tree and get the elementKey from
		/// the AST
		/// </summary>
		public override void Init(IRuntimeServices rs, IInternalContextAdapter context, INode node)
		{
			base.Init(rs, context, node);

			// get the msg, and add the space so we don't have to
			// do it each time
			outputMsgStart = rsvc.GetString(RuntimeConstants.ERRORMSG_START);
			outputMsgStart = outputMsgStart + " ";

			outputMsgEnd = rsvc.GetString(RuntimeConstants.ERRORMSG_END);
			outputMsgEnd = " " + outputMsgEnd;
		}

        /// <summary>
        /// iterates through the argument list and renders every
        /// argument that is appropriate.  Any non appropriate
        /// arguments are logged, but render() continues.
        /// </summary>
        public override bool Render(IInternalContextAdapter context, TextWriter writer, INode node)
        {
            // did we get an argument?
            if (!AssertArgument(node))
            {
                return false;
            }

            // does it have a value?  If you have a null reference, then no.
            Object value;
            if (!AssertNodeHasValue(node, context, out value))
            {
                return false;
            }

            // get the path
            String arg = value.ToString();

            AssertTemplateStack(context);

            Resource current = context.CurrentResource;

            // get the resource, and assume that we use the encoding of the current template
            // the 'current resource' can be null if we are processing a stream....
            String encoding;

            if (current == null)
            {
                encoding = (String) runtimeServices.GetProperty(RuntimeConstants.INPUT_ENCODING);
            }
            else
            {
                encoding = current.Encoding;
            }

            // now use the Runtime resource loader to get the template
            Template t = null;

            t = GetTemplate(arg, encoding, context);
            if (t == null)
            {
                return false;
            }

            // and render it
            if (!RenderTemplate(t, arg, writer, context))
            {
                return false;
            }

            return true;
        }

		/// <summary>
		/// does the real work.  Creates an Vector of Integers with the
		/// right value range
		/// </summary>
		/// <param name="context">app context used if Left or Right of .. is a ref</param>
		/// <returns>Object array of Integers</returns>
		public override Object Value(IInternalContextAdapter context)
		{
			// get the two range ends
			Object left = GetChild(0).Value(context);
			Object right = GetChild(1).Value(context);

			// if either is null, lets log and bail
			if (left == null || right == null)
			{
				runtimeServices.Error(
					string.Format(
						"{0} side of range operator [n..m] has null value. Operation not possible. {1} [line {2}, column {3}]",
						(left == null ? "Left" : "Right"), context.CurrentTemplateName, Line, Column));
				return null;
			}

			// if not an Integer, not much we can do either
			if (!(left is Int32) || !(right is Int32))
			{
				runtimeServices.Error(
					string.Format(
						"{0} side of range operator is not a valid type. Currently only integers (1,2,3...) and Integer type is supported. {1} [line {2}, column {3}]",
						(!(left is Int32) ? "Left" : "Right"), context.CurrentTemplateName, Line, Column));

				return null;
			}

			// get the two integer values of the ends of the range
			int l = ((Int32) left);
			int r = ((Int32) right);

			// find out how many there are
			int num = Math.Abs(l - r);
			num += 1;

			// see if your increment is Pos or Neg
			int delta = (l >= r) ? - 1 : 1;

			// make the vector and fill it
			ArrayList foo = new ArrayList(num);
			int val = l;

			for(int i = 0; i < num; i++)
			{
				foo.Add(val);
				val += delta;
			}

			return foo;
		}