/* Override this method if you want to customize how the node dumps * out its children. */ public void Dump(String prefix) { Console.Out.WriteLine(ToString(prefix)); if (children != null) { for (int i = 0; i < children.Length; ++i) { SimpleNode n = (SimpleNode)children[i]; if (n != null) { n.Dump(string.Format("{0} ", prefix)); } } } }
public override object Value(IInternalContextAdapter context) { int childrenCount = base.ChildrenCount; IDictionary dictionary = new Hashtable(); for (int i = 0; i < childrenCount; i += 2) { SimpleNode simpleNode = (SimpleNode)base.GetChild(i); SimpleNode simpleNode2 = (SimpleNode)base.GetChild(i + 1); object key = (simpleNode == null) ? null : simpleNode.Value(context); object value = (simpleNode2 == null) ? null : simpleNode2.Value(context); dictionary.Add(key, value); } return(dictionary); }
/* Override this method if you want to customize how the node dumps * out its children. */ public virtual void dump(System.String prefix) { System.Console.Out.WriteLine(toString(prefix)); if (children != null) { for (int i = 0; i < children.Length; ++i) { SimpleNode n = (SimpleNode)children[i]; if (n != null) { n.dump(prefix + " "); } } } }
public void Dump(string prefix) { Console.Out.WriteLine(this.ToString(prefix)); if (this.children != null) { for (int i = 0; i < this.children.Length; i++) { SimpleNode simpleNode = (SimpleNode)this.children[i]; if (simpleNode != null) { simpleNode.Dump(prefix + " "); } } } }
private object EvaluateInPlace(string content, IInternalContextAdapter context) { try { SimpleNode inlineNode = runtimeServices.Parse(new StringReader(content), context.CurrentTemplateName, false); inlineNode.Init(context, runtimeServices); return(Evaluate(inlineNode, context)); } catch (Exception) { throw new ArgumentException(string.Format("Problem evaluating dictionary entry with content {0}", content)); } }
/// <summary> /// parses the macro. We need to do this here, at init time, or else /// the local-scope template feature is hard to get to work :) /// </summary> private void parseTree(System.String[] callArgs) { try { //UPGRADE_ISSUE: The equivalent of constructor 'java.io.BufferedReader.BufferedReader' is incompatible with the expected type in C#. 'ms-help://MS.VSCC/commoner/redir/redirect.htm?keyword="jlca1109"' System.IO.TextReader br = new System.IO.StringReader(macroBody); /* * now parse the macro - and don't dump the namespace */ nodeTree = rsvc.parse(br, namespace_Renamed, false); /* * now, to make null references render as proper schmoo * we need to tweak the tree and change the literal of * the appropriate references * * we only do this at init time, so it's the overhead * is irrelevant */ Hashtable hm = new Hashtable(); for (int i = 1; i < argArray.Length; i++) { System.String arg = callArgs[i - 1]; /* * if the calling arg is indeed a reference * then we add to the map. We ignore other * stuff */ if (arg[0] == '$') { hm[argArray[i]] = arg; } } /* * now make one of our reference-munging visitor, and * let 'er rip */ VMReferenceMungeVisitor v = new VMReferenceMungeVisitor(hm); nodeTree.jjtAccept(v, null); } catch (System.Exception e) { rsvc.error("VelocimacroManager.parseTree() : exception " + macroName + " : " + StringUtils.stackTrace(e)); } }
/// <seealso cref="NVelocity.Runtime.Paser.Node.SimpleNode.Value(NVelocity.Context.IInternalContextAdapter)"> /// </seealso> public override object Value(IInternalContextAdapter context) { int size = GetNumChildren(); System.Collections.IDictionary objectMap = new System.Collections.Hashtable(); for (int i = 0; i < size; i += 2) { SimpleNode keyNode = (SimpleNode)GetChild(i); SimpleNode valueNode = (SimpleNode)GetChild(i + 1); object key = (keyNode == null ? null : keyNode.Value(context)); object value = (valueNode == null ? null : valueNode.Value(context)); objectMap[key] = value; } return(objectMap); }
/// <summary> /// Evaluate the node. /// </summary> public override Object Value(IInternalContextAdapter context) { int size = ChildrenCount; IDictionary objectMap = new Hashtable(); for (int i = 0; i < size; i += 2) { SimpleNode keyNode = (SimpleNode)GetChild(i); SimpleNode valueNode = (SimpleNode)GetChild(i + 1); Object key = (keyNode == null ? null : keyNode.Value(context)); Object value = (valueNode == null ? null : valueNode.Value(context)); objectMap.Add(key, value); } return(objectMap); }
/// <summary> does the housekeeping upon creating. If a dynamic type /// it needs to make an AST for further get()/set() operations /// Anything else is constant. /// </summary> private void setup() { switch(type) { case ParserTreeConstants.INTEGER_RANGE: case ParserTreeConstants.REFERENCE: case ParserTreeConstants.OBJECT_ARRAY: case ParserTreeConstants.STRING_LITERAL: case ParserTreeConstants.TEXT: { /* * dynamic types, just render */ constant = false; try { /* * fakie : wrap in directive to get the parser to treat our args as args * it doesn't matter that #include() can't take all these types, because we * just want the parser to consider our arg as a Directive/VM arg rather than * as if inline in schmoo */ String buff = string.Format("#include({0} ) ", callerReference); //ByteArrayInputStream inStream = new ByteArrayInputStream( buff.getBytes() ); //UPGRADE_ISSUE: The equivalent of constructor 'java.io.BufferedReader.BufferedReader' is incompatible with the expected type in C#. 'ms-help://MS.VSCC/commoner/redir/redirect.htm?keyword="jlca1109"' TextReader br = new StringReader(buff); nodeTree = runtimeServices.Parse(br, string.Format("VMProxyArg:{0}", callerReference), true); /* * now, our tree really is the first DirectiveArg(), and only one */ nodeTree = (SimpleNode) nodeTree.GetChild(0).GetChild(0); /* * sanity check */ if (nodeTree != null && nodeTree.Type != type) { runtimeServices.Error("VMProxyArg.setup() : programmer error : type doesn't match node type."); } /* * init. We can do this as they are only references */ nodeTree.Init(null, runtimeServices); } catch(Exception e) { runtimeServices.Error(string.Format("VMProxyArg.setup() : exception {0} : {1}", callerReference, e)); } break; } case ParserTreeConstants.TRUE: { constant = true; staticObject = true; break; } case ParserTreeConstants.FALSE: { constant = true; staticObject = false; break; } case ParserTreeConstants.NUMBER_LITERAL: { constant = true; staticObject = Int32.Parse(callerReference); break; } case ParserTreeConstants.WORD: { /* * this is technically an error... */ runtimeServices.Error( string.Format( "Unsupported arg type : {0} You most likely intended to call a VM with a string literal, so enclose with ' or \" characters. (VMProxyArg.setup())", callerReference)); constant = true; staticObject = new String(callerReference.ToCharArray()); break; } default: { runtimeServices.Error(string.Format(" VMProxyArg.setup() : unsupported type : {0}", callerReference)); } break; } }
/// <summary> /// parses the macro. We need to do this here, at init time, or else /// the local-scope template feature is hard to get to work :) /// </summary> private void parseTree(String[] callArgs) { try { TextReader br = new StringReader(macroBody); // now parse the macro - and don't dump the namespace nodeTree = rsvc.Parse(br, ns, false); // now, to make null references render as proper schmoo // we need to tweak the tree and change the literal of // the appropriate references // we only do this at init time, so it's the overhead // is irrelevant Hashtable hm = new Hashtable(); for(int i = 1; i < argArray.Length; i++) { String arg = callArgs[i - 1]; // if the calling arg is indeed a reference // then we add to the map. We ignore other // stuff if (arg[0] == '$') { hm[argArray[i]] = arg; } } // now make one of our reference-munging visitor, and // let 'er rip VMReferenceMungeVisitor v = new VMReferenceMungeVisitor(hm); nodeTree.Accept(v, null); } catch(Exception e) { rsvc.Error("VelocimacroManager.parseTree() : exception " + macroName + " : " + e); } }
public virtual void RegisterMatch(String xpath, SimpleNode node) { Hashtable foo = new Hashtable(); foo["xpath"] = xpath; foo["ast"] = node; xpathList.Add(foo); }
/// <summary>Display a SimpleNode /// </summary> public override Object Visit(SimpleNode node, Object data) { return ShowNode(node, data); }
private object Evaluate(SimpleNode inlineNode, IInternalContextAdapter context) { ArrayList values = new ArrayList(); for(int i = 0; i < inlineNode.ChildrenCount; i++) { INode node = inlineNode.GetChild(i); if (node.Type == ParserTreeConstants.TEXT) { values.Add(((ASTText) node).Text); } else { values.Add(node.Value(context)); } } if (values.Count == 0) { return null; } else if (values.Count == 1) { return values[0]; } else { StringBuilder sb = new StringBuilder(); foreach(object value in values) { sb.Append(value); } return sb.ToString(); } }
/// <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; }
private object Evaluate(SimpleNode inlineNode, IInternalContextAdapter context) { if (inlineNode.ChildrenCount == 1) { INode child = inlineNode.GetChild(0); return child.Value(context); } else { StringBuilder result = new StringBuilder(); for(int i = 0; i < inlineNode.ChildrenCount; i++) { INode child = inlineNode.GetChild(i); if (child.Type == ParserTreeConstants.REFERENCE) { result.Append(child.Value(context)); } else { result.Append(child.Literal); } } return result.ToString(); } }
/// <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> /// <param name="context"> /// </param> /// <param name="data"> /// </param> /// <returns> Init result. /// </returns> /// <throws> TemplateInitException </throws> public override object Init(IInternalContextAdapter context, object data) { /* * simple habit... we prollie don't have an AST beneath us */ 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 = rsvc.GetBoolean(RuntimeConstants.INTERPOLATE_STRINGLITERALS, true) && 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)); if (FirstToken.Image.StartsWith("\"")) { image = Unescape(image); } /** * note. A kludge on a kludge. The first part, Geir calls this the * dreaded <MORE> kludge. Basically, the use of the <MORE> token eats * the last character of an interpolated string. EXCEPT when a line * comment (##) is in the string this isn't an issue. * * So, to solve this we look for a line comment. If it isn't found we * Add a space here and remove it later. */ /** * Note - this should really use a regexp to look for [^\]## but * apparently escaping of line comments isn't working right now anyway. */ containsLineComment = (image.IndexOf("##") != -1); /* * if appropriate, tack a space on the end (dreaded <MORE> kludge) */ if (!containsLineComment) { interpolateimage = image + " "; } else { interpolateimage = image; } if (interpolate) { /* * now parse and Init the nodeTree */ StringReader 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 */ string templateName = (context != null) ? context.CurrentTemplateName : "StringLiteral"; try { nodeTree = rsvc.Parse(br, templateName, false); } catch (ParseException e) { string msg = "Failed to parse String literal at " + Log.Log.FormatFileString(templateName, Line, Column); throw new TemplateInitException(msg, e, templateName, Column, Line); } AdjTokenLineNums(nodeTree); /* * Init with context. It won't modify anything */ nodeTree.Init(context, rsvc); } return(data); }
internal void parseTree(IInternalContextAdapter ica) { try { //UPGRADE_ISSUE: The equivalent of constructor 'java.io.BufferedReader.BufferedReader' is incompatible with the expected type in C#. 'ms-help://MS.VSCC/commoner/redir/redirect.htm?keyword="jlca1109"' TextReader br = new StringReader(macrobody); nodeTree = Enclosing_Instance.rsvc.Parse(br, "VM:" + macroname, true); nodeTree.Init(ica, null); } catch(System.Exception e) { Enclosing_Instance.rsvc.Error("VelocimacroManager.parseTree() : exception " + macroname + " : " + e); } }
/* * CODE FOR ALTERNATE IMPL : please ignore. I will remove when comfortable with current. */ /// <summary> not used in current impl /// * /// Constructor for alternate impl where VelProxy class would make new /// VMProxyArg objects, and use this constructor to avoid re-parsing the /// reference args /// * /// that impl also had the VMProxyArg carry it's context /// </summary> public VMProxyArg(VMProxyArg model, IInternalContextAdapter c) { userContext = c; contextReference = model.ContextReference; callerReference = model.CallerReference; nodeTree = model.NodeTree; staticObject = model.StaticObject; type = model.Type; if (nodeTree != null) { numTreeChildren = nodeTree.ChildrenCount; } if (type == ParserTreeConstants.REFERENCE) { if (numTreeChildren == 0) { /* * use the reference node to do this... */ singleLevelRef = ((ASTReference) nodeTree).RootString; } } }
internal void parseTree(IInternalContextAdapter internalContextAdapter) { try { //UPGRADE_ISSUE: The equivalent of constructor 'java.io.BufferedReader.BufferedReader' is incompatible with the expected type in C#. 'ms-help://MS.VSCC/commoner/redir/redirect.htm?keyword="jlca1109"' TextReader br = new StringReader(macroBody); nodeTree = Enclosing_Instance.runtimeServices.Parse(br, string.Format("VM:{0}", macroName), true); nodeTree.Init(internalContextAdapter, null); } catch(System.Exception e) { Enclosing_Instance.runtimeServices.Error( string.Format("VelocimacroManager.parseTree() : exception {0} : {1}", macroName, e)); } }
/// <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 System.Object init(InternalContextAdapter context, System.Object data) { /* * simple habit... we prollie don't have an AST beneath us */ 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 = rsvc.getBoolean(NVelocity.Runtime.RuntimeConstants_Fields.INTERPOLATE_STRINGLITERALS, true) && FirstToken.image.StartsWith("\"") && ((FirstToken.image.IndexOf((System.Char) '$') != - 1) || (FirstToken.image.IndexOf((System.Char) '#') != - 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 */ //UPGRADE_ISSUE: The equivalent of constructor 'java.io.BufferedReader.BufferedReader' is incompatible with the expected type in C#. 'ms-help://MS.VSCC/commoner/redir/redirect.htm?keyword="jlca1109"' System.IO.TextReader br = new System.IO.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 virtual System.Object visit(SimpleNode node, System.Object data) { data = node.childrenAccept(this, data); return data; }
public virtual Object Visit(SimpleNode node, Object data) { data = node.ChildrenAccept(this, data); return data; }
/// <summary>Display a SimpleNode /// </summary> public override System.Object visit(SimpleNode node, System.Object data) { return showNode(node, data); }