[Adapdev-commits] Adapdev/src/Adapdev.NVelocity/Runtime/Visitor BaseVisitor.cs,1.4,1.5 NodeViewMode.cs,1.4,1.5 VMReferenceMungeVisitor.cs,1.4,1.5

[Sean M. <int...@us...>]

Update of /cvsroot/adapdev/Adapdev/src/Adapdev.NVelocity/Runtime/Visitor
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv909/src/Adapdev.NVelocity/Runtime/Visitor

Added Files:
	BaseVisitor.cs NodeViewMode.cs VMReferenceMungeVisitor.cs 
Log Message:


--- NEW FILE: NodeViewMode.cs ---
namespace NVelocity.Runtime.Visitor
{
	using System;
	using System.Text;
	using NVelocity.Runtime.Parser;
	using NVelocity.Runtime.Parser.Node;

	/// <summary> This class is simply a visitor implementation
	/// that traverses the AST, produced by the Velocity
	/// parsing process, and creates a visual structure
	/// of the AST. This is primarily used for
	/// debugging, but it useful for documentation
	/// as well.
	/// *
	/// </summary>
	/// <author> <a href="mailto:jv...@ap...">Jason van Zyl</a>
	/// </author>
	/// <version> $Id: NodeViewMode.cs,v 1.5 2005/11/16 07:01:51 intesar66 Exp $
	/// 
	/// </version>
	public class NodeViewMode : BaseVisitor
	{
		private int indent = 0;
		private bool showTokens = true;

		/// <summary>Indent child nodes to help visually identify
		/// the structure of the AST.
		/// </summary>
		private String indentString()
		{
			StringBuilder sb = new StringBuilder();
			for (int i = 0; i < indent; ++i)
			{
				sb.Append("  ");
			}
			return sb.ToString();
		}

		/// <summary> Display the type of nodes and optionally the
		/// first token.
		/// </summary>
		private Object showNode(INode node, Object data)
		{
			String tokens = "";
			String special = "";
			Token t;

			if (showTokens)
			{
				t = node.FirstToken;

				if (t.specialToken != null && !t.specialToken.image.StartsWith("##"))
					special = t.specialToken.image;

				tokens = " -> " + special + t.image;
			}

			Console.Out.WriteLine(indentString() + node + tokens);
			++indent;
			data = node.childrenAccept(this, data);
			--indent;
			return data;
		}

		/// <summary>Display a SimpleNode 
		/// </summary>
		public override Object visit(SimpleNode node, Object data)
		{
			return showNode(node, data);
		}

		/// <summary>Display an ASTprocess node 
		/// </summary>
		public override Object visit(ASTprocess node, Object data)
		{
			return showNode(node, data);
		}

		/// <summary>Display an ASTExpression node 
		/// </summary>
		public override Object visit(ASTExpression node, Object data)
		{
			return showNode(node, data);
		}

		/// <summary>Display an ASTAssignment node ( = ) 
		/// </summary>
		public override Object visit(ASTAssignment node, Object data)
		{
			return showNode(node, data);
		}

		/// <summary>Display an ASTOrNode ( || ) 
		/// </summary>
		public override Object visit(ASTOrNode node, Object data)
		{
			return showNode(node, data);
		}

		/// <summary>Display an ASTAndNode ( && ) 
		/// </summary>
		public override Object visit(ASTAndNode node, Object data)
		{
			return showNode(node, data);
		}

		/// <summary>Display an ASTEQNode ( == ) 
		/// </summary>
		public override Object visit(ASTEQNode node, Object data)
		{
			return showNode(node, data);
		}

		/// <summary>Display an ASTNENode ( != ) 
		/// </summary>
		public override Object visit(ASTNENode node, Object data)
		{
			return showNode(node, data);
		}

		/// <summary>Display an ASTLTNode ( < ) 
		/// </summary>
		public override Object visit(ASTLTNode node, Object data)
		{
			return showNode(node, data);
		}

