package org.apache.velocity.runtime.directive;
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
import java.io.IOException;
import java.io.Writer;
import org.apache.commons.lang.StringUtils;
import org.apache.velocity.context.InternalContextAdapter;
import org.apache.velocity.context.ProxyVMContext;
import org.apache.velocity.exception.MacroOverflowException;
import org.apache.velocity.exception.MethodInvocationException;
import org.apache.velocity.exception.TemplateInitException;
import org.apache.velocity.exception.VelocityException;
import org.apache.velocity.runtime.RuntimeConstants;
import org.apache.velocity.runtime.RuntimeServices;
import org.apache.velocity.runtime.parser.node.ASTDirective;
import org.apache.velocity.runtime.parser.node.Node;
import org.apache.velocity.runtime.parser.node.SimpleNode;
/**
* VelocimacroProxy.java
*
* a proxy Directive-derived object to fit with the current directive system
*
* @author <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a>
* @version $Id: VelocimacroProxy.java 687177 2008-08-19 22:00:32Z nbubna $
*/
public class VelocimacroProxy extends Directive
{
private String macroName;
private String[] argArray = null;
private String[] literalArgArray = null;
private SimpleNode nodeTree = null;
private int numMacroArgs = 0;
private boolean preInit = false;
private boolean strictArguments;
private boolean localContextScope = false;
private int maxCallDepth;
/**
* Return name of this Velocimacro.
* @return The name of this Velocimacro.
*/
public String getName()
{
return macroName;
}
/**
* Velocimacros are always LINE type directives.
* @return The type of this directive.
*/
public int getType()
{
return LINE;
}
/**
* sets the directive name of this VM
*
* @param name
*/
public void setName(String name)
{
macroName = name;
}
/**
* sets the array of arguments specified in the macro definition
*
* @param arr
*/
public void setArgArray(String[] arr)
{
argArray = arr;
// for performance reasons we precache these strings - they are needed in
// "render literal if null" functionality
literalArgArray = new String[arr.length];
for(int i = 0; i < arr.length; i++)
{
literalArgArray[i] = ".literal.$" + argArray[i];
}
/*
* get the arg count from the arg array. remember that the arg array has the macro name as
* it's 0th element
*/
numMacroArgs = argArray.length - 1;
}
/**
* @param tree
*/
public void setNodeTree(SimpleNode tree)
{
nodeTree = tree;
}
/**
* returns the number of ars needed for this VM
*
* @return The number of ars needed for this VM
*/
public int getNumArgs()
{
return numMacroArgs;
}
/**
* Renders the macro using the context.
*
* @param context Current rendering context
* @param writer Writer for output
* @param node AST that calls the macro
* @return True if the directive rendered successfully.
* @throws IOException
* @throws MethodInvocationException
* @throws MacroOverflowException
*/
public boolean render(InternalContextAdapter context, Writer writer, Node node)
throws IOException, MethodInvocationException, MacroOverflowException
{
// wrap the current context and add the macro arguments
// the creation of this context is a major bottleneck (incl 2x HashMap)
final ProxyVMContext vmc = new ProxyVMContext(context, rsvc, localContextScope);
int callArguments = node.jjtGetNumChildren();
if (callArguments > 0)
{
// the 0th element is the macro name
for (int i = 1; i < argArray.length; i++)
{
Node macroCallArgument = node.jjtGetChild(i - 1);
/*
* literalArgArray[i] is needed for "render literal if null" functionality.
* The value is used in ASTReference render-method.
*
* The idea is to avoid generating the literal until absolutely necessary.
*
* This makes VMReferenceMungeVisitor obsolete and it would not work anyway
* when the macro AST is shared
*/
vmc.addVMProxyArg(context, argArray[i], literalArgArray[i], macroCallArgument);
}
}
/*
* check that we aren't already at the max call depth
*/
if (maxCallDepth > 0 && maxCallDepth == vmc.getCurrentMacroCallDepth())
{
String templateName = vmc.getCurrentTemplateName();
Object[] stack = vmc.getMacroNameStack();
String message = "Max calling depth of " + maxCallDepth + " was exceeded in Template:"
+ templateName + " and Macro:" + macroName + " with Call Stack:";
for (int i = 0; i < stack.length; i++)
{
if (i != 0)
{
message += "->";
}
message += stack[i];
}
rsvc.getLog().error(message);
try
{
throw new MacroOverflowException(message);
}
finally
{
// clean out the macro stack, since we just broke it
while (vmc.getCurrentMacroCallDepth() > 0)
{
vmc.popCurrentMacroName();
}
}
}
try
{
// render the velocity macro
vmc.pushCurrentMacroName(macroName);
nodeTree.render(vmc, writer);
vmc.popCurrentMacroName();
return true;
}
catch (MethodInvocationException e)
{
throw e;
}
catch (RuntimeException e)
{
throw e;
}
catch (Exception e)
{
String msg = "VelocimacroProxy.render() : exception VM = #" + macroName + "()";
rsvc.getLog().error(msg, e);
throw new VelocityException(msg, e);
}
}
/**
* The major meat of VelocimacroProxy, init() checks the # of arguments.
*
* @param rs
* @param context
* @param node
* @throws TemplateInitException
*/
public void init(RuntimeServices rs, InternalContextAdapter context, Node node)
throws TemplateInitException
{
// there can be multiple threads here so avoid double inits
synchronized (this)
{
if (!preInit)
{
super.init(rs, context, node);
// this is a very expensive call (ExtendedProperties is very slow)
strictArguments = rs.getConfiguration().getBoolean(
RuntimeConstants.VM_ARGUMENTS_STRICT, false);
// support for local context scope feature, where all references are local
// we do not have to check this at every invocation of ProxyVMContext
localContextScope = rsvc.getBoolean(RuntimeConstants.VM_CONTEXT_LOCALSCOPE, false);
// get the macro call depth limit
maxCallDepth = rsvc.getInt(RuntimeConstants.VM_MAX_DEPTH);
// initialize the parsed AST
// since this is context independent we need to do this only once so
// do it here instead of the render method
nodeTree.init(context, rs);
preInit = true;
}
}
// check how many arguments we got
int i = node.jjtGetNumChildren();
// Throw exception for invalid number of arguments?
if (getNumArgs() != i)
{
// If we have a not-yet defined macro, we do get no arguments because
// the syntax tree looks different than with a already defined macro.
// But we do know that we must be in a macro definition context somewhere up the
// syntax tree.
// Check for that, if it is true, suppress the error message.
// Fixes VELOCITY-71.
for (Node parent = node.jjtGetParent(); parent != null;)
{
if ((parent instanceof ASTDirective)
&& StringUtils.equals(((ASTDirective) parent).getDirectiveName(), "macro"))
{
return;
}
parent = parent.jjtGetParent();
}
String msg = "VM #" + macroName + ": too "
+ ((getNumArgs() > i) ? "few" : "many") + " arguments to macro. Wanted "
+ getNumArgs() + " got " + i;
if (strictArguments)
{
/**
* indicate col/line assuming it starts at 0 - this will be corrected one call up
*/
throw new TemplateInitException(msg, context.getCurrentTemplateName(), 0, 0);
}
else
{
rsvc.getLog().debug(msg);
return;
}
}
}
}