/**
* Returns OgnlRuntime.NotFound if the property does not exist.
*/
public object getPossibleProperty(IDictionary context, object target, string name) // throws OgnlException
{
object result;
OgnlContext ognlContext = (OgnlContext)context;
if (context [("_compile")] != null)
{
Getter getter = getGetter(ognlContext, target, name);
if (getter != NotFoundGetter)
{
result = getter.get(ognlContext, target, name);
}
else
{
try
{
result = OgnlRuntime.getFieldValue(ognlContext, target, name, true);
}
catch (Exception ex)
{
throw new OgnlException(name, ex);
}
}
}
else
{
result = base.getPossibleProperty(context, target, name);
}
return(result);
}
protected override object getValueBody(OgnlContext context, object source) // throws OgnlException
{
IDictionary answer;
if (className == null)
{
try {
answer = (IDictionary)DEFAULT_MAP_CLASS.GetConstructor(new Type[0]).Invoke(new object[0]);
} catch (Exception ex) {
/* This should never happen */
throw new OgnlException("Default IDictionary class '" + DEFAULT_MAP_CLASS.Name + "' instantiation error", ex);
}
}
else
{
try {
answer = (IDictionary)OgnlRuntime.classForName(context, className).GetConstructor(new Type[0]).Invoke(new object[0]);
} catch (Exception ex) {
throw new OgnlException("IDictionary implementor '" + className + "' not found", ex);
}
}
for (int i = 0; i < jjtGetNumChildren(); ++i)
{
ASTKeyValue kv = (ASTKeyValue)children[i];
Node k = kv.getKey(),
v = kv.getValue();
answer.Add(k.getValue(context, source), (v == null) ? null : v.getValue(context, source));
}
return(answer);
}
public object getProperty(IDictionary context, object target, object name) // throws OgnlException
{
if ("x".Equals(name) || "y".Equals(name))
{
return(OgnlRuntime.getProperty((OgnlContext)context, target, name));
}
return(null);
}
public override bool isNodeConstant(OgnlContext context) // throws OgnlException
{
bool result = false;
Exception reason = null;
try {
Type c = OgnlRuntime.classForName(context, className);
/*
* Check for virtual static field "class"; this cannot interfere with
* normal static fields because it is a reserved word. It is considered
* constant.
*/
if (fieldName.Equals("class"))
{
result = true;
}
else
{
FieldInfo f = c.GetField(fieldName);
if (f == null)
{
// try to load Property
PropertyInfo p = c.GetProperty(fieldName);
if (p == null)
{
throw new MissingFieldException("Field or Property " + fieldName + " of class " + className + " is not found.");
}
else
if (!p.GetAccessors() [0].IsStatic)
{
throw new MissingFieldException("Property " + fieldName + " of class " + className + " is not static.");
}
// Property can't be constant.
else
{
return(false);
}
}
else
if (!f.IsStatic)
{
throw new OgnlException("Field " + fieldName + " of class " + className + " is not static");
}
result = f.IsLiteral;
}
} catch (TypeLoadException e) { reason = e; }
catch (MissingFieldException e) { reason = e; }
catch (SecurityException e) { reason = e; }
if (reason != null)
{
throw new OgnlException("Could not get static field " + fieldName + " from class " + className, reason);
}
return(result);
}
public bool hasGetProperty(OgnlContext context, object target, object oname) // throws OgnlException
{
try
{
return(OgnlRuntime.hasGetProperty(context, target, oname));
}
catch (/*Introspection*/ Exception ex)
{
throw new OgnlException("checking if " + target + " has gettable property " + oname, ex);
}
}
protected override object getValueBody(OgnlContext context, object source) // throws OgnlException
{
Node expr = children[0];
IList answer = new ArrayList();
IElementsAccessor elementsAccessor = OgnlRuntime.getElementsAccessor(OgnlRuntime.getTargetClass(source));
for (IEnumerator e = elementsAccessor.getElements(source); e.MoveNext();)
{
answer.Add(expr.getValue(context, e.Current));
}
return(answer);
}
/**
* Returns true if this property is described by an IndexedPropertyDescriptor
* and that if followed by an index specifier it will call the index get/set
* methods rather than go through property accessors.
*/
public int getIndexedPropertyType(OgnlContext context, object source) // throws OgnlException
{
if (!isIndexedAccess())
{
object property = getProperty(context, source);
if (property is string)
{
return(OgnlRuntime.getIndexedPropertyType(context, (source == null) ? null : source.GetType(), (string)property));
}
}
return(OgnlRuntime.INDEXED_PROPERTY_NONE);
}
public object callMethod(IDictionary context, object target, string methodName, object[] args) // throws MethodFailedException
{
Type targetClass = (target == null) ? null : target.GetType();
object source = target;
IList methods = OgnlRuntime.getMethods(targetClass, methodName, false);
if ((methods == null) || (methods.Count == 0))
{
methods = OgnlRuntime.getMethods(targetClass, methodName, true);
source = targetClass;
}
return(OgnlRuntime.callAppropriateMethod((OgnlContext)context, target, target, methodName, null, methods, args));
}
protected override void setValueBody(OgnlContext context, object target, object value) // throws OgnlException
{
if (indexedAccess && children [0] is ASTSequence)
{
// As property [index1, index2]...
// Use Indexer.
object [] indexParameters = ((ASTSequence)children [0]).getValues(context, context.getRoot());
/*IndexerAccessor.setIndexerValue (target, value ,indexParameters) ;*/
OgnlRuntime.setIndxerValue(context, target, "Indexer", value, indexParameters);
return;
}
OgnlRuntime.setProperty(context, target, getProperty(context, target), value);
}
protected override object getValueBody(OgnlContext context, object source) // throws OgnlException
{
object[] args = OgnlRuntime.getObjectArrayPool().create(jjtGetNumChildren());
object root = context.getRoot();
try {
for (int i = 0, icount = args.Length; i < icount; ++i)
{
args[i] = children[i].getValue(context, root);
}
return(OgnlRuntime.callStaticMethod(context, className, methodName, args));
} finally {
OgnlRuntime.getObjectArrayPool().recycle(args);
}
}
public void testPropertyDescriptorReflection() // throws Exception
{
OgnlRuntime.getPropertyDescriptor(typeof(CollectionBase), "");
// OgnlRuntime.getPropertyDescriptor(typeof (java.util.AbstractSequentialList), "");
OgnlRuntime.getPropertyDescriptor(typeof(System.Array), "");
OgnlRuntime.getPropertyDescriptor(typeof(ArrayList), "");
// OgnlRuntime.getPropertyDescriptor(typeof (java.util.BitSet), "");
OgnlRuntime.getPropertyDescriptor(typeof(System.DateTime), "");
OgnlRuntime.getPropertyDescriptor(typeof(FieldInfo), "");
// OgnlRuntime.getPropertyDescriptor(typeof (java.util.LinkedList), "");
OgnlRuntime.getPropertyDescriptor(typeof(IList), "");
OgnlRuntime.getPropertyDescriptor(typeof(IEnumerator), "");
// OgnlRuntime.getPropertyDescriptor(typeof (java.lang.ThreadLocal), "");
OgnlRuntime.getPropertyDescriptor(typeof(Uri), "");
OgnlRuntime.getPropertyDescriptor(typeof(Stack), "");
}
public virtual object getProperty(IDictionary context, object target, object oname) // throws OgnlException
{
object result = OgnlRuntime.NotFound;
Node currentNode = ((OgnlContext)context).getCurrentNode();
bool indexedAccess = false;
if (currentNode == null)
{
throw new OgnlException("node is null for '" + oname + "'");
}
if (!(currentNode is ASTProperty))
{
currentNode = currentNode.jjtGetParent();
}
if (currentNode is ASTProperty)
{
indexedAccess = ((ASTProperty)currentNode).isIndexedAccess();
}
if (((oname is string) && isPropertyName((string)oname)) &&
(!indexedAccess ||
!OgnlRuntime.hasSetIndexer((OgnlContext)context, target, target.GetType(), 1)))
{
result = javaGetProperty(oname, context, target);
}
else
{
// will use index Access property
/*
* PropertyInfo indexer = IndexerAccessor.getIndexer (target, new object [] {oname}) ;
* if (indexer != null)
* result = indexer.GetValue (target , new object[] {oname}) ;
* else
* // throw new NoSuchPropertyException(target, oname.ToString ()) ;
* // TODO: support old java style property: [propertyName].
* result = javaGetProperty (oname, context, target) ;
*/
result = OgnlRuntime.getIndxerValue((OgnlContext)context, target, oname, new object[] { oname });
}
return(result);
}
public static bool operin(object v1, object v2) // throws OgnlException
{
if (v2 == null) // A null collection is always treated as empty
{
return(false);
}
IElementsAccessor elementsAccessor = OgnlRuntime.getElementsAccessor(OgnlRuntime.getTargetClass(v2));
for (IEnumerator e = elementsAccessor.getElements(v2); e.MoveNext();)
{
object o = e.Current;
if (equal(v1, o))
{
return(true);
}
}
return(false);
}
///<summary>
/// Returns OgnlRuntime.NotFound if the property does not exist.
///</summary>
public object setPossibleProperty(IDictionary context, object target, string name, object value) // throws OgnlException
{
object result = null;
OgnlContext ognlContext = (OgnlContext)context;
try
{
if (!OgnlRuntime.setMethodValue(ognlContext, target, name, value, true))
{
result = OgnlRuntime.setFieldValue(ognlContext, target, name, value) ? null : OgnlRuntime.NotFound;
}
}
catch (OgnlException ex)
{
throw ex;
}
catch (Exception ex)
{
throw new OgnlException(name, ex);
}
return(result);
}
public virtual void setProperty(IDictionary context, object target, object oname, object value) // throws OgnlException
{
object result = OgnlRuntime.NotFound;
string name = oname.ToString();
Node currentNode = ((OgnlContext)context).getCurrentNode();
bool indexedAccess = false;
if (currentNode == null)
{
throw new OgnlException("node is null for '" + oname + "'");
}
if (!(currentNode is ASTProperty))
{
currentNode = currentNode.jjtGetParent();
}
if (currentNode is ASTProperty)
{
indexedAccess = ((ASTProperty)currentNode).isIndexedAccess();
}
if (!indexedAccess || !OgnlRuntime.hasSetIndexer((OgnlContext)context, target, target.GetType(), 1))
{
if ((result = setPossibleProperty(context, target, name, value)) == OgnlRuntime.NotFound)
{
throw new NoSuchPropertyException(target, name);
}
}
else
{
/*
* PropertyInfo indexer = IndexerAccessor.getIndexer (target, new object[] {oname}) ;
* if (indexer == null)
* throw new NoSuchPropertyException(target, name) ;
*
* indexer.SetValue (target , value , new object[] {oname}) ;
*/
OgnlRuntime.setIndxerValue((OgnlContext)context, target, oname, value, new object[] { oname });
}
}
public object getValue(OgnlContext context, object source)
{
if (context.getTraceEvaluations())
{
EvaluationPool pool = OgnlRuntime.getEvaluationPool();
object result = null;
Exception evalException = null;
Evaluation evaluation = pool.create(this, source);
context.pushEvaluation(evaluation);
try {
result = evaluateGetValueBody(context, source);
} catch (OgnlException ex) {
evalException = ex;
throw ex;
} catch (Exception ex) {
evalException = ex;
throw ex;
} finally {
Evaluation eval = context.popEvaluation();
eval.setResult(result);
if (evalException != null)
{
eval.setException(evalException);
}
if ((evalException == null) && (context.getRootEvaluation() == null) && !context.getKeepLastEvaluation())
{
pool.recycleAll(eval);
}
}
return(result);
}
else
{
return(evaluateGetValueBody(context, source));
}
}
protected override object getValueBody(OgnlContext context, object source) // throws OgnlException
{
if (indexedAccess && children [0] is ASTSequence)
{
// As property [index1, index2]...
// Use Indexer.
object [] indexParameters = ((ASTSequence)children [0]).getValues(context, context.getRoot());
/* return IndexerAccessor.getIndexerValue (source, indexParameters) ; */
return(OgnlRuntime.getIndxerValue(context, source, "Indexer", indexParameters));
}
object result;
object property = getProperty(context, source);
Node indexSibling;
result = OgnlRuntime.getProperty(context, source, property);
if (result == null)
{
result = OgnlRuntime.getNullHandler(OgnlRuntime.getTargetClass(source)).nullPropertyValue(context, source, property);
}
return(result);
}
protected override object getValueBody(OgnlContext context, object source) // throws OgnlException
{
object[] args = OgnlRuntime.getObjectArrayPool().create(jjtGetNumChildren());
try {
object result,
root = context.getRoot();
for (int i = 0, icount = args.Length; i < icount; ++i)
{
args[i] = children[i].getValue(context, root);
}
result = OgnlRuntime.callMethod(context, source, methodName, null, args);
if (result == null)
{
NullHandler nh = OgnlRuntime.getNullHandler(OgnlRuntime.getTargetClass(source));
result = nh.nullMethodResult(context, source, methodName, args);
}
return(result);
} finally {
OgnlRuntime.getObjectArrayPool().recycle(args);
}
}
public void setValue(OgnlContext context, object target, object value)
{
if (context.getTraceEvaluations())
{
EvaluationPool pool = OgnlRuntime.getEvaluationPool();
Exception evalException = null;
Evaluation evaluation = pool.create(this, target, true);
context.pushEvaluation(evaluation);
try {
evaluateSetValueBody(context, target, value);
} catch (OgnlException ex) {
evalException = ex;
ex.setEvaluation(evaluation);
throw ex;
} catch (Exception ex) {
evalException = ex;
throw ex;
} finally {
Evaluation eval = context.popEvaluation();
if (evalException != null)
{
eval.setException(evalException);
}
if ((evalException == null) && (context.getRootEvaluation() == null) && !context.getKeepLastEvaluation())
{
pool.recycleAll(eval);
}
}
}
else
{
evaluateSetValueBody(context, target, value);
}
}
/* MethodAccessor interface */
public object callStaticMethod(IDictionary context, Type targetClass, string methodName, object[] args) // throws MethodFailedException
{
IList methods = OgnlRuntime.getMethods(targetClass, methodName, true);
return(OgnlRuntime.callAppropriateMethod((OgnlContext)context, targetClass, null, methodName, null, methods, args));
}
protected override object getValueBody(OgnlContext context, object source) // throws OgnlException
{
return(OgnlRuntime.getStaticField(context, className, fieldName));
}
public override void setUp()
{
base.setUp();
OgnlRuntime.setPropertyAccessor(typeof(Blah), new BlahPropertyAccessor());
}
///<summary>
/// This method can be called when the last evaluation has been used
/// and can be returned for reuse in the free pool maintained by the
/// runtime. This is not a necessary step, but is useful for keeping
/// memory usage down. This will recycle the last evaluation and then
/// set the last evaluation to null.
///</summary>
public void recycleLastEvaluation()
{
OgnlRuntime.getEvaluationPool().recycleAll(lastEvaluation);
lastEvaluation = null;
}
/// <summary>
/// Returns the value converted numerically to the given class type
/// </summary>
/// <remarks>
/// This method also detects when arrays are being converted and
/// converts the components of one array to the type of the other.
/// </remarks>
/// <param name="value">an object to be converted to the given type</param>
///<param name="toType">class type to be converted to</param>
/// <returns>converted value of the type given, or value if the value
/// cannot be converted to the given type.</returns>
///
public static object convertValue(object value, Type toType)
{
object result = null;
if (value != null)
{
/* If array -> array then convert components of array individually */
if (value.GetType().IsArray&& toType.IsArray)
{
Type componentType = toType.GetElementType();
result = Array.CreateInstance(componentType, ((Array)value).Length);
for (int i = 0, icount = ((Array)value).Length; i < icount; i++)
{
((Array)result).SetValue(convertValue(((Array)value).GetValue(i), componentType), i);
}
}
else
{
if ((toType == typeof(int)) || (toType == typeof(uint)))
{
result = (int)longValue(value);
}
if ((toType == typeof(Double)) || (toType == typeof(double)))
{
result = doubleValue(value);
}
if ((toType == typeof(Boolean) || (toType == typeof(bool))))
{
result = booleanValue(value); // ? Boolean.TRUE : Boolean.FALSE;
}
if ((toType == typeof(Byte) || (toType == typeof(byte))))
{
result = (byte)longValue(value);
}
if ((toType == typeof(char)) || (toType == typeof(char)))
{
result = ((char)longValue(value));
}
if ((toType == typeof(short)) || (toType == typeof(ushort)))
{
result = (short)longValue(value);
}
if ((toType == typeof(long)) || (toType == typeof(ulong)))
{
result = (longValue(value));
}
if ((toType == typeof(float)) || (toType == typeof(Single)))
{
result = (float)(doubleValue(value));
}
// ignore if ( toType == BigInteger.class ) result = bigIntValue(value);
if (toType == typeof(decimal))
{
result = bigDecValue(value);
}
if (toType == typeof(string))
{
result = stringValue(value);
}
if (toType.IsEnum)
{
result = enumValue(value, toType);
}
}
}
else
{
if (toType.IsPrimitive)
{
result = OgnlRuntime.getPrimitiveDefaultValue(toType);
}
else
// support Enum
if (toType.IsEnum)
{
result = Enum.GetValues(toType).GetValue(0);
}
}
return(result);
}
private Getter getGetter(OgnlContext context, object target, string propertyName) // throws OgnlException
{
Getter result;
Type targetClass = target.GetType();
IDictionary propertyMap;
if ((propertyMap = (IDictionary)seenGetMethods.get(targetClass)) == null)
{
propertyMap = new HashMap(101);
seenGetMethods.put(targetClass, propertyMap);
}
if ((result = (Getter)propertyMap.get(propertyName)) == null)
{
try
{
MethodInfo method = OgnlRuntime.getGetMethod(context, targetClass, propertyName);
if (method != null)
{
if (method.IsPublic)
{
if (method.ReturnType.IsPrimitive)
{
propertyMap.Add(propertyName, result = generateGetter(context,
"java.lang.object\t\tresult;\n" +
targetClass.Name + "\t" + "t0 = (" + targetClass.Name + ")$2;\n" +
"\n" +
"try {\n" +
" result = new " + getPrimitiveWrapperClass(method.ReturnType).Name + "(t0." + method.Name + "());\n" +
"} catch (java.lang.Exception ex) {\n" +
" throw new java.lang.RuntimeException(ex);\n" +
"}\n" +
"return result;"
));
}
else
{
propertyMap.Add(propertyName, result = generateGetter(context,
"java.lang.object\t\tresult;\n" +
targetClass.Name + "\t" + "t0 = (" + targetClass.Name + ")$2;\n" +
"\n" +
"try {\n" +
" result = t0." + method.Name + "();\n" +
"} catch (java.lang.Exception ex) {\n" +
" throw new java.lang.RuntimeException(ex);\n" +
"}\n" +
"return result;"
));
}
}
else
{
propertyMap.Add(propertyName, result = DefaultGetter);
}
}
else
{
propertyMap.Add(propertyName, result = NotFoundGetter);
}
}
catch (Exception ex)
{
throw new OgnlException("getting getter", ex);
}
}
return(result);
}
protected override object getValueBody(OgnlContext context, object source) // throws OgnlException
{
object result = source;
for (int i = 0, ilast = children.Length - 1; i <= ilast; ++i)
{
bool handled = false;
if (i < ilast)
{
if (children[i] is ASTProperty)
{
ASTProperty propertyNode = (ASTProperty)children[i];
int indexType = propertyNode.getIndexedPropertyType(context, result);
if ((indexType != OgnlRuntime.INDEXED_PROPERTY_NONE) && (children[i + 1] is ASTProperty))
{
ASTProperty indexNode = (ASTProperty)children[i + 1];
if (indexNode.isIndexedAccess())
{
object index = indexNode.getProperty(context, result);
if (index is DynamicSubscript)
{
if (indexType == OgnlRuntime.INDEXED_PROPERTY_INT)
{
object array = propertyNode.getValue(context, result);
int len = ((Array)array).Length;
switch (((DynamicSubscript)index).getFlag())
{
case DynamicSubscript.ALL:
result = Array.CreateInstance(array.GetType().GetElementType(), len);
Array.Copy((Array)array, 0, (Array)result, 0, len);
handled = true;
i++;
break;
case DynamicSubscript.FIRST:
index = ((len > 0) ? 0 : -1);
break;
case DynamicSubscript.MID:
index = ((len > 0) ? (len / 2) : -1);
break;
case DynamicSubscript.LAST:
index = ((len > 0) ? (len - 1) : -1);
break;
}
}
else
{
if (indexType == OgnlRuntime.INDEXED_PROPERTY_OBJECT)
{
throw new OgnlException("DynamicSubscript '" + indexNode + "' not allowed for object indexed property '" + propertyNode + "'");
}
}
}
if (!handled)
{
result = OgnlRuntime.getIndexedProperty(context, result, propertyNode.getProperty(context, result).ToString(), index);
handled = true;
i++;
}
}
}
}
}
if (!handled)
{
result = children[i].getValue(context, result);
}
}
return(result);
}
protected override void setValueBody(OgnlContext context, object target, object value) // throws OgnlException
{
bool handled = false;
for (int i = 0, ilast = children.Length - 2; i <= ilast; ++i)
{
if (i == ilast)
{
if (children[i] is ASTProperty)
{
ASTProperty propertyNode = (ASTProperty)children[i];
int indexType = propertyNode.getIndexedPropertyType(context, target);
if ((indexType != OgnlRuntime.INDEXED_PROPERTY_NONE) && (children[i + 1] is ASTProperty))
{
ASTProperty indexNode = (ASTProperty)children[i + 1];
if (indexNode.isIndexedAccess())
{
object index = indexNode.getProperty(context, target);
if (index is DynamicSubscript)
{
if (indexType == OgnlRuntime.INDEXED_PROPERTY_INT)
{
object array = propertyNode.getValue(context, target);
int len = ((Array)array).Length;
switch (((DynamicSubscript)index).getFlag())
{
case DynamicSubscript.ALL:
Array.Copy((Array)target, 0, (Array)value, 0, len);
handled = true;
i++;
break;
case DynamicSubscript.FIRST:
index = ((len > 0) ? 0 : -1);
break;
case DynamicSubscript.MID:
index = ((len > 0) ? (len / 2) : -1);
break;
case DynamicSubscript.LAST:
index = ((len > 0) ? (len - 1) : -1);
break;
}
}
else
{
if (indexType == OgnlRuntime.INDEXED_PROPERTY_OBJECT)
{
throw new OgnlException("DynamicSubscript '" + indexNode + "' not allowed for object indexed property '" + propertyNode + "'");
}
}
}
if (!handled)
{
OgnlRuntime.setIndexedProperty(context, target, propertyNode.getProperty(context, target).ToString(), index, value);
handled = true;
i++;
}
}
}
}
}
if (!handled)
{
target = children[i].getValue(context, target);
}
}
if (!handled)
{
children[children.Length - 1].setValue(context, target, value);
}
}
public override void setUp()
{
base.setUp();
OgnlRuntime.setNullHandler(typeof(CorrectedObject), new CorrectedObjectNullHandler("corrected"));
}
/*===================================================================
* Public static methods
* ===================================================================*/
public static void main(string[] args)
{
for (int i = 0; i < args.Length; i++)
{
if (args[i].Equals("-time"))
{
TIME_MODE = true;
MAX_TIME = Util.ParseLong(args[++i]);
}
else if (args[i].Equals("-iterations"))
{
ITERATIONS_MODE = true;
MAX_ITERATIONS = (int)Util.ParseLong(args[++i]);
}
}
if (!TIME_MODE && !ITERATIONS_MODE)
{
TIME_MODE = true;
MAX_TIME = 1000;
}
OgnlRuntime.setPropertyAccessor(typeof(object), new CompilingPropertyAccessor());
try
{
Performance[] tests = new Performance[]
{
new Performance("Constant",
"100 + 20 * 5",
"testConstantExpression"),
new Performance("Single Property",
"bean2",
"testSinglePropertyExpression"),
new Performance("Property Navigation",
"bean2.bean3.value",
"testPropertyNavigationExpression"),
new Performance("Property Navigation and Comparison",
"bean2.bean3.value <= 24",
"testPropertyNavigationAndComparisonExpression"),
new Performance("Property Navigation with Indexed Access",
"bean2.bean3.indexedValue[25]",
"testIndexedPropertyNavigationExpression"),
new Performance("Property Navigation with Map Access",
"bean2.bean3.map['foo']",
"testPropertyNavigationWithMapExpression"),
};
for (int i = 0; i < tests.Length; i++)
{
Performance perf = tests[i];
try
{
Results javaResults = perf.testJava(),
interpretedResults = perf.testExpression(false),
compiledResults = perf.testExpression(true);
Console.WriteLine(perf.getName() + ": " + perf.getExpression().ToString());
Console.WriteLine(" java: " + javaResults.iterations + " iterations in " + javaResults.time + " ms");
Console.WriteLine(" compiled: " + compiledResults.iterations + " iterations in " + compiledResults.time + " ms (" + (compiledResults.getFactor(javaResults).ToString("0.0")) + " times slower than java)");
Console.WriteLine("interpreted: " + interpretedResults.iterations + " iterations in " + interpretedResults.time + " ms (" + /*FACTOR_FORMAT.format*/ (interpretedResults.getFactor(javaResults).ToString("0.0")) + " times slower than java)");
Console.WriteLine();
}
catch (OgnlException ex)
{
Console.WriteLine(ex);
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
protected override object getValueBody(OgnlContext context, object source) // throws OgnlException
{
object result,
root = context.getRoot();
int count = jjtGetNumChildren();
object[] args = OgnlRuntime.getObjectArrayPool().create(count);
try {
for (int i = 0; i < count; ++i)
{
args[i] = children[i].getValue(context, root);
}
if (isArray)
{
if (args.Length == 1)
{
try {
Type componentClass = OgnlRuntime.classForName(context, className);
IList sourceList = null;
int size;
if (args[0] is IList)
{
sourceList = (IList)args[0];
size = sourceList.Count;
}
else
{
size = (int)OgnlOps.longValue(args[0]);
}
result = Array.CreateInstance(componentClass, size);
if (sourceList != null)
{
TypeConverter converter = context.getTypeConverter();
for (int i = 0, icount = sourceList.Count; i < icount; i++)
{
object o = sourceList [i];
if ((o == null) || componentClass.IsInstanceOfType(o))
{
((Array)result).SetValue(o, i);
}
else
{
((Array)result).SetValue(converter.convertValue(context, null, null, null, o, componentClass), i);
}
}
}
} catch (TypeLoadException ex) {
throw new OgnlException("array component class '" + className + "' not found", ex);
}
}
else
{
throw new OgnlException("only expect array size or fixed initializer list");
}
}
else
{
result = OgnlRuntime.callConstructor(context, className, args);
}
return(result);
} finally {
OgnlRuntime.getObjectArrayPool().recycle(args);
}
}