		/// <summary>Display an ASTGTNode ( > ) 
		/// </summary>
		public override Object visit(ASTGTNode node, Object data)
		{
			return showNode(node, data);
		}

		/// <summary>Display an ASTLENode ( <= ) 
		/// </summary>
		public override Object visit(ASTLENode node, Object data)
		{
			return showNode(node, data);
		}

		/// <summary>Display an ASTGENode ( >= ) 
		/// </summary>
		public override Object visit(ASTGENode node, Object data)
		{
			return showNode(node, data);
		}

		/// <summary>Display an ASTAddNode ( + ) 
		/// </summary>
		public override Object visit(ASTAddNode node, Object data)
		{
			return showNode(node, data);
		}

		/// <summary>Display an ASTSubtractNode ( - ) 
		/// </summary>
		public override Object visit(ASTSubtractNode node, Object data)
		{
			return showNode(node, data);
		}

		/// <summary>Display an ASTMulNode ( * ) 
		/// </summary>
		public override Object visit(ASTMulNode node, Object data)
		{
			return showNode(node, data);
		}

		/// <summary>Display an ASTDivNode ( / ) 
		/// </summary>
		public override Object visit(ASTDivNode node, Object data)
		{
			return showNode(node, data);
		}

		/// <summary>Display an ASTModNode ( % ) 
		/// </summary>
		public override Object visit(ASTModNode node, Object data)
		{
			return showNode(node, data);
		}

		/// <summary>Display an ASTNotNode ( ! ) 
		/// </summary>
		public override Object visit(ASTNotNode node, Object data)
		{
			return showNode(node, data);
		}

		/// <summary>Display an ASTNumberLiteral node  
		/// </summary>
		public override Object visit(ASTNumberLiteral node, Object data)
		{
			return showNode(node, data);
		}

		/// <summary>Display an ASTStringLiteral node 
		/// </summary>
		public override Object visit(ASTStringLiteral node, Object data)
		{
			return showNode(node, data);
		}

		/// <summary>Display an ASTIdentifier node 
		/// </summary>
		public override Object visit(ASTIdentifier node, Object data)
		{
			return showNode(node, data);
		}

		/// <summary>Display an ASTMethod node 
		/// </summary>
		public override Object visit(ASTMethod node, Object data)
		{
			return showNode(node, data);
		}

		/// <summary>Display an ASTReference node 
		/// </summary>
		public override Object visit(ASTReference node, Object data)
		{
			return showNode(node, data);
		}

		/// <summary>Display an ASTTrue node 
		/// </summary>
		public override Object visit(ASTTrue node, Object data)
		{
			return showNode(node, data);
		}

		/// <summary>Display an ASTFalse node 
		/// </summary>
		public override Object visit(ASTFalse node, Object data)
		{
			return showNode(node, data);
		}

		/// <summary>Display an ASTBlock node 
		/// </summary>
		public override Object visit(ASTBlock node, Object data)
		{
			return showNode(node, data);
		}

		/// <summary>Display an ASTText node 
		/// </summary>
		public override Object visit(ASTText node, Object data)
		{
			return showNode(node, data);
		}

		/// <summary>Display an ASTIfStatement node 
		/// </summary>
		public override Object visit(ASTIfStatement node, Object data)
		{
			return showNode(node, data);
		}

		/// <summary>Display an ASTElseStatement node 
		/// </summary>
		public override Object visit(ASTElseStatement node, Object data)
		{
			return showNode(node, data);
		}

		/// <summary>Display an ASTElseIfStatement node 
		/// </summary>
		public override Object visit(ASTElseIfStatement node, Object data)
		{
			return showNode(node, data);
		}

		public override Object visit(ASTObjectArray node, Object data)
		{
			return showNode(node, data);
		}

		public override Object visit(ASTDirective node, Object data)
		{
			return showNode(node, data);
		}

		public override Object visit(ASTWord node, Object data)
		{
			return showNode(node, data);
		}

		public override Object visit(ASTSetDirective node, Object data)
		{
			return showNode(node, data);
		}
	}
}
--- NEW FILE: VMReferenceMungeVisitor.cs ---
namespace NVelocity.Runtime.Visitor
{
	using System;
	using System.Collections;
	using NVelocity.Runtime.Parser.Node;

	/// <summary>
	/// This class is a visitor used by the VM proxy to change the 
	/// literal representation of a reference in a VM.  The reason is
	/// to preserve the 'render literal if null' behavior w/o making
	/// the VMProxy stuff more complicated than it is already.
	/// </summary>
	/// <author> <a href="mailto:ge...@op...">Geir Magnusson Jr.</a></author>
	/// <version> $Id: VMReferenceMungeVisitor.cs,v 1.5 2005/11/16 07:01:51 intesar66 Exp $</version>
	public class VMReferenceMungeVisitor : BaseVisitor
	{
		/// <summary>
		/// Map containing VM arg to instance-use reference
		/// Passed in with CTOR
		/// </summary>
		private Hashtable argmap = null;

		/// <summary>
		/// CTOR - takes a map of args to reference
		/// </summary>
		public VMReferenceMungeVisitor(Hashtable map)
		{
			argmap = map;
		}

		/// <summary>
		/// Visitor method - if the literal is right, will
		/// set the literal in the ASTReference node
		/// </summary>
		/// <param name="node">ASTReference to work on</param>
		/// <param name="data">Object to pass down from caller</param>
		public override Object visit(ASTReference node, Object data)
		{
			/*
	    *  see if there is an override value for this
	    *  reference
	    */
			String override_Renamed = (String) argmap[node.literal().Substring(1)];

			/*
	    *  if so, set in the node
	    */
			if (override_Renamed != null)
			{
				node.Literal = override_Renamed;
			}

			/*
	    *  feed the children...
	    */
			data = node.childrenAccept(this, data);

			return data;
		}
	}
}
--- NEW FILE: BaseVisitor.cs ---
namespace NVelocity.Runtime.Visitor
{
	using System;
	using System.IO;
	using NVelocity.Context;
	using NVelocity.Runtime.Parser.Node;

	/// <summary> This is the base class for all visitors.
	/// For each AST node, this class will provide
	/// a bare-bones method for traversal.
	/// *
	/// </summary>
	/// <author> <a href="mailto:jv...@ap...">Jason van Zyl</a>
	/// </author>
	/// <author> <a href="mailto:ge...@op...">Geir Magnusson Jr.</a>
	/// </author>
	/// <version> $Id: BaseVisitor.cs,v 1.5 2005/11/16 07:01:51 intesar66 Exp $
	/// 
	/// </version>
	public abstract class BaseVisitor : ParserVisitor
	{
		public virtual StreamWriter Writer
		{
			set { this.writer = value; }

		}

		public virtual InternalContextAdapter Context
		{
			set { this.context = value; }

		}

		/// <summary>Context used during traversal 
		/// </summary>
		protected internal InternalContextAdapter context;

		/// <summary>Writer used as the output sink 
		/// </summary>
		protected internal StreamWriter writer;


		public virtual Object visit(SimpleNode node, Object data)
		{
			data = node.childrenAccept(this, data);
			return data;
		}

		public virtual Object visit(ASTprocess node, Object data)
		{
			data = node.childrenAccept(this, data);
			return data;
		}

		public virtual Object visit(ASTExpression node, Object data)
		{
			data = node.childrenAccept(this, data);
			return data;
		}

		public virtual Object visit(ASTAssignment node, Object data)
		{
			data = node.childrenAccept(this, data);
			return data;
		}

		public virtual Object visit(ASTOrNode node, Object data)
		{
			data = node.childrenAccept(this, data);
			return data;
		}

		public virtual Object visit(ASTAndNode node, Object data)
		{
			data = node.childrenAccept(this, data);
			return data;
		}

		public virtual Object visit(ASTEQNode node, Object data)
		{
			data = node.childrenAccept(this, data);
			return data;
		}

		public virtual Object visit(ASTNENode node, Object data)
		{
			data = node.childrenAccept(this, data);
			return data;
		}

		public virtual Object visit(ASTLTNode node, Object data)
		{
			data = node.childrenAccept(this, data);
			return data;
		}

		public virtual Object visit(ASTGTNode node, Object data)
		{
			data = node.childrenAccept(this, data);
			return data;
		}

		public virtual Object visit(ASTLENode node, Object data)
		{
			data = node.childrenAccept(this, data);
			return data;
		}

		public virtual Object visit(ASTGENode node, Object data)
		{
			data = node.childrenAccept(this, data);
			return data;
		}

		public virtual Object visit(ASTAddNode node, Object data)
		{
			data = node.childrenAccept(this, data);
			return data;
		}

		public virtual Object visit(ASTSubtractNode node, Object data)
		{
			data = node.childrenAccept(this, data);
			return data;
		}

		public virtual Object visit(ASTMulNode node, Object data)
		{
			data = node.childrenAccept(this, data);
			return data;
		}

		public virtual Object visit(ASTDivNode node, Object data)
		{
			data = node.childrenAccept(this, data);
			return data;
		}

		public virtual Object visit(ASTModNode node, Object data)
		{
			data = node.childrenAccept(this, data);
			return data;
		}

		public virtual Object visit(ASTNotNode node, Object data)
		{
			data = node.childrenAccept(this, data);
			return data;
		}

		public virtual Object visit(ASTNumberLiteral node, Object data)
		{
			data = node.childrenAccept(this, data);
			return data;
		}

		public virtual Object visit(ASTStringLiteral node, Object data)
		{
			data = node.childrenAccept(this, data);
			return data;
		}

		public virtual Object visit(ASTIdentifier node, Object data)
		{
			data = node.childrenAccept(this, data);
			return data;
		}

		public virtual Object visit(ASTMethod node, Object data)
		{
			data = node.childrenAccept(this, data);
			return data;
		}

		public virtual Object visit(ASTReference node, Object data)
		{
			data = node.childrenAccept(this, data);
			return data;
		}

		public virtual Object visit(ASTTrue node, Object data)
		{
			data = node.childrenAccept(this, data);
			return data;
		}

		public virtual Object visit(ASTFalse node, Object data)
		{
			data = node.childrenAccept(this, data);
			return data;
		}

		public virtual Object visit(ASTBlock node, Object data)
		{
			data = node.childrenAccept(this, data);
			return data;
		}

		public virtual Object visit(ASTText node, Object data)
		{
			data = node.childrenAccept(this, data);
			return data;
		}

		public virtual Object visit(ASTIfStatement node, Object data)
		{
			data = node.childrenAccept(this, data);
			return data;
		}

		public virtual Object visit(ASTElseStatement node, Object data)
		{
			data = node.childrenAccept(this, data);
			return data;
		}

		public virtual Object visit(ASTElseIfStatement node, Object data)
		{
			data = node.childrenAccept(this, data);
			return data;
		}

		public virtual Object visit(ASTComment node, Object data)
		{
			data = node.childrenAccept(this, data);
			return data;
		}

		public virtual Object visit(ASTObjectArray node, Object data)
		{
			data = node.childrenAccept(this, data);
			return data;
		}

		public virtual Object visit(ASTWord node, Object data)
		{
			data = node.childrenAccept(this, data);
			return data;
		}

		public virtual Object visit(ASTSetDirective node, Object data)
		{
			data = node.childrenAccept(this, data);
			return data;
		}

		public virtual Object visit(ASTDirective node, Object data)
		{
			data = node.childrenAccept(this, data);
			return data;
		}
	}
}