jj_gen) {
jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
switch (i) {
case 0: jj_3_1(); break;
case 1: jj_3_2(); break;
case 2: jj_3_3(); break;
case 3: jj_3_4(); break;
case 4: jj_3_5(); break;
case 5: jj_3_6(); break;
case 6: jj_3_7(); break;
case 7: jj_3_8(); break;
case 8: jj_3_9(); break;
case 9: jj_3_10(); break;
case 10: jj_3_11(); break;
case 11: jj_3_12(); break;
case 12: jj_3_13(); break;
case 13: jj_3_14(); break;
case 14: jj_3_15(); break;
case 15: jj_3_16(); break;
}
}
p = p.next;
} while (p != null);
} catch(LookaheadSuccess ls) { }
}
jj_rescan = false;
}
private void jj_save(int index, int xla) {
JJCalls p = jj_2_rtns[index];
while (p.gen > jj_gen) {
if (p.next == null) { p = p.next = new JJCalls(); break; }
p = p.next;
}
p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
}
static final class JJCalls {
int gen;
Token first;
int arg;
JJCalls next;
}
}
ognl-2.7.3.orig/src/java/ognl/Evaluation.java 0000644 0001750 0001750 00000024453 10561411075 020746 0 ustar drazzib drazzib //--------------------------------------------------------------------------
// Copyright (c) 1998-2004, Drew Davidson and Luke Blanshard
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
// Neither the name of the Drew Davidson nor the names of its contributors
// may be used to endorse or promote products derived from this software
// without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
// COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
// OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
// AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
// DAMAGE.
//--------------------------------------------------------------------------
package ognl;
/**
An Evaluation is and object that holds a node being evaluated
and the source from which that node will take extract its
value. It refers to child evaluations that occur as
a result of the nodes' evaluation.
*/
public class Evaluation extends Object
{
private SimpleNode node;
private Object source;
private boolean setOperation;
private Object result;
private Throwable exception;
private Evaluation parent;
private Evaluation next;
private Evaluation previous;
private Evaluation firstChild;
private Evaluation lastChild;
/**
Constructs a new "get" Evaluation from the node and source given.
*/
public Evaluation(SimpleNode node, Object source)
{
super();
this.node = node;
this.source = source;
}
/**
Constructs a new Evaluation from the node and source given.
If setOperation is true this Evaluation represents
a "set" as opposed to a "get".
*/
public Evaluation(SimpleNode node, Object source, boolean setOperation)
{
this(node, source);
this.setOperation = setOperation;
}
/**
Returns the SimpleNode for this Evaluation
*/
public SimpleNode getNode()
{
return node;
}
/**
Sets the node of the evaluation. Normally applications do not need to
set this. Notable exceptions to this rule are custom evaluators that
choose between navigable objects (as in a multi-root evaluator where
the navigable node is chosen at runtime).
*/
public void setNode(SimpleNode value)
{
node = value;
}
/**
Returns the source object on which this Evaluation operated.
*/
public Object getSource()
{
return source;
}
/**
Sets the source of the evaluation. Normally applications do not need to
set this. Notable exceptions to this rule are custom evaluators that
choose between navigable objects (as in a multi-root evaluator where
the navigable node is chosen at runtime).
*/
public void setSource(Object value)
{
source = value;
}
/**
Returns true if this Evaluation represents a set operation.
*/
public boolean isSetOperation()
{
return setOperation;
}
/**
Marks the Evaluation as a set operation if the value is true, else
marks it as a get operation.
*/
public void setSetOperation(boolean value)
{
setOperation = value;
}
/**
Returns the result of the Evaluation, or null if it was a set operation.
*/
public Object getResult()
{
return result;
}
/**
Sets the result of the Evaluation. This method is normally only used
interally and should not be set without knowledge of what you are doing.
*/
public void setResult(Object value)
{
result = value;
}
/**
Returns the exception that occurred as a result of evaluating the
Evaluation, or null if no exception occurred.
*/
public Throwable getException()
{
return exception;
}
/**
Sets the exception that occurred as a result of evaluating the
Evaluation. This method is normally only used interally and
should not be set without knowledge of what you are doing.
*/
public void setException(Throwable value)
{
exception = value;
}
/**
Returns the parent evaluation of this evaluation. If this returns
null then it is is the root evaluation of a tree.
*/
public Evaluation getParent()
{
return parent;
}
/**
Returns the next sibling of this evaluation. Returns null if
this is the last in a chain of evaluations.
*/
public Evaluation getNext()
{
return next;
}
/**
Returns the previous sibling of this evaluation. Returns null if
this is the first in a chain of evaluations.
*/
public Evaluation getPrevious()
{
return previous;
}
/**
Returns the first child of this evaluation. Returns null if
there are no children.
*/
public Evaluation getFirstChild()
{
return firstChild;
}
/**
Returns the last child of this evaluation. Returns null if
there are no children.
*/
public Evaluation getLastChild()
{
return lastChild;
}
/**
Gets the first descendent. In any Evaluation tree this will the
Evaluation that was first executed.
*/
public Evaluation getFirstDescendant()
{
if (firstChild != null) {
return firstChild.getFirstDescendant();
}
return this;
}
/**
Gets the last descendent. In any Evaluation tree this will the
Evaluation that was most recently executing.
*/
public Evaluation getLastDescendant()
{
if (lastChild != null) {
return lastChild.getLastDescendant();
}
return this;
}
/**
Adds a child to the list of children of this evaluation. The
parent of the child is set to the receiver and the children
references are modified in the receiver to reflect the new child.
The lastChild of the receiver is set to the child, and the
firstChild is set also if child is the first (or only) child.
*/
public void addChild(Evaluation child)
{
if (firstChild == null) {
firstChild = lastChild = child;
} else {
if (firstChild == lastChild) {
firstChild.next = child;
lastChild = child;
lastChild.previous = firstChild;
} else {
child.previous = lastChild;
lastChild.next = child;
lastChild = child;
}
}
child.parent = this;
}
/**
Reinitializes this Evaluation to the parameters specified.
*/
public void init(SimpleNode node, Object source, boolean setOperation)
{
this.node = node;
this.source = source;
this.setOperation = setOperation;
result = null;
exception = null;
parent = null;
next = null;
previous = null;
firstChild = null;
lastChild = null;
}
/**
Resets this Evaluation to the initial state.
*/
public void reset()
{
init(null, null, false);
}
/**
Produces a String value for the Evaluation. If compact is
true then a more compact form of the description only including
the node type and unique identifier is shown, else a full
description including source and result are shown. If showChildren
is true the child evaluations are printed using the depth string
given as a prefix.
*/
public String toString(boolean compact, boolean showChildren, String depth)
{
String stringResult;
if (compact) {
stringResult = depth + "<" + node.getClass().getName() + " " + System.identityHashCode(this) + ">";
} else {
String ss = (source != null) ? source.getClass().getName() : "null",
rs = (result != null) ? result.getClass().getName() : "null";
stringResult = depth + "<" + node.getClass().getName() + ": [" + (setOperation ? "set" : "get") + "] source = " + ss + ", result = " + result + " [" + rs + "]>";
}
if (showChildren) {
Evaluation child = firstChild;
stringResult += "\n";
while (child != null) {
stringResult += child.toString(compact, depth + " ");
child = child.next;
}
}
return stringResult;
}
/**
Produces a String value for the Evaluation. If compact is
true then a more compact form of the description only including
the node type and unique identifier is shown, else a full
description including source and result are shown. Child
evaluations are printed using the depth string given as a prefix.
*/
public String toString(boolean compact, String depth)
{
return toString(compact, true, depth);
}
/**
Returns a String description of the Evaluation.
*/
public String toString()
{
return toString(false, "");
}
}
ognl-2.7.3.orig/src/java/ognl/PropertyAccessor.java 0000644 0001750 0001750 00000012421 10745155540 022144 0 ustar drazzib drazzib // --------------------------------------------------------------------------
// Copyright (c) 1998-2004, Drew Davidson and Luke Blanshard
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
// Neither the name of the Drew Davidson nor the names of its contributors
// may be used to endorse or promote products derived from this software
// without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
// COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
// OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
// AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
// DAMAGE.
// --------------------------------------------------------------------------
package ognl;
import java.util.Map;
/**
* This interface defines methods for setting and getting a property from a target object. A
* "property" in this case is a named data value that takes the generic form of an Object---the same
* definition as is used by beans. But the operational semantics of the term will vary by
* implementation of this interface: a bean-style implementation will get and set properties as
* beans do, by reflection on the target object's class, but other implementations are possible,
* such as one that uses the property name as a key into a map.
*
* An implementation of this interface will often require that its target objects all be of some
* particular type. For example, the MapPropertyAccessor class requires that its targets all
* implement the java.util.Map interface.
*
* Note that the "name" of a property is represented by a generic Object. Some implementations may
* require properties' names to be Strings, while others may allow them to be other types---for
* example, ArrayPropertyAccessor treats Number names as indexes into the target object, which must
* be an array.
*
* @author Luke Blanshard (blanshlu@netscape.net)
* @author Drew Davidson (drew@ognl.org)
*/
public interface PropertyAccessor
{
/**
* Extracts and returns the property of the given name from the given target object.
*
* @param context
* The current execution context.
* @param target
* the object to get the property from
* @param name
* the name of the property to get.
*
* @return the current value of the given property in the given object
* @exception OgnlException
* if there is an error locating the property in the given object
*/
Object getProperty(Map context, Object target, Object name)
throws OgnlException;
/**
* Sets the value of the property of the given name in the given target object.
*
* @param context
* The current execution context.
* @param target
* the object to set the property in
* @param name
* the name of the property to set
* @param value
* the new value for the property.
*
* @exception OgnlException
* if there is an error setting the property in the given object
*/
void setProperty(Map context, Object target, Object name, Object value)
throws OgnlException;
/**
* Returns a java string representing the textual method that should be called to access a
* particular element. (ie "get")
*
* @param context
* The current execution context.
* @param target
* The current object target on the expression tree being evaluated.
* @param index
* The index object that will be placed inside the string to access the value.
*
* @return The source accessor method to call.
*/
String getSourceAccessor(OgnlContext context, Object target, Object index);
/**
* Returns a java string representing the textual method that should be called to set a
* particular element. (ie "set")
*
* @param context
* The current execution context.
* @param target
* The current object target on the expression tree being evaluated.
* @param index
* The index object that will be placed inside the string to set the value.
* @return The source setter method to call.
*/
String getSourceSetter(OgnlContext context, Object target, Object index);
}
ognl-2.7.3.orig/src/java/ognl/ArrayPropertyAccessor.java 0000644 0001750 0001750 00000021055 10754136360 023145 0 ustar drazzib drazzib // --------------------------------------------------------------------------
// Copyright (c) 1998-2004, Drew Davidson and Luke Blanshard
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
// Neither the name of the Drew Davidson nor the names of its contributors
// may be used to endorse or promote products derived from this software
// without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
// COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
// OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
// AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
// DAMAGE.
// --------------------------------------------------------------------------
package ognl;
import java.lang.reflect.Array;
import java.util.Map;
/**
* Implementation of PropertyAccessor that uses numbers and dynamic subscripts as properties to
* index into Java arrays.
*
* @author Luke Blanshard (blanshlu@netscape.net)
* @author Drew Davidson (drew@ognl.org)
*/
public class ArrayPropertyAccessor extends ObjectPropertyAccessor implements PropertyAccessor
{
public Object getProperty(Map context, Object target, Object name)
throws OgnlException
{
Object result = null;
if (name instanceof String)
{
if (name.equals("length"))
{
result = new Integer(Array.getLength(target));
} else
{
result = super.getProperty(context, target, name);
}
} else
{
Object index = name;
if (index instanceof DynamicSubscript)
{
int len = Array.getLength(target);
switch(((DynamicSubscript) index).getFlag())
{
case DynamicSubscript.ALL:
result = Array.newInstance(target.getClass().getComponentType(), len);
System.arraycopy(target, 0, result, 0, len);
break;
case DynamicSubscript.FIRST:
index = new Integer((len > 0) ? 0 : -1);
break;
case DynamicSubscript.MID:
index = new Integer((len > 0) ? (len / 2) : -1);
break;
case DynamicSubscript.LAST:
index = new Integer((len > 0) ? (len - 1) : -1);
break;
}
}
if (result == null)
{
if (index instanceof Number)
{
int i = ((Number) index).intValue();
result = (i >= 0) ? Array.get(target, i) : null;
} else
{
throw new NoSuchPropertyException(target, index);
}
}
}
return result;
}
public void setProperty(Map context, Object target, Object name, Object value)
throws OgnlException
{
Object index = name;
boolean isNumber = (index instanceof Number);
if (isNumber || (index instanceof DynamicSubscript))
{
TypeConverter converter = ((OgnlContext) context).getTypeConverter();
Object convertedValue;
convertedValue =
converter.convertValue(context, target, null, name.toString(),
value, target.getClass().getComponentType());
if (isNumber)
{
int i = ((Number) index).intValue();
if (i >= 0)
{
Array.set(target, i, convertedValue);
}
} else
{
int len = Array.getLength(target);
switch(((DynamicSubscript) index).getFlag())
{
case DynamicSubscript.ALL:
System.arraycopy(target, 0, convertedValue, 0, len);
return;
case DynamicSubscript.FIRST:
index = new Integer((len > 0) ? 0 : -1);
break;
case DynamicSubscript.MID:
index = new Integer((len > 0) ? (len / 2) : -1);
break;
case DynamicSubscript.LAST:
index = new Integer((len > 0) ? (len - 1) : -1);
break;
}
}
} else {
if (name instanceof String)
{
super.setProperty(context, target, name, value);
} else
{
throw new NoSuchPropertyException(target, index);
}
}
}
public String getSourceAccessor(OgnlContext context, Object target, Object index)
{
String indexStr = index.toString();
// need to convert to primitive for list index access
// System.out.println("index class " + index.getClass() + " current type " + context.getCurrentType() + " current object class " + context.getCurrentObject().getClass());
if (context.getCurrentType() != null && !context.getCurrentType().isPrimitive()
&& Number.class.isAssignableFrom(context.getCurrentType()))
{
indexStr += "." + OgnlRuntime.getNumericValueGetter(context.getCurrentType());
} else if (context.getCurrentObject() != null && Number.class.isAssignableFrom(context.getCurrentObject().getClass())
&& !context.getCurrentType().isPrimitive())
{
// means it needs to be cast first as well
String toString = String.class.isInstance(index) && context.getCurrentType() != Object.class ? "" : ".toString()";
indexStr = "ognl.OgnlOps#getIntValue(" + indexStr + toString + ")";
}
context.setCurrentAccessor(target.getClass());
context.setCurrentType(target.getClass().getComponentType());
return "[" + indexStr + "]";
}
public String getSourceSetter(OgnlContext context, Object target, Object index)
{
String indexStr = index.toString();
// need to convert to primitive for list index access
if (context.getCurrentType() != null && !context.getCurrentType().isPrimitive()
&& Number.class.isAssignableFrom(context.getCurrentType()))
{
indexStr += "." + OgnlRuntime.getNumericValueGetter(context.getCurrentType());
} else if (context.getCurrentObject() != null && Number.class.isAssignableFrom(context.getCurrentObject().getClass())
&& !context.getCurrentType().isPrimitive())
{
// means it needs to be cast first as well
String toString = String.class.isInstance(index) && context.getCurrentType() != Object.class ? "" : ".toString()";
indexStr = "ognl.OgnlOps#getIntValue(" + indexStr + toString + ")";
}
Class type = target.getClass().isArray() ? target.getClass().getComponentType() : target.getClass();
context.setCurrentAccessor(target.getClass());
context.setCurrentType(target.getClass().getComponentType());
if (type.isPrimitive())
{
Class wrapClass = OgnlRuntime.getPrimitiveWrapperClass(type);
return "[" + indexStr + "]=((" + wrapClass.getName() + ")ognl.OgnlOps.convertValue($3," + wrapClass.getName()
+ ".class, true))." + OgnlRuntime.getNumericValueGetter(wrapClass);
} else
{
return "[" + indexStr + "]=ognl.OgnlOps.convertValue($3," + type.getName() + ".class)";
}
}
}
ognl-2.7.3.orig/src/java/ognl/OgnlParserTokenManager.java 0000644 0001750 0001750 00000140012 10746450726 023210 0 ustar drazzib drazzib /* Generated By:JJTree&JavaCC: Do not edit this line. OgnlParserTokenManager.java */
package ognl;
import java.math.BigDecimal;
import java.math.BigInteger;
/** Token Manager. */
public class OgnlParserTokenManager implements OgnlParserConstants
{
/** Holds the last value computed by a constant token. */
Object literalValue;
/** Holds the last character escaped or in a character literal. */
private char charValue;
/** Holds char literal start token. */
private char charLiteralStartQuote;
/** Holds the last string literal parsed. */
private StringBuffer stringBuffer;
/** Converts an escape sequence into a character value. */
private char escapeChar()
{
int ofs = image.length() - 1;
switch ( image.charAt(ofs) ) {
case 'n': return '\n';
case 'r': return '\r';
case 't': return '\t';
case 'b': return '\b';
case 'f': return '\f';
case '\\': return '\\';
case '\'': return '\'';
case '\"': return '\"';
}
// Otherwise, it's an octal number. Find the backslash and convert.
while ( image.charAt(--ofs) != '\\' )
{}
int value = 0;
while ( ++ofs < image.length() )
value = (value << 3) | (image.charAt(ofs) - '0');
return (char) value;
}
private Object makeInt()
{
Object result;
String s = image.toString();
int base = 10;
if ( s.charAt(0) == '0' )
base = (s.length() > 1 && (s.charAt(1) == 'x' || s.charAt(1) == 'X'))? 16 : 8;
if ( base == 16 )
s = s.substring(2); // Trim the 0x off the front
switch ( s.charAt(s.length()-1) ) {
case 'l': case 'L':
result = Long.valueOf( s.substring(0,s.length()-1), base );
break;
case 'h': case 'H':
result = new BigInteger( s.substring(0,s.length()-1), base );
break;
default:
result = Integer.valueOf( s, base );
break;
}
return result;
}
private Object makeFloat()
{
String s = image.toString();
switch ( s.charAt(s.length()-1) ) {
case 'f': case 'F':
return Float.valueOf( s );
case 'b': case 'B':
return new BigDecimal( s.substring(0,s.length()-1) );
case 'd': case 'D':
default:
return Double.valueOf( s );
}
}
/** Debug output. */
public java.io.PrintStream debugStream = System.out;
/** Set debug output. */
public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1)
{
switch (pos)
{
case 0:
if ((active0 & 0x201c4055d555540L) != 0L)
{
jjmatchedKind = 64;
return 1;
}
if ((active0 & 0x400000000000000L) != 0L)
return 1;
if ((active0 & 0x10000000000000L) != 0L)
return 3;
if ((active0 & 0x80000000000L) != 0L)
return 9;
return -1;
case 1:
if ((active0 & 0x201c00550045500L) != 0L)
{
if (jjmatchedPos != 1)
{
jjmatchedKind = 64;
jjmatchedPos = 1;
}
return 1;
}
if ((active0 & 0x4000d510040L) != 0L)
return 1;
return -1;
case 2:
if ((active0 & 0x1c40400004000L) != 0L)
{
jjmatchedKind = 64;
jjmatchedPos = 2;
return 1;
}
if ((active0 & 0x200000155041500L) != 0L)
return 1;
return -1;
case 3:
if ((active0 & 0x1400400004000L) != 0L)
return 1;
if ((active0 & 0x840000000000L) != 0L)
{
jjmatchedKind = 64;
jjmatchedPos = 3;
return 1;
}
return -1;
case 4:
if ((active0 & 0x800000000000L) != 0L)
return 1;
if ((active0 & 0x40000000000L) != 0L)
{
jjmatchedKind = 64;
jjmatchedPos = 4;
return 1;
}
return -1;
case 5:
if ((active0 & 0x40000000000L) != 0L)
{
jjmatchedKind = 64;
jjmatchedPos = 5;
return 1;
}
return -1;
case 6:
if ((active0 & 0x40000000000L) != 0L)
{
jjmatchedKind = 64;
jjmatchedPos = 6;
return 1;
}
return -1;
case 7:
if ((active0 & 0x40000000000L) != 0L)
{
jjmatchedKind = 64;
jjmatchedPos = 7;
return 1;
}
return -1;
case 8:
if ((active0 & 0x40000000000L) != 0L)
{
jjmatchedKind = 64;
jjmatchedPos = 8;
return 1;
}
return -1;
default :
return -1;
}
}
private final int jjStartNfa_0(int pos, long active0, long active1)
{
return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1), pos + 1);
}
private int jjStopAtPos(int pos, int kind)
{
jjmatchedKind = kind;
jjmatchedPos = pos;
return pos + 1;
}
private int jjMoveStringLiteralDfa0_0()
{
switch(curChar)
{
case 33:
jjmatchedKind = 41;
return jjMoveStringLiteralDfa1_0(0x20000L);
case 34:
return jjStopAtPos(0, 70);
case 35:
jjmatchedKind = 51;
return jjMoveStringLiteralDfa1_0(0x6000000000000L);
case 36:
return jjStartNfaWithStates_0(0, 58, 1);
case 37:
return jjStopAtPos(0, 39);
case 38:
jjmatchedKind = 13;
return jjMoveStringLiteralDfa1_0(0x80L);
case 39:
return jjStopAtPos(0, 69);
case 40:
return jjStopAtPos(0, 44);
case 41:
return jjStopAtPos(0, 45);
case 42:
return jjStopAtPos(0, 37);
case 43:
return jjStopAtPos(0, 35);
case 44:
return jjStopAtPos(0, 1);
case 45:
return jjStopAtPos(0, 36);
case 46:
return jjStartNfaWithStates_0(0, 43, 9);
case 47:
return jjStopAtPos(0, 38);
case 58:
return jjStopAtPos(0, 4);
case 60:
jjmatchedKind = 19;
return jjMoveStringLiteralDfa1_0(0x20800000L);
case 61:
jjmatchedKind = 2;
return jjMoveStringLiteralDfa1_0(0x8000L);
case 62:
jjmatchedKind = 21;
return jjMoveStringLiteralDfa1_0(0x282000000L);
case 63:
return jjStopAtPos(0, 3);
case 64:
return jjStopAtPos(0, 56);
case 91:
return jjStartNfaWithStates_0(0, 52, 3);
case 93:
return jjStopAtPos(0, 53);
case 94:
return jjStopAtPos(0, 11);
case 96:
return jjStopAtPos(0, 68);
case 97:
return jjMoveStringLiteralDfa1_0(0x100L);
case 98:
return jjMoveStringLiteralDfa1_0(0x4400L);
case 101:
return jjMoveStringLiteralDfa1_0(0x10000L);
case 102:
return jjMoveStringLiteralDfa1_0(0x800000000000L);
case 103:
return jjMoveStringLiteralDfa1_0(0x4400000L);
case 105:
return jjMoveStringLiteralDfa1_0(0x40008000000L);
case 108:
return jjMoveStringLiteralDfa1_0(0x1100000L);
case 110:
return jjMoveStringLiteralDfa1_0(0x201000010040000L);
case 111:
return jjMoveStringLiteralDfa1_0(0x40L);
case 115:
return jjMoveStringLiteralDfa1_0(0x140000000L);
case 116:
return jjMoveStringLiteralDfa1_0(0x400000000000L);
case 117:
return jjMoveStringLiteralDfa1_0(0x400000000L);
case 120:
return jjMoveStringLiteralDfa1_0(0x1000L);
case 123:
return jjStopAtPos(0, 54);
case 124:
jjmatchedKind = 9;
return jjMoveStringLiteralDfa1_0(0x20L);
case 125:
return jjStopAtPos(0, 55);
case 126:
return jjStopAtPos(0, 40);
default :
return jjMoveNfa_0(0, 0);
}
}
private int jjMoveStringLiteralDfa1_0(long active0)
{
try { curChar = input_stream.readChar(); }
catch(java.io.IOException e) {
jjStopStringLiteralDfa_0(0, active0, 0L);
return 1;
}
switch(curChar)
{
case 38:
if ((active0 & 0x80L) != 0L)
return jjStopAtPos(1, 7);
break;
case 60:
if ((active0 & 0x20000000L) != 0L)
return jjStopAtPos(1, 29);
break;
case 61:
if ((active0 & 0x8000L) != 0L)
return jjStopAtPos(1, 15);
else if ((active0 & 0x20000L) != 0L)
return jjStopAtPos(1, 17);
else if ((active0 & 0x800000L) != 0L)
return jjStopAtPos(1, 23);
else if ((active0 & 0x2000000L) != 0L)
return jjStopAtPos(1, 25);
break;
case 62:
if ((active0 & 0x80000000L) != 0L)
{
jjmatchedKind = 31;
jjmatchedPos = 1;
}
return jjMoveStringLiteralDfa2_0(active0, 0x200000000L);
case 97:
return jjMoveStringLiteralDfa2_0(active0, 0x800000004000L);
case 101:
return jjMoveStringLiteralDfa2_0(active0, 0x200000000040000L);
case 104:
return jjMoveStringLiteralDfa2_0(active0, 0x140000000L);
case 110:
if ((active0 & 0x8000000L) != 0L)
{
jjmatchedKind = 27;
jjmatchedPos = 1;
}
return jjMoveStringLiteralDfa2_0(active0, 0x40000000100L);
case 111:
return jjMoveStringLiteralDfa2_0(active0, 0x10001400L);
case 113:
if ((active0 & 0x10000L) != 0L)
return jjStartNfaWithStates_0(1, 16, 1);
break;
case 114:
if ((active0 & 0x40L) != 0L)
return jjStartNfaWithStates_0(1, 6, 1);
return jjMoveStringLiteralDfa2_0(active0, 0x4400000000000L);
case 115:
return jjMoveStringLiteralDfa2_0(active0, 0x400000000L);
case 116:
if ((active0 & 0x100000L) != 0L)
{
jjmatchedKind = 20;
jjmatchedPos = 1;
}
else if ((active0 & 0x400000L) != 0L)
{
jjmatchedKind = 22;
jjmatchedPos = 1;
}
return jjMoveStringLiteralDfa2_0(active0, 0x2000005000000L);
case 117:
return jjMoveStringLiteralDfa2_0(active0, 0x1000000000000L);
case 124:
if ((active0 & 0x20L) != 0L)
return jjStopAtPos(1, 5);
break;
default :
break;
}
return jjStartNfa_0(0, active0, 0L);
}
private int jjMoveStringLiteralDfa2_0(long old0, long active0)
{
if (((active0 &= old0)) == 0L)
return jjStartNfa_0(0, old0, 0L);
try { curChar = input_stream.readChar(); }
catch(java.io.IOException e) {
jjStopStringLiteralDfa_0(1, active0, 0L);
return 2;
}
switch(curChar)
{
case 62:
if ((active0 & 0x200000000L) != 0L)
return jjStopAtPos(2, 33);
break;
case 100:
if ((active0 & 0x100L) != 0L)
return jjStartNfaWithStates_0(2, 8, 1);
break;
case 101:
if ((active0 & 0x1000000L) != 0L)
return jjStartNfaWithStates_0(2, 24, 1);
else if ((active0 & 0x4000000L) != 0L)
return jjStartNfaWithStates_0(2, 26, 1);
break;
case 104:
return jjMoveStringLiteralDfa3_0(active0, 0x2000400000000L);
case 108:
if ((active0 & 0x40000000L) != 0L)
return jjStartNfaWithStates_0(2, 30, 1);
return jjMoveStringLiteralDfa3_0(active0, 0x1800000000000L);
case 110:
return jjMoveStringLiteralDfa3_0(active0, 0x4000L);
case 111:
return jjMoveStringLiteralDfa3_0(active0, 0x4000000000000L);
case 113:
if ((active0 & 0x40000L) != 0L)
return jjStartNfaWithStates_0(2, 18, 1);
break;
case 114:
if ((active0 & 0x400L) != 0L)
return jjStartNfaWithStates_0(2, 10, 1);
else if ((active0 & 0x1000L) != 0L)
return jjStartNfaWithStates_0(2, 12, 1);
else if ((active0 & 0x100000000L) != 0L)
return jjStartNfaWithStates_0(2, 32, 1);
break;
case 115:
return jjMoveStringLiteralDfa3_0(active0, 0x40000000000L);
case 116:
if ((active0 & 0x10000000L) != 0L)
return jjStartNfaWithStates_0(2, 28, 1);
break;
case 117:
return jjMoveStringLiteralDfa3_0(active0, 0x400000000000L);
case 119:
if ((active0 & 0x200000000000000L) != 0L)
return jjStartNfaWithStates_0(2, 57, 1);
break;
default :
break;
}
return jjStartNfa_0(1, active0, 0L);
}
private int jjMoveStringLiteralDfa3_0(long old0, long active0)
{
if (((active0 &= old0)) == 0L)
return jjStartNfa_0(1, old0, 0L);
try { curChar = input_stream.readChar(); }
catch(java.io.IOException e) {
jjStopStringLiteralDfa_0(2, active0, 0L);
return 3;
}
switch(curChar)
{
case 100:
if ((active0 & 0x4000L) != 0L)
return jjStartNfaWithStates_0(3, 14, 1);
break;
case 101:
if ((active0 & 0x400000000000L) != 0L)
return jjStartNfaWithStates_0(3, 46, 1);
break;
case 105:
return jjMoveStringLiteralDfa4_0(active0, 0x2000000000000L);
case 108:
if ((active0 & 0x1000000000000L) != 0L)
return jjStartNfaWithStates_0(3, 48, 1);
break;
case 111:
return jjMoveStringLiteralDfa4_0(active0, 0x4000000000000L);
case 114:
if ((active0 & 0x400000000L) != 0L)
return jjStartNfaWithStates_0(3, 34, 1);
break;
case 115:
return jjMoveStringLiteralDfa4_0(active0, 0x800000000000L);
case 116:
return jjMoveStringLiteralDfa4_0(active0, 0x40000000000L);
default :
break;
}
return jjStartNfa_0(2, active0, 0L);
}
private int jjMoveStringLiteralDfa4_0(long old0, long active0)
{
if (((active0 &= old0)) == 0L)
return jjStartNfa_0(2, old0, 0L);
try { curChar = input_stream.readChar(); }
catch(java.io.IOException e) {
jjStopStringLiteralDfa_0(3, active0, 0L);
return 4;
}
switch(curChar)
{
case 97:
return jjMoveStringLiteralDfa5_0(active0, 0x40000000000L);
case 101:
if ((active0 & 0x800000000000L) != 0L)
return jjStartNfaWithStates_0(4, 47, 1);
break;
case 115:
if ((active0 & 0x2000000000000L) != 0L)
return jjStopAtPos(4, 49);
break;
case 116:
if ((active0 & 0x4000000000000L) != 0L)
return jjStopAtPos(4, 50);
break;
default :
break;
}
return jjStartNfa_0(3, active0, 0L);
}
private int jjMoveStringLiteralDfa5_0(long old0, long active0)
{
if (((active0 &= old0)) == 0L)
return jjStartNfa_0(3, old0, 0L);
try { curChar = input_stream.readChar(); }
catch(java.io.IOException e) {
jjStopStringLiteralDfa_0(4, active0, 0L);
return 5;
}
switch(curChar)
{
case 110:
return jjMoveStringLiteralDfa6_0(active0, 0x40000000000L);
default :
break;
}
return jjStartNfa_0(4, active0, 0L);
}
private int jjMoveStringLiteralDfa6_0(long old0, long active0)
{
if (((active0 &= old0)) == 0L)
return jjStartNfa_0(4, old0, 0L);
try { curChar = input_stream.readChar(); }
catch(java.io.IOException e) {
jjStopStringLiteralDfa_0(5, active0, 0L);
return 6;
}
switch(curChar)
{
case 99:
return jjMoveStringLiteralDfa7_0(active0, 0x40000000000L);
default :
break;
}
return jjStartNfa_0(5, active0, 0L);
}
private int jjMoveStringLiteralDfa7_0(long old0, long active0)
{
if (((active0 &= old0)) == 0L)
return jjStartNfa_0(5, old0, 0L);
try { curChar = input_stream.readChar(); }
catch(java.io.IOException e) {
jjStopStringLiteralDfa_0(6, active0, 0L);
return 7;
}
switch(curChar)
{
case 101:
return jjMoveStringLiteralDfa8_0(active0, 0x40000000000L);
default :
break;
}
return jjStartNfa_0(6, active0, 0L);
}
private int jjMoveStringLiteralDfa8_0(long old0, long active0)
{
if (((active0 &= old0)) == 0L)
return jjStartNfa_0(6, old0, 0L);
try { curChar = input_stream.readChar(); }
catch(java.io.IOException e) {
jjStopStringLiteralDfa_0(7, active0, 0L);
return 8;
}
switch(curChar)
{
case 111:
return jjMoveStringLiteralDfa9_0(active0, 0x40000000000L);
default :
break;
}
return jjStartNfa_0(7, active0, 0L);
}
private int jjMoveStringLiteralDfa9_0(long old0, long active0)
{
if (((active0 &= old0)) == 0L)
return jjStartNfa_0(7, old0, 0L);
try { curChar = input_stream.readChar(); }
catch(java.io.IOException e) {
jjStopStringLiteralDfa_0(8, active0, 0L);
return 9;
}
switch(curChar)
{
case 102:
if ((active0 & 0x40000000000L) != 0L)
return jjStartNfaWithStates_0(9, 42, 1);
break;
default :
break;
}
return jjStartNfa_0(8, active0, 0L);
}
private int jjStartNfaWithStates_0(int pos, int kind, int state)
{
jjmatchedKind = kind;
jjmatchedPos = pos;
try { curChar = input_stream.readChar(); }
catch(java.io.IOException e) { return pos + 1; }
return jjMoveNfa_0(state, pos + 1);
}
static final long[] jjbitVec0 = {
0x1ff00000fffffffeL, 0xffffffffffffc000L, 0xffffffffL, 0x600000000000000L
};
static final long[] jjbitVec2 = {
0x0L, 0x0L, 0x0L, 0xff7fffffff7fffffL
};
static final long[] jjbitVec3 = {
0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
};
static final long[] jjbitVec4 = {
0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffL, 0x0L
};
static final long[] jjbitVec5 = {
0xffffffffffffffffL, 0xffffffffffffffffL, 0x0L, 0x0L
};
static final long[] jjbitVec6 = {
0x3fffffffffffL, 0x0L, 0x0L, 0x0L
};
private int jjMoveNfa_0(int startState, int curPos)
{
//int[] nextStates; // not used
int startsAt = 0;
jjnewStateCnt = 27;
int i = 1;
jjstateSet[0] = startState;
//int j; // not used
int kind = 0x7fffffff;
for (;;)
{
if (++jjround == 0x7fffffff)
ReInitRounds();
if (curChar < 64)
{
long l = 1L << curChar;
do
{
switch(jjstateSet[--i])
{
case 0:
if ((0x3ff000000000000L & l) != 0L)
jjCheckNAddStates(0, 5);
else if (curChar == 46)
jjCheckNAdd(9);
else if (curChar == 36)
{
if (kind > 64)
kind = 64;
jjCheckNAdd(1);
}
if ((0x3fe000000000000L & l) != 0L)
{
if (kind > 80)
kind = 80;
jjCheckNAddTwoStates(6, 7);
}
else if (curChar == 48)
{
if (kind > 80)
kind = 80;
jjCheckNAddStates(6, 8);
}
break;
case 1:
if ((0x3ff001000000000L & l) == 0L)
break;
if (kind > 64)
kind = 64;
jjCheckNAdd(1);
break;
case 3:
if ((0x41000000000L & l) != 0L)
jjstateSet[jjnewStateCnt++] = 4;
break;
case 5:
if ((0x3fe000000000000L & l) == 0L)
break;
if (kind > 80)
kind = 80;
jjCheckNAddTwoStates(6, 7);
break;
case 6:
if ((0x3ff000000000000L & l) == 0L)
break;
if (kind > 80)
kind = 80;
jjCheckNAddTwoStates(6, 7);
break;
case 8:
if (curChar == 46)
jjCheckNAdd(9);
break;
case 9:
if ((0x3ff000000000000L & l) == 0L)
break;
if (kind > 81)
kind = 81;
jjCheckNAddStates(9, 11);
break;
case 11:
if ((0x280000000000L & l) != 0L)
jjCheckNAdd(12);
break;
case 12:
if ((0x3ff000000000000L & l) == 0L)
break;
if (kind > 81)
kind = 81;
jjCheckNAddTwoStates(12, 13);
break;
case 14:
if ((0x3ff000000000000L & l) != 0L)
jjCheckNAddStates(0, 5);
break;
case 15:
if ((0x3ff000000000000L & l) != 0L)
jjCheckNAddTwoStates(15, 16);
break;
case 16:
if (curChar != 46)
break;
if (kind > 81)
kind = 81;
jjCheckNAddStates(12, 14);
break;
case 17:
if ((0x3ff000000000000L & l) == 0L)
break;
if (kind > 81)
kind = 81;
jjCheckNAddStates(12, 14);
break;
case 18:
if ((0x3ff000000000000L & l) != 0L)
jjCheckNAddTwoStates(18, 19);
break;
case 20:
if ((0x280000000000L & l) != 0L)
jjCheckNAdd(21);
break;
case 21:
if ((0x3ff000000000000L & l) == 0L)
break;
if (kind > 81)
kind = 81;
jjCheckNAddTwoStates(21, 13);
break;
case 22:
if ((0x3ff000000000000L & l) != 0L)
jjCheckNAddTwoStates(22, 13);
break;
case 23:
if (curChar != 48)
break;
if (kind > 80)
kind = 80;
jjCheckNAddStates(6, 8);
break;
case 24:
if ((0xff000000000000L & l) == 0L)
break;
if (kind > 80)
kind = 80;
jjCheckNAddTwoStates(24, 7);
break;
case 26:
if ((0x3ff000000000000L & l) == 0L)
break;
if (kind > 80)
kind = 80;
jjCheckNAddTwoStates(26, 7);
break;
default : break;
}
} while(i != startsAt);
}
else if (curChar < 128)
{
long l = 1L << (curChar & 077);
do
{
switch(jjstateSet[--i])
{
case 0:
if ((0x7fffffe87fffffeL & l) != 0L)
{
if (kind > 64)
kind = 64;
jjCheckNAdd(1);
}
else if (curChar == 91)
jjstateSet[jjnewStateCnt++] = 3;
break;
case 1:
if ((0x7fffffe87fffffeL & l) == 0L)
break;
if (kind > 64)
kind = 64;
jjCheckNAdd(1);
break;
case 2:
if (curChar == 91)
jjstateSet[jjnewStateCnt++] = 3;
break;
case 3:
if ((0x1000000040000000L & l) != 0L)
jjstateSet[jjnewStateCnt++] = 4;
break;
case 4:
if (curChar == 93)
kind = 67;
break;
case 7:
if ((0x110000001100L & l) != 0L && kind > 80)
kind = 80;
break;
case 10:
if ((0x2000000020L & l) != 0L)
jjAddStates(15, 16);
break;
case 13:
if ((0x5400000054L & l) != 0L && kind > 81)
kind = 81;
break;
case 19:
if ((0x2000000020L & l) != 0L)
jjAddStates(17, 18);
break;
case 25:
if ((0x100000001000000L & l) != 0L)
jjCheckNAdd(26);
break;
case 26:
if ((0x7e0000007eL & l) == 0L)
break;
if (kind > 80)
kind = 80;
jjCheckNAddTwoStates(26, 7);
break;
default : break;
}
} while(i != startsAt);
}
else
{
int hiByte = (int)(curChar >> 8);
int i1 = hiByte >> 6;
long l1 = 1L << (hiByte & 077);
int i2 = (curChar & 0xff) >> 6;
long l2 = 1L << (curChar & 077);
do
{
switch(jjstateSet[--i])
{
case 0:
case 1:
if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
break;
if (kind > 64)
kind = 64;
jjCheckNAdd(1);
break;
default : break;
}
} while(i != startsAt);
}
if (kind != 0x7fffffff)
{
jjmatchedKind = kind;
jjmatchedPos = curPos;
kind = 0x7fffffff;
}
++curPos;
if ((i = jjnewStateCnt) == (startsAt = 27 - (jjnewStateCnt = startsAt)))
return curPos;
try { curChar = input_stream.readChar(); }
catch(java.io.IOException e) { return curPos; }
}
}
private final int jjStopStringLiteralDfa_2(int pos, long active0, long active1)
{
switch (pos)
{
default :
return -1;
}
}
private final int jjStartNfa_2(int pos, long active0, long active1)
{
return jjMoveNfa_2(jjStopStringLiteralDfa_2(pos, active0, active1), pos + 1);
}
private int jjMoveStringLiteralDfa0_2()
{
switch(curChar)
{
case 96:
return jjStopAtPos(0, 76);
default :
return jjMoveNfa_2(0, 0);
}
}
static final long[] jjbitVec7 = {
0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
};
static final long[] jjbitVec8 = {
0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
};
private int jjMoveNfa_2(int startState, int curPos)
{
//int[] nextStates; // not used
int startsAt = 0;
jjnewStateCnt = 6;
int i = 1;
jjstateSet[0] = startState;
//int j; // not used
int kind = 0x7fffffff;
for (;;)
{
if (++jjround == 0x7fffffff)
ReInitRounds();
if (curChar < 64)
{
long l = 1L << curChar;
do
{
switch(jjstateSet[--i])
{
case 0:
if (kind > 75)
kind = 75;
break;
case 1:
if ((0x8400000000L & l) != 0L && kind > 74)
kind = 74;
break;
case 2:
if ((0xf000000000000L & l) != 0L)
jjstateSet[jjnewStateCnt++] = 3;
break;
case 3:
if ((0xff000000000000L & l) == 0L)
break;
if (kind > 74)
kind = 74;
jjstateSet[jjnewStateCnt++] = 4;
break;
case 4:
if ((0xff000000000000L & l) != 0L && kind > 74)
kind = 74;
break;
default : break;
}
} while(i != startsAt);
}
else if (curChar < 128)
{
long l = 1L << (curChar & 077);
do
{
switch(jjstateSet[--i])
{
case 0:
if ((0xfffffffeefffffffL & l) != 0L)
{
if (kind > 75)
kind = 75;
}
else if (curChar == 92)
jjAddStates(19, 21);
break;
case 1:
if ((0x14404510000000L & l) != 0L && kind > 74)
kind = 74;
break;
case 5:
if ((0xfffffffeefffffffL & l) != 0L && kind > 75)
kind = 75;
break;
default : break;
}
} while(i != startsAt);
}
else
{
int hiByte = (int)(curChar >> 8);
int i1 = hiByte >> 6;
long l1 = 1L << (hiByte & 077);
int i2 = (curChar & 0xff) >> 6;
long l2 = 1L << (curChar & 077);
do
{
switch(jjstateSet[--i])
{
case 0:
if (jjCanMove_1(hiByte, i1, i2, l1, l2) && kind > 75)
kind = 75;
break;
default : break;
}
} while(i != startsAt);
}
if (kind != 0x7fffffff)
{
jjmatchedKind = kind;
jjmatchedPos = curPos;
kind = 0x7fffffff;
}
++curPos;
if ((i = jjnewStateCnt) == (startsAt = 6 - (jjnewStateCnt = startsAt)))
return curPos;
try { curChar = input_stream.readChar(); }
catch(java.io.IOException e) { return curPos; }
}
}
private final int jjStopStringLiteralDfa_1(int pos, long active0, long active1)
{
switch (pos)
{
default :
return -1;
}
}
private final int jjStartNfa_1(int pos, long active0, long active1)
{
return jjMoveNfa_1(jjStopStringLiteralDfa_1(pos, active0, active1), pos + 1);
}
private int jjMoveStringLiteralDfa0_1()
{
switch(curChar)
{
case 39:
return jjStopAtPos(0, 73);
default :
return jjMoveNfa_1(0, 0);
}
}
private int jjMoveNfa_1(int startState, int curPos)
{
//int[] nextStates; // not used
int startsAt = 0;
jjnewStateCnt = 6;
int i = 1;
jjstateSet[0] = startState;
//int j; // not used
int kind = 0x7fffffff;
for (;;)
{
if (++jjround == 0x7fffffff)
ReInitRounds();
if (curChar < 64)
{
long l = 1L << curChar;
do
{
switch(jjstateSet[--i])
{
case 0:
if ((0xffffff7fffffffffL & l) != 0L && kind > 72)
kind = 72;
break;
case 1:
if ((0x8400000000L & l) != 0L && kind > 71)
kind = 71;
break;
case 2:
if ((0xf000000000000L & l) != 0L)
jjstateSet[jjnewStateCnt++] = 3;
break;
case 3:
if ((0xff000000000000L & l) == 0L)
break;
if (kind > 71)
kind = 71;
jjstateSet[jjnewStateCnt++] = 4;
break;
case 4:
if ((0xff000000000000L & l) != 0L && kind > 71)
kind = 71;
break;
default : break;
}
} while(i != startsAt);
}
else if (curChar < 128)
{
long l = 1L << (curChar & 077);
do
{
switch(jjstateSet[--i])
{
case 0:
if ((0xffffffffefffffffL & l) != 0L)
{
if (kind > 72)
kind = 72;
}
else if (curChar == 92)
jjAddStates(19, 21);
break;
case 1:
if ((0x14404510000000L & l) != 0L && kind > 71)
kind = 71;
break;
case 5:
if ((0xffffffffefffffffL & l) != 0L && kind > 72)
kind = 72;
break;
default : break;
}
} while(i != startsAt);
}
else
{
int hiByte = (int)(curChar >> 8);
int i1 = hiByte >> 6;
long l1 = 1L << (hiByte & 077);
int i2 = (curChar & 0xff) >> 6;
long l2 = 1L << (curChar & 077);
do
{
switch(jjstateSet[--i])
{
case 0:
if (jjCanMove_1(hiByte, i1, i2, l1, l2) && kind > 72)
kind = 72;
break;
default : break;
}
} while(i != startsAt);
}
if (kind != 0x7fffffff)
{
jjmatchedKind = kind;
jjmatchedPos = curPos;
kind = 0x7fffffff;
}
++curPos;
if ((i = jjnewStateCnt) == (startsAt = 6 - (jjnewStateCnt = startsAt)))
return curPos;
try { curChar = input_stream.readChar(); }
catch(java.io.IOException e) { return curPos; }
}
}
private final int jjStopStringLiteralDfa_3(int pos, long active0, long active1)
{
switch (pos)
{
default :
return -1;
}
}
private final int jjStartNfa_3(int pos, long active0, long active1)
{
return jjMoveNfa_3(jjStopStringLiteralDfa_3(pos, active0, active1), pos + 1);
}
private int jjMoveStringLiteralDfa0_3()
{
switch(curChar)
{
case 34:
return jjStopAtPos(0, 79);
default :
return jjMoveNfa_3(0, 0);
}
}
private int jjMoveNfa_3(int startState, int curPos)
{
//int[] nextStates; // not used
int startsAt = 0;
jjnewStateCnt = 6;
int i = 1;
jjstateSet[0] = startState;
//int j; // not used
int kind = 0x7fffffff;
for (;;)
{
if (++jjround == 0x7fffffff)
ReInitRounds();
if (curChar < 64)
{
long l = 1L << curChar;
do
{
switch(jjstateSet[--i])
{
case 0:
if ((0xfffffffbffffffffL & l) != 0L && kind > 78)
kind = 78;
break;
case 1:
if ((0x8400000000L & l) != 0L && kind > 77)
kind = 77;
break;
case 2:
if ((0xf000000000000L & l) != 0L)
jjstateSet[jjnewStateCnt++] = 3;
break;
case 3:
if ((0xff000000000000L & l) == 0L)
break;
if (kind > 77)
kind = 77;
jjstateSet[jjnewStateCnt++] = 4;
break;
case 4:
if ((0xff000000000000L & l) != 0L && kind > 77)
kind = 77;
break;
default : break;
}
} while(i != startsAt);
}
else if (curChar < 128)
{
long l = 1L << (curChar & 077);
do
{
switch(jjstateSet[--i])
{
case 0:
if ((0xffffffffefffffffL & l) != 0L)
{
if (kind > 78)
kind = 78;
}
else if (curChar == 92)
jjAddStates(19, 21);
break;
case 1:
if ((0x14404510000000L & l) != 0L && kind > 77)
kind = 77;
break;
case 5:
if ((0xffffffffefffffffL & l) != 0L && kind > 78)
kind = 78;
break;
default : break;
}
} while(i != startsAt);
}
else
{
int hiByte = (int)(curChar >> 8);
int i1 = hiByte >> 6;
long l1 = 1L << (hiByte & 077);
int i2 = (curChar & 0xff) >> 6;
long l2 = 1L << (curChar & 077);
do
{
switch(jjstateSet[--i])
{
case 0:
if (jjCanMove_1(hiByte, i1, i2, l1, l2) && kind > 78)
kind = 78;
break;
default : break;
}
} while(i != startsAt);
}
if (kind != 0x7fffffff)
{
jjmatchedKind = kind;
jjmatchedPos = curPos;
kind = 0x7fffffff;
}
++curPos;
if ((i = jjnewStateCnt) == (startsAt = 6 - (jjnewStateCnt = startsAt)))
return curPos;
try { curChar = input_stream.readChar(); }
catch(java.io.IOException e) { return curPos; }
}
}
static final int[] jjnextStates = {
15, 16, 18, 19, 22, 13, 24, 25, 7, 9, 10, 13, 17, 10, 13, 11,
12, 20, 21, 1, 2, 3,
};
private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
{
switch(hiByte)
{
case 0:
return ((jjbitVec2[i2] & l2) != 0L);
case 48:
return ((jjbitVec3[i2] & l2) != 0L);
case 49:
return ((jjbitVec4[i2] & l2) != 0L);
case 51:
return ((jjbitVec5[i2] & l2) != 0L);
case 61:
return ((jjbitVec6[i2] & l2) != 0L);
default :
if ((jjbitVec0[i1] & l1) != 0L)
return true;
return false;
}
}
private static final boolean jjCanMove_1(int hiByte, int i1, int i2, long l1, long l2)
{
switch(hiByte)
{
case 0:
return ((jjbitVec8[i2] & l2) != 0L);
default :
if ((jjbitVec7[i1] & l1) != 0L)
return true;
return false;
}
}
/** Token literal values. */
public static final String[] jjstrLiteralImages = {
"", "\54", "\75", "\77", "\72", "\174\174", "\157\162", "\46\46",
"\141\156\144", "\174", "\142\157\162", "\136", "\170\157\162", "\46", "\142\141\156\144",
"\75\75", "\145\161", "\41\75", "\156\145\161", "\74", "\154\164", "\76", "\147\164",
"\74\75", "\154\164\145", "\76\75", "\147\164\145", "\151\156", "\156\157\164",
"\74\74", "\163\150\154", "\76\76", "\163\150\162", "\76\76\76", "\165\163\150\162",
"\53", "\55", "\52", "\57", "\45", "\176", "\41",
"\151\156\163\164\141\156\143\145\157\146", "\56", "\50", "\51", "\164\162\165\145", "\146\141\154\163\145",
"\156\165\154\154", "\43\164\150\151\163", "\43\162\157\157\164", "\43", "\133", "\135", "\173",
"\175", "\100", "\156\145\167", "\44", null, null, null, null, null, null, null, null,
null, null, null, null, null, null, null, null, null, null, null, null, null, null,
null, null, null, null, null, };
/** Lexer state names. */
public static final String[] lexStateNames = {
"DEFAULT",
"WithinCharLiteral",
"WithinBackCharLiteral",
"WithinStringLiteral",
};
/** Lex State array. */
public static final int[] jjnewLexState = {
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2, 1, 3, -1, -1, 0, -1,
-1, 0, -1, -1, 0, -1, -1, -1, -1, -1, -1,
};
static final long[] jjtoToken = {
0x7ffffffffffffffL, 0x39209L,
};
static final long[] jjtoSkip = {
0xf800000000000000L, 0x0L,
};
static final long[] jjtoMore = {
0x0L, 0x6df0L,
};
protected JavaCharStream input_stream;
private final int[] jjrounds = new int[27];
private final int[] jjstateSet = new int[54];
private final StringBuffer image = new StringBuffer();
private int jjimageLen;
private int lengthOfMatch;
protected char curChar;
/** Constructor. */
public OgnlParserTokenManager(JavaCharStream stream){
if (JavaCharStream.staticFlag)
throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
input_stream = stream;
}
/** Constructor. */
public OgnlParserTokenManager(JavaCharStream stream, int lexState){
this(stream);
SwitchTo(lexState);
}
/** Reinitialise parser. */
public void ReInit(JavaCharStream stream)
{
jjmatchedPos = jjnewStateCnt = 0;
curLexState = defaultLexState;
input_stream = stream;
ReInitRounds();
}
private void ReInitRounds()
{
int i;
jjround = 0x80000001;
for (i = 27; i-- > 0;)
jjrounds[i] = 0x80000000;
}
/** Reinitialise parser. */
public void ReInit(JavaCharStream stream, int lexState)
{
ReInit(stream);
SwitchTo(lexState);
}
/** Switch to specified lex state. */
public void SwitchTo(int lexState)
{
if (lexState >= 4 || lexState < 0)
throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
else
curLexState = lexState;
}
protected Token jjFillToken()
{
final Token t;
final String tokenImage;
final int beginLine;
final int endLine;
final int beginColumn;
final int endColumn;
String im = jjstrLiteralImages[jjmatchedKind];
tokenImage = (im == null) ? input_stream.GetImage() : im;
beginLine = input_stream.getBeginLine();
beginColumn = input_stream.getBeginColumn();
endLine = input_stream.getEndLine();
endColumn = input_stream.getEndColumn();
t = Token.newToken(jjmatchedKind, tokenImage);
t.beginLine = beginLine;
t.endLine = endLine;
t.beginColumn = beginColumn;
t.endColumn = endColumn;
return t;
}
int curLexState = 0;
int defaultLexState = 0;
int jjnewStateCnt;
int jjround;
int jjmatchedPos;
int jjmatchedKind;
/** Get the next Token. */
public Token getNextToken()
{
Token matchedToken;
int curPos = 0;
EOFLoop :
for (;;)
{
try
{
curChar = input_stream.BeginToken();
}
catch(java.io.IOException e)
{
jjmatchedKind = 0;
matchedToken = jjFillToken();
return matchedToken;
}
image.setLength(0);
jjimageLen = 0;
for (;;)
{
switch(curLexState)
{
case 0:
try { input_stream.backup(0);
while (curChar <= 32 && (0x100003600L & (1L << curChar)) != 0L)
curChar = input_stream.BeginToken();
}
catch (java.io.IOException e1) { continue EOFLoop; }
jjmatchedKind = 0x7fffffff;
jjmatchedPos = 0;
curPos = jjMoveStringLiteralDfa0_0();
break;
case 1:
jjmatchedKind = 0x7fffffff;
jjmatchedPos = 0;
curPos = jjMoveStringLiteralDfa0_1();
break;
case 2:
jjmatchedKind = 0x7fffffff;
jjmatchedPos = 0;
curPos = jjMoveStringLiteralDfa0_2();
break;
case 3:
jjmatchedKind = 0x7fffffff;
jjmatchedPos = 0;
curPos = jjMoveStringLiteralDfa0_3();
break;
}
if (jjmatchedKind != 0x7fffffff)
{
if (jjmatchedPos + 1 < curPos)
input_stream.backup(curPos - jjmatchedPos - 1);
if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
{
matchedToken = jjFillToken();
TokenLexicalActions(matchedToken);
if (jjnewLexState[jjmatchedKind] != -1)
curLexState = jjnewLexState[jjmatchedKind];
return matchedToken;
}
else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
{
if (jjnewLexState[jjmatchedKind] != -1)
curLexState = jjnewLexState[jjmatchedKind];
continue EOFLoop;
}
MoreLexicalActions();
if (jjnewLexState[jjmatchedKind] != -1)
curLexState = jjnewLexState[jjmatchedKind];
curPos = 0;
jjmatchedKind = 0x7fffffff;
try {
curChar = input_stream.readChar();
continue;
}
catch (java.io.IOException e1) { }
}
int error_line = input_stream.getEndLine();
int error_column = input_stream.getEndColumn();
String error_after = null;
boolean EOFSeen = false;
try { input_stream.readChar(); input_stream.backup(1); }
catch (java.io.IOException e1) {
EOFSeen = true;
error_after = curPos <= 1 ? "" : input_stream.GetImage();
if (curChar == '\n' || curChar == '\r') {
error_line++;
error_column = 0;
}
else
error_column++;
}
if (!EOFSeen) {
input_stream.backup(1);
error_after = curPos <= 1 ? "" : input_stream.GetImage();
}
throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
}
}
}
void MoreLexicalActions()
{
jjimageLen += (lengthOfMatch = jjmatchedPos + 1);
switch(jjmatchedKind)
{
case 69 :
image.append(input_stream.GetSuffix(jjimageLen));
jjimageLen = 0;
stringBuffer = new StringBuffer();
break;
case 70 :
image.append(input_stream.GetSuffix(jjimageLen));
jjimageLen = 0;
stringBuffer = new StringBuffer();
break;
case 71 :
image.append(input_stream.GetSuffix(jjimageLen));
jjimageLen = 0;
charValue = escapeChar(); stringBuffer.append(charValue);
break;
case 72 :
image.append(input_stream.GetSuffix(jjimageLen));
jjimageLen = 0;
charValue = image.charAt( image.length()-1 ); stringBuffer.append(charValue);
break;
case 74 :
image.append(input_stream.GetSuffix(jjimageLen));
jjimageLen = 0;
charValue = escapeChar();
break;
case 75 :
image.append(input_stream.GetSuffix(jjimageLen));
jjimageLen = 0;
charValue = image.charAt( image.length()-1 );
break;
case 77 :
image.append(input_stream.GetSuffix(jjimageLen));
jjimageLen = 0;
stringBuffer.append( escapeChar() );
break;
case 78 :
image.append(input_stream.GetSuffix(jjimageLen));
jjimageLen = 0;
stringBuffer.append( image.charAt(image.length()-1) );
break;
default :
break;
}
}
void TokenLexicalActions(Token matchedToken)
{
switch(jjmatchedKind)
{
case 67 :
image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
switch (image.charAt(1)) {
case '^': literalValue = DynamicSubscript.first; break;
case '|': literalValue = DynamicSubscript.mid; break;
case '$': literalValue = DynamicSubscript.last; break;
case '*': literalValue = DynamicSubscript.all; break;
}
break;
case 73 :
image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
if (stringBuffer.length() == 1) {
literalValue = new Character( charValue );
} else {
literalValue = new String( stringBuffer );
}
break;
case 76 :
image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
literalValue = new Character( charValue );
break;
case 79 :
image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
literalValue = new String( stringBuffer );
break;
case 80 :
image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
literalValue =
makeInt();
break;
case 81 :
image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
literalValue = makeFloat();
break;
default :
break;
}
}
private void jjCheckNAdd(int state)
{
if (jjrounds[state] != jjround)
{
jjstateSet[jjnewStateCnt++] = state;
jjrounds[state] = jjround;
}
}
private void jjAddStates(int start, int end)
{
do {
jjstateSet[jjnewStateCnt++] = jjnextStates[start];
} while (start++ != end);
}
private void jjCheckNAddTwoStates(int state1, int state2)
{
jjCheckNAdd(state1);
jjCheckNAdd(state2);
}
private void jjCheckNAddStates(int start, int end)
{
do {
jjCheckNAdd(jjnextStates[start]);
} while (start++ != end);
}
}
ognl-2.7.3.orig/src/java/ognl/MapElementsAccessor.java 0000644 0001750 0001750 00000004176 10561411075 022534 0 ustar drazzib drazzib //--------------------------------------------------------------------------
// Copyright (c) 1998-2004, Drew Davidson and Luke Blanshard
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
// Neither the name of the Drew Davidson nor the names of its contributors
// may be used to endorse or promote products derived from this software
// without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
// COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
// OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
// AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
// DAMAGE.
//--------------------------------------------------------------------------
package ognl;
import java.util.*;
/**
* Implementation of ElementsAccessor that returns an iterator over the map's values.
* @author Luke Blanshard (blanshlu@netscape.net)
* @author Drew Davidson (drew@ognl.org)
*/
public class MapElementsAccessor implements ElementsAccessor
{
public Enumeration getElements( Object target )
{
return new IteratorEnumeration( ((Map)target).values().iterator() );
}
}
ognl-2.7.3.orig/src/java/ognl/ASTRemainder.java 0000644 0001750 0001750 00000004544 10641530755 021122 0 ustar drazzib drazzib //--------------------------------------------------------------------------
// Copyright (c) 1998-2004, Drew Davidson and Luke Blanshard
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
// Neither the name of the Drew Davidson nor the names of its contributors
// may be used to endorse or promote products derived from this software
// without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
// COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
// OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
// AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
// DAMAGE.
//--------------------------------------------------------------------------
package ognl;
/**
* @author Luke Blanshard (blanshlu@netscape.net)
* @author Drew Davidson (drew@ognl.org)
*/
class ASTRemainder extends NumericExpression
{
public ASTRemainder(int id) {
super(id);
}
public ASTRemainder(OgnlParser p, int id) {
super(p, id);
}
protected Object getValueBody( OgnlContext context, Object source ) throws OgnlException
{
Object v1 = _children[0].getValue( context, source );
Object v2 = _children[1].getValue( context, source );
return OgnlOps.remainder( v1, v2 );
}
public String getExpressionOperator(int index)
{
return "%";
}
}
ognl-2.7.3.orig/src/java/ognl/ASTNotIn.java 0000644 0001750 0001750 00000006562 10646473765 020261 0 ustar drazzib drazzib //--------------------------------------------------------------------------
// Copyright (c) 1998-2004, Drew Davidson and Luke Blanshard
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
// Neither the name of the Drew Davidson nor the names of its contributors
// may be used to endorse or promote products derived from this software
// without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
// COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
// OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
// AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
// DAMAGE.
//--------------------------------------------------------------------------
package ognl;
import ognl.enhance.UnsupportedCompilationException;
/**
* @author Luke Blanshard (blanshlu@netscape.net)
* @author Drew Davidson (drew@ognl.org)
*/
class ASTNotIn extends SimpleNode implements NodeType
{
public ASTNotIn(int id) {
super(id);
}
public ASTNotIn(OgnlParser p, int id) {
super(p, id);
}
protected Object getValueBody( OgnlContext context, Object source ) throws OgnlException
{
Object v1 = _children[0].getValue( context, source );
Object v2 = _children[1].getValue( context, source );
return OgnlOps.in( v1, v2 )? Boolean.FALSE : Boolean.TRUE;
}
public String toString()
{
return _children[0] + " not in " + _children[1];
}
public Class getGetterClass()
{
return Boolean.TYPE;
}
public Class getSetterClass()
{
return null;
}
public String toGetSourceString(OgnlContext context, Object target)
{
try {
String result = "(! ognl.OgnlOps.in( ($w) ";
result += OgnlRuntime.getChildSource(context, target, _children[0]) + ", ($w) " + OgnlRuntime.getChildSource(context, target, _children[1]);
result += ") )";
context.setCurrentType(Boolean.TYPE);
return result;
} catch (NullPointerException e) {
// expected to happen in some instances
e.printStackTrace();
throw new UnsupportedCompilationException("evaluation resulted in null expression.");
} catch (Throwable t)
{
throw OgnlOps.castToRuntime(t);
}
}
}
ognl-2.7.3.orig/src/java/ognl/ASTSubtract.java 0000644 0001750 0001750 00000004540 10566476144 021006 0 ustar drazzib drazzib //--------------------------------------------------------------------------
// Copyright (c) 1998-2004, Drew Davidson and Luke Blanshard
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
// Neither the name of the Drew Davidson nor the names of its contributors
// may be used to endorse or promote products derived from this software
// without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
// COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
// OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
// AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
// DAMAGE.
//--------------------------------------------------------------------------
package ognl;
/**
* @author Luke Blanshard (blanshlu@netscape.net)
* @author Drew Davidson (drew@ognl.org)
*/
class ASTSubtract extends NumericExpression
{
public ASTSubtract(int id) {
super(id);
}
public ASTSubtract(OgnlParser p, int id) {
super(p, id);
}
protected Object getValueBody( OgnlContext context, Object source ) throws OgnlException
{
Object v1 = _children[0].getValue( context, source );
Object v2 = _children[1].getValue( context, source );
return OgnlOps.subtract( v1, v2 );
}
public String getExpressionOperator(int index)
{
return "-";
}
}
ognl-2.7.3.orig/src/java/ognl/ASTStaticField.java 0000644 0001750 0001750 00000014270 10646473765 021420 0 ustar drazzib drazzib // --------------------------------------------------------------------------
// Copyright (c) 1998-2004, Drew Davidson and Luke Blanshard
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
// Neither the name of the Drew Davidson nor the names of its contributors
// may be used to endorse or promote products derived from this software
// without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
// COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
// OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
// AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
// DAMAGE.
// --------------------------------------------------------------------------
package ognl;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
/**
* @author Luke Blanshard (blanshlu@netscape.net)
* @author Drew Davidson (drew@ognl.org)
*/
public class ASTStaticField extends SimpleNode implements NodeType
{
private String className;
private String fieldName;
private Class _getterClass;
public ASTStaticField(int id)
{
super(id);
}
public ASTStaticField(OgnlParser p, int id)
{
super(p, id);
}
/** Called from parser action. */
void init(String className, String fieldName)
{
this.className = className;
this.fieldName = fieldName;
}
protected Object getValueBody(OgnlContext context, Object source)
throws OgnlException
{
return OgnlRuntime.getStaticField(context, className, fieldName);
}
public boolean isNodeConstant(OgnlContext context)
throws OgnlException
{
boolean result = false;
Exception reason = null;
try {
Class 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 if (OgnlRuntime.isJdk15() && c.isEnum())
{
result = true;
} else
{
Field f = c.getField(fieldName);
if (!Modifier.isStatic(f.getModifiers()))
throw new OgnlException("Field " + fieldName + " of class " + className + " is not static");
result = Modifier.isFinal(f.getModifiers());
}
} catch (ClassNotFoundException e) {
reason = e;
} catch (NoSuchFieldException 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;
}
Class getFieldClass(OgnlContext context)
throws OgnlException
{
Exception reason = null;
try {
Class 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"))
{
return c;
} else if (OgnlRuntime.isJdk15() && c.isEnum())
{
return c;
} else
{
Field f = c.getField(fieldName);
return f.getType();
}
} catch (ClassNotFoundException e) {
reason = e;
} catch (NoSuchFieldException 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 null;
}
public Class getGetterClass()
{
return _getterClass;
}
public Class getSetterClass()
{
return _getterClass;
}
public String toString()
{
return "@" + className + "@" + fieldName;
}
public String toGetSourceString(OgnlContext context, Object target)
{
try {
Object obj = OgnlRuntime.getStaticField(context, className, fieldName);
context.setCurrentObject(obj);
_getterClass = getFieldClass(context);
context.setCurrentType(_getterClass);
} catch (Throwable t)
{
throw OgnlOps.castToRuntime(t);
}
return className + "." + fieldName;
}
public String toSetSourceString(OgnlContext context, Object target)
{
try {
Object obj = OgnlRuntime.getStaticField(context, className, fieldName);
context.setCurrentObject(obj);
_getterClass = getFieldClass(context);
context.setCurrentType(_getterClass);
} catch (Throwable t)
{
throw OgnlOps.castToRuntime(t);
}
return className + "." + fieldName;
}
}
ognl-2.7.3.orig/src/java/ognl/ASTThisVarRef.java 0000644 0001750 0001750 00000005424 10566476144 021236 0 ustar drazzib drazzib // --------------------------------------------------------------------------
// Copyright (c) 1998-2004, Drew Davidson and Luke Blanshard
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
// Neither the name of the Drew Davidson nor the names of its contributors
// may be used to endorse or promote products derived from this software
// without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
// COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
// OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
// AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
// DAMAGE.
// --------------------------------------------------------------------------
package ognl;
import ognl.enhance.UnsupportedCompilationException;
/**
* @author Luke Blanshard (blanshlu@netscape.net)
* @author Drew Davidson (drew@ognl.org)
*/
public class ASTThisVarRef extends ASTVarRef
{
public ASTThisVarRef(int id)
{
super(id);
}
public ASTThisVarRef(OgnlParser p, int id)
{
super(p, id);
}
protected Object getValueBody(OgnlContext context, Object source)
throws OgnlException
{
return context.getCurrentObject();
}
protected void setValueBody(OgnlContext context, Object target, Object value)
throws OgnlException
{
context.setCurrentObject(value);
}
public String toString()
{
return "#this";
}
public String toGetSourceString(OgnlContext context, Object target)
{
throw new UnsupportedCompilationException("Unable to compile this references.");
}
public String toSetSourceString(OgnlContext context, Object target)
{
throw new UnsupportedCompilationException("Unable to compile this references.");
}
}
ognl-2.7.3.orig/src/java/ognl/NodeType.java 0000644 0001750 0001750 00000000732 10633051645 020363 0 ustar drazzib drazzib /**
*
*/
package ognl;
/**
* Used by some of the {@link ognl.enhance.OgnlExpressionCompiler} logic to determine the object
* type of {@link Node}s during expression evaluation.
*/
public interface NodeType
{
/**
* The type returned from the expression - if any.
*
* @return The type.
*/
Class getGetterClass();
/**
* The type used to set the value - if any.
*
* @return The type.
*/
Class getSetterClass();
}
ognl-2.7.3.orig/src/java/ognl/ASTNegate.java 0000644 0001750 0001750 00000005101 10634650771 020410 0 ustar drazzib drazzib //--------------------------------------------------------------------------
// Copyright (c) 1998-2004, Drew Davidson and Luke Blanshard
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
// Neither the name of the Drew Davidson nor the names of its contributors
// may be used to endorse or promote products derived from this software
// without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
// COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
// OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
// AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
// DAMAGE.
//--------------------------------------------------------------------------
package ognl;
/**
* @author Luke Blanshard (blanshlu@netscape.net)
* @author Drew Davidson (drew@ognl.org)
*/
class ASTNegate extends NumericExpression
{
public ASTNegate(int id) {
super(id);
}
public ASTNegate(OgnlParser p, int id) {
super(p, id);
}
protected Object getValueBody( OgnlContext context, Object source ) throws OgnlException
{
return OgnlOps.negate( _children[0].getValue(context, source) );
}
public String toString()
{
return "-" + _children[0];
}
public String toGetSourceString(OgnlContext context, Object target)
{
String source = _children[0].toGetSourceString(context, target);
if (!ASTNegate.class.isInstance(_children[0]))
{
return "-" + source;
} else
{
return "-(" + source + ")";
}
}
}
ognl-2.7.3.orig/src/java/ognl/Ognl.java 0000644 0001750 0001750 00000111130 10633051645 017526 0 ustar drazzib drazzib // --------------------------------------------------------------------------
// Copyright (c) 1998-2004, Drew Davidson and Luke Blanshard
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
// Neither the name of the Drew Davidson nor the names of its contributors
// may be used to endorse or promote products derived from this software
// without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
// COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
// OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
// AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
// DAMAGE.
// --------------------------------------------------------------------------
package ognl;
import ognl.enhance.ExpressionAccessor;
import java.io.StringReader;
import java.util.Map;
/**
*
* This class provides static methods for parsing and interpreting OGNL expressions.
*
*
* The simplest use of the Ognl class is to get the value of an expression from an object, without
* extra context or pre-parsing.
*
*
*
*
* import ognl.Ognl; import ognl.OgnlException; try { result = Ognl.getValue(expression, root); }
* catch (OgnlException ex) { // Report error or recover }
*
*
*
*
* This will parse the expression given and evaluate it against the root object given, returning the
* result. If there is an error in the expression, such as the property is not found, the exception
* is encapsulated into an {@link ognl.OgnlException OgnlException}.
*
*
* Other more sophisticated uses of Ognl can pre-parse expressions. This provides two advantages: in
* the case of user-supplied expressions it allows you to catch parse errors before evaluation and
* it allows you to cache parsed expressions into an AST for better speed during repeated use. The
* pre-parsed expression is always returned as an Object to simplify use for programs
* that just wish to store the value for repeated use and do not care that it is an AST. If it does
* care it can always safely cast the value to an AST type.
*
*
* The Ognl class also takes a context map as one of the parameters to the set and get
* methods. This allows you to put your own variables into the available namespace for OGNL
* expressions. The default context contains only the #root and #context
* keys, which are required to be present. The addDefaultContext(Object, Map) method
* will alter an existing Map to put the defaults in. Here is an example that shows
* how to extract the documentName property out of the root object and append a
* string with the current user name in parens:
*
*
*
*
* private Map context = new HashMap(); public void setUserName(String value) {
* context.put("userName", value); } try { // get value using our own custom context map result =
* Ognl.getValue("documentName + \" (\" + ((#userName == null) ? \"<nobody>\" : #userName) +
* \")\"", context, root); } catch (OgnlException ex) { // Report error or recover }
*
*
*
* @author Luke Blanshard (blanshlu@netscape.net)
* @author Drew Davidson (drew@ognl.org)
* @version 27 June 1999
*/
public abstract class Ognl
{
/**
* Parses the given OGNL expression and returns a tree representation of the expression that can
* be used by Ognl static methods.
*
* @param expression
* the OGNL expression to be parsed
* @return a tree representation of the expression
* @throws ExpressionSyntaxException
* if the expression is malformed
* @throws OgnlException
* if there is a pathological environmental problem
*/
public static Object parseExpression(String expression)
throws OgnlException
{
try {
OgnlParser parser = new OgnlParser(new StringReader(expression));
return parser.topLevelExpression();
} catch (ParseException e) {
throw new ExpressionSyntaxException(expression, e);
} catch (TokenMgrError e) {
throw new ExpressionSyntaxException(expression, e);
}
}
/**
* Parses and compiles the given expression using the {@link ognl.enhance.OgnlExpressionCompiler} returned
* from {@link ognl.OgnlRuntime#getCompiler()}.
*
* @param context
* The context to use.
* @param root
* The root object for the given expression.
* @param expression
* The expression to compile.
*
* @return The node with a compiled accessor set on {@link ognl.Node#getAccessor()} if compilation
* was successfull. In instances where compilation wasn't possible because of a partially null
* expression the {@link ExpressionAccessor} instance may be null and the compilation of this expression
* still possible at some as yet indertermined point in the future.
*
* @throws Exception If a compilation error occurs.
*/
public static Node compileExpression(OgnlContext context, Object root, String expression)
throws Exception
{
Node expr = (Node)Ognl.parseExpression(expression);
OgnlRuntime.compileExpression(context, expr, root);
return expr;
}
/**
* Creates and returns a new standard naming context for evaluating an OGNL expression.
*
* @param root
* the root of the object graph
* @return a new Map with the keys root and context set
* appropriately
*/
public static Map createDefaultContext(Object root)
{
return addDefaultContext(root, null, null, null, new OgnlContext());
}
/**
* Creates and returns a new standard naming context for evaluating an OGNL expression.
*
* @param root
* The root of the object graph.
* @param classResolver
* The resolver used to instantiate {@link Class} instances referenced in the expression.
*
* @return a new OgnlContext with the keys root and context set
* appropriately
*/
public static Map createDefaultContext(Object root, ClassResolver classResolver)
{
return addDefaultContext(root, classResolver, null, null, new OgnlContext());
}
/**
* Creates and returns a new standard naming context for evaluating an OGNL expression.
*
* @param root
* The root of the object graph.
* @param classResolver
* The resolver used to instantiate {@link Class} instances referenced in the expression.
* @param converter
* Converter used to convert return types of an expression in to their desired types.
*
* @return a new Map with the keys root and context set
* appropriately
*/
public static Map createDefaultContext(Object root, ClassResolver classResolver, TypeConverter converter)
{
return addDefaultContext(root, classResolver, converter, null, new OgnlContext());
}
/**
* Creates and returns a new standard naming context for evaluating an OGNL expression.
*
* @param root
* The root of the object graph.
* @param classResolver
* The resolver used to instantiate {@link Class} instances referenced in the expression.
* @param converter
* Converter used to convert return types of an expression in to their desired types.
* @param memberAccess
* Java security handling object to determine semantics for accessing normally private/protected
* methods / fields.
* @return a new Map with the keys root and context set
* appropriately
*/
public static Map createDefaultContext(Object root, ClassResolver classResolver,
TypeConverter converter, MemberAccess memberAccess)
{
return addDefaultContext(root, classResolver, converter, memberAccess, new OgnlContext());
}
/**
* Appends the standard naming context for evaluating an OGNL expression into the context given
* so that cached maps can be used as a context.
*
* @param root
* the root of the object graph
* @param context
* the context to which OGNL context will be added.
* @return Context Map with the keys root and context set
* appropriately
*/
public static Map addDefaultContext(Object root, Map context)
{
return addDefaultContext(root, null, null, null, context);
}
/**
* Appends the standard naming context for evaluating an OGNL expression into the context given
* so that cached maps can be used as a context.
*
* @param root
* The root of the object graph.
* @param classResolver
* The resolver used to instantiate {@link Class} instances referenced in the expression.
* @param context
* The context to which OGNL context will be added.
*
* @return Context Map with the keys root and context set
* appropriately
*/
public static Map addDefaultContext(Object root, ClassResolver classResolver, Map context)
{
return addDefaultContext(root, classResolver, null, null, context);
}
/**
* Appends the standard naming context for evaluating an OGNL expression into the context given
* so that cached maps can be used as a context.
*
* @param root
* The root of the object graph.
* @param classResolver
* The resolver used to instantiate {@link Class} instances referenced in the expression.
* @param converter
* Converter used to convert return types of an expression in to their desired types.
* @param context
* The context to which OGNL context will be added.
*
* @return Context Map with the keys root and context set
* appropriately
*/
public static Map addDefaultContext(Object root, ClassResolver classResolver,
TypeConverter converter, Map context)
{
return addDefaultContext(root, classResolver, converter, null, context);
}
/**
* Appends the standard naming context for evaluating an OGNL expression into the context given
* so that cached maps can be used as a context.
*
* @param root
* the root of the object graph
* @param classResolver
* The class loading resolver that should be used to resolve class references.
* @param converter
* The type converter to be used by default.
* @param memberAccess
* Definition for handling private/protected access.
* @param context
* Default context to use, if not an {@link OgnlContext} will be dumped into
* a new {@link OgnlContext} object.
* @return Context Map with the keys root and context set
* appropriately
*/
public static Map addDefaultContext(Object root, ClassResolver classResolver,
TypeConverter converter, MemberAccess memberAccess, Map context)
{
OgnlContext result;
if (!(context instanceof OgnlContext)) {
result = new OgnlContext();
result.setValues(context);
} else {
result = (OgnlContext) context;
}
if (classResolver != null) {
result.setClassResolver(classResolver);
}
if (converter != null) {
result.setTypeConverter(converter);
}
if (memberAccess != null) {
result.setMemberAccess(memberAccess);
}
result.setRoot(root);
return result;
}
/**
* Configures the {@link ClassResolver} to use for the given context. Will be used during
* expression parsing / execution to resolve class names.
*
* @param context
* The context to place the resolver.
* @param classResolver
* The resolver to use to resolve classes.
*/
public static void setClassResolver(Map context, ClassResolver classResolver)
{
context.put(OgnlContext.CLASS_RESOLVER_CONTEXT_KEY, classResolver);
}
/**
* Gets the previously stored {@link ClassResolver} for the given context - if any.
*
* @param context
* The context to get the configured resolver from.
*
* @return The resolver instance, or null if none found.
*/
public static ClassResolver getClassResolver(Map context)
{
return (ClassResolver) context.get(OgnlContext.CLASS_RESOLVER_CONTEXT_KEY);
}
/**
* Configures the type converter to use for a given context. This will be used
* to convert into / out of various java class types.
*
* @param context
* The context to configure it for.
* @param converter
* The converter to use.
*/
public static void setTypeConverter(Map context, TypeConverter converter)
{
context.put(OgnlContext.TYPE_CONVERTER_CONTEXT_KEY, converter);
}
/**
* Gets the currently configured {@link TypeConverter} for the given context - if any.
*
* @param context
* The context to get the converter from.
*
* @return The converter - or null if none found.
*/
public static TypeConverter getTypeConverter(Map context)
{
return (TypeConverter) context.get(OgnlContext.TYPE_CONVERTER_CONTEXT_KEY);
}
/**
* Configures the specified context with a {@link MemberAccess} instance for
* handling field/method protection levels.
*
* @param context
* The context to configure.
* @param memberAccess
* The access resolver to configure the context with.
*/
public static void setMemberAccess(Map context, MemberAccess memberAccess)
{
context.put(OgnlContext.MEMBER_ACCESS_CONTEXT_KEY, memberAccess);
}
/**
* Gets the currently stored {@link MemberAccess} object for the given context - if any.
*
* @param context
* The context to get the object from.
*
* @return The configured {@link MemberAccess} instance in the specified context - or null if none found.
*/
public static MemberAccess getMemberAccess(Map context)
{
return (MemberAccess) context.get(OgnlContext.MEMBER_ACCESS_CONTEXT_KEY);
}
/**
* Sets the root object to use for all expressions in the given context - doesn't necessarily replace
* root object instances explicitly passed in to other expression resolving methods on this class.
*
* @param context
* The context to store the root object in.
* @param root
* The root object.
*/
public static void setRoot(Map context, Object root)
{
context.put(OgnlContext.ROOT_CONTEXT_KEY, root);
}
/**
* Gets the stored root object for the given context - if any.
*
* @param context
* The context to get the root object from.
*
* @return The root object - or null if none found.
*/
public static Object getRoot(Map context)
{
return context.get(OgnlContext.ROOT_CONTEXT_KEY);
}
/**
* Gets the last {@link Evaluation} executed on the given context.
*
* @param context
* The context to get the evaluation from.
*
* @return The {@link Evaluation} - or null if none was found.
*/
public static Evaluation getLastEvaluation(Map context)
{
return (Evaluation) context.get(OgnlContext.LAST_EVALUATION_CONTEXT_KEY);
}
/**
* Evaluates the given OGNL expression tree to extract a value from the given root object. The
* default context is set for the given context and root via addDefaultContext().
*
* @param tree
* the OGNL expression tree to evaluate, as returned by parseExpression()
* @param context
* the naming context for the evaluation
* @param root
* the root object for the OGNL expression
* @return the result of evaluating the expression
* @throws MethodFailedException
* if the expression called a method which failed
* @throws NoSuchPropertyException
* if the expression referred to a nonexistent property
* @throws InappropriateExpressionException
* if the expression can't be used in this context
* @throws OgnlException
* if there is a pathological environmental problem
*/
public static Object getValue(Object tree, Map context, Object root)
throws OgnlException
{
return getValue(tree, context, root, null);
}
/**
* Evaluates the given OGNL expression tree to extract a value from the given root object. The
* default context is set for the given context and root via addDefaultContext().
*
* @param tree
* the OGNL expression tree to evaluate, as returned by parseExpression()
* @param context
* the naming context for the evaluation
* @param root
* the root object for the OGNL expression
* @param resultType
* the converted type of the resultant object, using the context's type converter
* @return the result of evaluating the expression
* @throws MethodFailedException
* if the expression called a method which failed
* @throws NoSuchPropertyException
* if the expression referred to a nonexistent property
* @throws InappropriateExpressionException
* if the expression can't be used in this context
* @throws OgnlException
* if there is a pathological environmental problem
*/
public static Object getValue(Object tree, Map context, Object root, Class resultType)
throws OgnlException
{
Object result;
OgnlContext ognlContext = (OgnlContext) addDefaultContext(root, context);
Node node = (Node)tree;
if (node.getAccessor() != null)
result = node.getAccessor().get(ognlContext, root);
else
result = node.getValue(ognlContext, root);
if (resultType != null) {
result = getTypeConverter(context).convertValue(context, root, null, null, result, resultType);
}
return result;
}
/**
* Gets the value represented by the given pre-compiled expression on the specified root
* object.
*
* @param expression
* The pre-compiled expression, as found in {@link Node#getAccessor()}.
* @param context
* The ognl context.
* @param root
* The object to retrieve the expression value from.
* @return
* The value.
*/
public static Object getValue(ExpressionAccessor expression, OgnlContext context, Object root)
{
return expression.get(context, root);
}
/**
* Gets the value represented by the given pre-compiled expression on the specified root
* object.
*
* @param expression
* The pre-compiled expression, as found in {@link Node#getAccessor()}.
* @param context
* The ognl context.
* @param root
* The object to retrieve the expression value from.
* @param resultType
* The desired object type that the return value should be converted to using the {@link #getTypeConverter(java.util.Map)} }.
* @return
* The value.
*/
public static Object getValue(ExpressionAccessor expression, OgnlContext context,
Object root, Class resultType)
{
return getTypeConverter(context).convertValue(context, root, null, null, expression.get(context, root), resultType);
}
/**
* Evaluates the given OGNL expression to extract a value from the given root object in a given
* context
*
* @see #parseExpression(String)
* @see #getValue(Object,Object)
* @param expression
* the OGNL expression to be parsed
* @param context
* the naming context for the evaluation
* @param root
* the root object for the OGNL expression
* @return the result of evaluating the expression
* @throws MethodFailedException
* if the expression called a method which failed
* @throws NoSuchPropertyException
* if the expression referred to a nonexistent property
* @throws InappropriateExpressionException
* if the expression can't be used in this context
* @throws OgnlException
* if there is a pathological environmental problem
*/
public static Object getValue(String expression, Map context, Object root)
throws OgnlException
{
return getValue(expression, context, root, null);
}
/**
* Evaluates the given OGNL expression to extract a value from the given root object in a given
* context
*
* @see #parseExpression(String)
* @see #getValue(Object,Object)
* @param expression
* the OGNL expression to be parsed
* @param context
* the naming context for the evaluation
* @param root
* the root object for the OGNL expression
* @param resultType
* the converted type of the resultant object, using the context's type converter
* @return the result of evaluating the expression
* @throws MethodFailedException
* if the expression called a method which failed
* @throws NoSuchPropertyException
* if the expression referred to a nonexistent property
* @throws InappropriateExpressionException
* if the expression can't be used in this context
* @throws OgnlException
* if there is a pathological environmental problem
*/
public static Object getValue(String expression, Map context, Object root, Class resultType)
throws OgnlException
{
return getValue(parseExpression(expression), context, root, resultType);
}
/**
* Evaluates the given OGNL expression tree to extract a value from the given root object.
*
* @param tree
* the OGNL expression tree to evaluate, as returned by parseExpression()
* @param root
* the root object for the OGNL expression
* @return the result of evaluating the expression
* @throws MethodFailedException
* if the expression called a method which failed
* @throws NoSuchPropertyException
* if the expression referred to a nonexistent property
* @throws InappropriateExpressionException
* if the expression can't be used in this context
* @throws OgnlException
* if there is a pathological environmental problem
*/
public static Object getValue(Object tree, Object root)
throws OgnlException
{
return getValue(tree, root, null);
}
/**
* Evaluates the given OGNL expression tree to extract a value from the given root object.
*
* @param tree
* the OGNL expression tree to evaluate, as returned by parseExpression()
* @param root
* the root object for the OGNL expression
* @param resultType
* the converted type of the resultant object, using the context's type converter
* @return the result of evaluating the expression
* @throws MethodFailedException
* if the expression called a method which failed
* @throws NoSuchPropertyException
* if the expression referred to a nonexistent property
* @throws InappropriateExpressionException
* if the expression can't be used in this context
* @throws OgnlException
* if there is a pathological environmental problem
*/
public static Object getValue(Object tree, Object root, Class resultType)
throws OgnlException
{
return getValue(tree, createDefaultContext(root), root, resultType);
}
/**
* Convenience method that combines calls to parseExpression and
* getValue.
*
* @see #parseExpression(String)
* @see #getValue(Object,Object)
* @param expression
* the OGNL expression to be parsed
* @param root
* the root object for the OGNL expression
* @return the result of evaluating the expression
* @throws ExpressionSyntaxException
* if the expression is malformed
* @throws MethodFailedException
* if the expression called a method which failed
* @throws NoSuchPropertyException
* if the expression referred to a nonexistent property
* @throws InappropriateExpressionException
* if the expression can't be used in this context
* @throws OgnlException
* if there is a pathological environmental problem
*/
public static Object getValue(String expression, Object root)
throws OgnlException
{
return getValue(expression, root, null);
}
/**
* Convenience method that combines calls to parseExpression and
* getValue.
*
* @see #parseExpression(String)
* @see #getValue(Object,Object)
* @param expression
* the OGNL expression to be parsed
* @param root
* the root object for the OGNL expression
* @param resultType
* the converted type of the resultant object, using the context's type converter
* @return the result of evaluating the expression
* @throws ExpressionSyntaxException
* if the expression is malformed
* @throws MethodFailedException
* if the expression called a method which failed
* @throws NoSuchPropertyException
* if the expression referred to a nonexistent property
* @throws InappropriateExpressionException
* if the expression can't be used in this context
* @throws OgnlException
* if there is a pathological environmental problem
*/
public static Object getValue(String expression, Object root, Class resultType)
throws OgnlException
{
return getValue(parseExpression(expression), root, resultType);
}
/**
* Evaluates the given OGNL expression tree to insert a value into the object graph rooted at
* the given root object. The default context is set for the given context and root via addDefaultContext().
*
* @param tree
* the OGNL expression tree to evaluate, as returned by parseExpression()
* @param context
* the naming context for the evaluation
* @param root
* the root object for the OGNL expression
* @param value
* the value to insert into the object graph
* @throws MethodFailedException
* if the expression called a method which failed
* @throws NoSuchPropertyException
* if the expression referred to a nonexistent property
* @throws InappropriateExpressionException
* if the expression can't be used in this context
* @throws OgnlException
* if there is a pathological environmental problem
*/
public static void setValue(Object tree, Map context, Object root, Object value)
throws OgnlException
{
OgnlContext ognlContext = (OgnlContext) addDefaultContext(root, context);
Node n = (Node) tree;
if (n.getAccessor() != null) {
n.getAccessor().set(ognlContext, root, value);
return;
}
n.setValue(ognlContext, root, value);
}
/**
* Sets the value given using the pre-compiled expression on the specified root
* object.
*
* @param expression
* The pre-compiled expression, as found in {@link Node#getAccessor()}.
* @param context
* The ognl context.
* @param root
* The object to set the expression value on.
* @param value
* The value to set.
*/
public static void setValue(ExpressionAccessor expression, OgnlContext context,
Object root, Object value)
{
expression.set(context, root, value);
}
/**
* Evaluates the given OGNL expression to insert a value into the object graph rooted at the
* given root object given the context.
*
* @param expression
* the OGNL expression to be parsed
* @param root
* the root object for the OGNL expression
* @param context
* the naming context for the evaluation
* @param value
* the value to insert into the object graph
* @throws MethodFailedException
* if the expression called a method which failed
* @throws NoSuchPropertyException
* if the expression referred to a nonexistent property
* @throws InappropriateExpressionException
* if the expression can't be used in this context
* @throws OgnlException
* if there is a pathological environmental problem
*/
public static void setValue(String expression, Map context, Object root, Object value)
throws OgnlException
{
setValue(parseExpression(expression), context, root, value);
}
/**
* Evaluates the given OGNL expression tree to insert a value into the object graph rooted at
* the given root object.
*
* @param tree
* the OGNL expression tree to evaluate, as returned by parseExpression()
* @param root
* the root object for the OGNL expression
* @param value
* the value to insert into the object graph
* @throws MethodFailedException
* if the expression called a method which failed
* @throws NoSuchPropertyException
* if the expression referred to a nonexistent property
* @throws InappropriateExpressionException
* if the expression can't be used in this context
* @throws OgnlException
* if there is a pathological environmental problem
*/
public static void setValue(Object tree, Object root, Object value)
throws OgnlException
{
setValue(tree, createDefaultContext(root), root, value);
}
/**
* Convenience method that combines calls to parseExpression and
* setValue.
*
* @see #parseExpression(String)
* @see #setValue(Object,Object,Object)
* @param expression
* the OGNL expression to be parsed
* @param root
* the root object for the OGNL expression
* @param value
* the value to insert into the object graph
* @throws ExpressionSyntaxException
* if the expression is malformed
* @throws MethodFailedException
* if the expression called a method which failed
* @throws NoSuchPropertyException
* if the expression referred to a nonexistent property
* @throws InappropriateExpressionException
* if the expression can't be used in this context
* @throws OgnlException
* if there is a pathological environmental problem
*/
public static void setValue(String expression, Object root, Object value)
throws OgnlException
{
setValue(parseExpression(expression), root, value);
}
/**
* Checks if the specified {@link Node} instance represents a constant
* expression.
*
* @param tree
* The {@link Node} to check.
* @param context
* The context to use.
*
* @return True if the node is a constant - false otherwise.
* @throws OgnlException If an error occurs checking the expression.
*/
public static boolean isConstant(Object tree, Map context)
throws OgnlException
{
return ((SimpleNode) tree).isConstant((OgnlContext) addDefaultContext(null, context));
}
/**
* Checks if the specified expression represents a constant expression.
*
* @param expression
* The expression to check.
* @param context
* The context to use.
*
* @return True if the node is a constant - false otherwise.
* @throws OgnlException If an error occurs checking the expression.
*/
public static boolean isConstant(String expression, Map context)
throws OgnlException
{
return isConstant(parseExpression(expression), context);
}
/**
* Same as {@link #isConstant(Object, java.util.Map)} - only the {@link Map} context
* is created for you.
*
* @param tree
* The {@link Node} to check.
*
* @return True if the node represents a constant expression - false otherwise.
* @throws OgnlException If an exception occurs.
*/
public static boolean isConstant(Object tree)
throws OgnlException
{
return isConstant(tree, createDefaultContext(null));
}
/**
* Same as {@link #isConstant(String, java.util.Map)} - only the {@link Map}
* instance is created for you.
*
* @param expression
* The expression to check.
*
* @return True if the expression represents a constant - false otherwise.
* @throws OgnlException If an exception occurs.
*/
public static boolean isConstant(String expression)
throws OgnlException
{
return isConstant(parseExpression(expression), createDefaultContext(null));
}
public static boolean isSimpleProperty(Object tree, Map context)
throws OgnlException
{
return ((SimpleNode) tree).isSimpleProperty((OgnlContext) addDefaultContext(null, context));
}
public static boolean isSimpleProperty(String expression, Map context)
throws OgnlException
{
return isSimpleProperty(parseExpression(expression), context);
}
public static boolean isSimpleProperty(Object tree)
throws OgnlException
{
return isSimpleProperty(tree, createDefaultContext(null));
}
public static boolean isSimpleProperty(String expression)
throws OgnlException
{
return isSimpleProperty(parseExpression(expression), createDefaultContext(null));
}
public static boolean isSimpleNavigationChain(Object tree, Map context)
throws OgnlException
{
return ((SimpleNode) tree).isSimpleNavigationChain((OgnlContext) addDefaultContext(null, context));
}
public static boolean isSimpleNavigationChain(String expression, Map context)
throws OgnlException
{
return isSimpleNavigationChain(parseExpression(expression), context);
}
public static boolean isSimpleNavigationChain(Object tree)
throws OgnlException
{
return isSimpleNavigationChain(tree, createDefaultContext(null));
}
public static boolean isSimpleNavigationChain(String expression)
throws OgnlException
{
return isSimpleNavigationChain(parseExpression(expression), createDefaultContext(null));
}
/** You can't make one of these. */
private Ognl()
{
}
}
ognl-2.7.3.orig/src/java/ognl/ASTLess.java 0000644 0001750 0001750 00000004732 10566476144 020130 0 ustar drazzib drazzib //--------------------------------------------------------------------------
// Copyright (c) 1998-2004, Drew Davidson and Luke Blanshard
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
// Neither the name of the Drew Davidson nor the names of its contributors
// may be used to endorse or promote products derived from this software
// without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
// COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
// OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
// AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
// DAMAGE.
//--------------------------------------------------------------------------
package ognl;
/**
* @author Luke Blanshard (blanshlu@netscape.net)
* @author Drew Davidson (drew@ognl.org)
*/
class ASTLess extends ComparisonExpression
{
public ASTLess(int id) {
super(id);
}
public ASTLess(OgnlParser p, int id) {
super(p, id);
}
protected Object getValueBody( OgnlContext context, Object source ) throws OgnlException
{
Object v1 = _children[0].getValue( context, source );
Object v2 = _children[1].getValue( context, source );
return OgnlOps.less( v1, v2 )? Boolean.TRUE : Boolean.FALSE;
}
public String getExpressionOperator(int index)
{
return "<";
}
public String getComparisonFunction()
{
return "ognl.OgnlOps.less";
}
}
ognl-2.7.3.orig/src/java/ognl/OgnlInvokePermission.java 0000644 0001750 0001750 00000004623 10561411075 022760 0 ustar drazzib drazzib //--------------------------------------------------------------------------
// Copyright (c) 1998-2004, Drew Davidson and Luke Blanshard
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
// Neither the name of the Drew Davidson nor the names of its contributors
// may be used to endorse or promote products derived from this software
// without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
// COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
// OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
// AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
// DAMAGE.
//--------------------------------------------------------------------------
package ognl;
import java.security.*;
/**
* BasicPermission subclass that defines a permission token for invoking
* methods within OGNL. This does not override any methods (except
* constructors) and does not implement actions. It is similar in spirit
* to the {@link java.lang.reflect.ReflectPermission} class in that it
* guards access to methods.
* @author Luke Blanshard (blanshlu@netscape.net)
* @author Drew Davidson (drew@ognl.org)
*/
public class OgnlInvokePermission extends BasicPermission
{
public OgnlInvokePermission(String name)
{
super(name);
}
public OgnlInvokePermission(String name, String actions)
{
super(name, actions);
}
}
ognl-2.7.3.orig/src/java/ognl/IntHashMap.java 0000644 0001750 0001750 00000024704 10561411075 020632 0 ustar drazzib drazzib //--------------------------------------------------------------------------
// Copyright (c) 1998-2004, Drew Davidson and Luke Blanshard
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
// Neither the name of the Drew Davidson nor the names of its contributors
// may be used to endorse or promote products derived from this software
// without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
// COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
// OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
// AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
// DAMAGE.
//--------------------------------------------------------------------------
package ognl;
import java.util.*;
/**
* A Map that uses ints as the keys.
* Use just like any java.util.Map, except that the keys must be ints.
* This is much faster than creating a new Integer for each access.
* For non-Map access (faster) use the put(int, Object) method.
* This class implements Map for convenience, but this is not the most
* efficient usage.
* @see java.util.HashMap
* @see java.util.Map
*/
public class IntHashMap extends Object implements Map
{
private Entry table[];
private int count;
private int threshold;
private float loadFactor;
/*===================================================================
Private static classes
===================================================================*/
private static class IntHashMapIterator implements Iterator
{
boolean keys;
int index;
Entry table[];
Entry entry;
IntHashMapIterator(Entry table[], boolean keys)
{
super();
this.table = table;
this.keys = keys;
this.index = table.length;
}
/*===================================================================
Iterator interface
===================================================================*/
public boolean hasNext()
{
if (entry != null) {
return true;
}
while (index-- > 0) {
if ((entry = table[index]) != null) {
return true;
}
}
return false;
}
public Object next()
{
if (entry == null) {
while ((index-- > 0) && ((entry = table[index]) == null)) {
/* do nothing */
}
}
if (entry != null) {
Entry e = entry;
entry = e.next;
return keys ? new Integer(e.key) : e.value;
}
throw new NoSuchElementException("IntHashMapIterator");
}
public void remove()
{
throw new UnsupportedOperationException("remove");
}
}
/*===================================================================
Public static classes
===================================================================*/
public static class Entry extends Object
{
int hash;
int key;
Object value;
Entry next;
public Entry()
{
super();
}
}
/*===================================================================
Constructors
===================================================================*/
public IntHashMap(int initialCapacity, float loadFactor)
{
super();
if (initialCapacity <= 0 || loadFactor <= 0.0) {
throw new IllegalArgumentException();
}
this.loadFactor = loadFactor;
table = new Entry[initialCapacity];
threshold = (int)(initialCapacity * loadFactor);
}
public IntHashMap(int initialCapacity)
{
this(initialCapacity, 0.75f);
}
public IntHashMap()
{
this(101, 0.75f);
}
/*===================================================================
Protected methods
===================================================================*/
protected void rehash()
{
int oldCapacity = table.length;
Entry oldTable[] = table;
int newCapacity = oldCapacity * 2 + 1;
Entry newTable[] = new Entry[newCapacity];
threshold = (int)(newCapacity * loadFactor);
table = newTable;
for (int i = oldCapacity ; i-- > 0 ;) {
for (Entry old = oldTable[i] ; old != null;) {
Entry e = old;
int index = ( e.hash & 0x7FFFFFFF ) % newCapacity;
old = old.next;
e.next = newTable[index];
newTable[index] = e;
}
}
}
/*===================================================================
Public methods
===================================================================*/
public final boolean containsKey(int key)
{
int index = (key & 0x7FFFFFFF) % table.length;
for (Entry e = table[index] ; e != null ; e = e.next) {
if ((e.hash == key) && (e.key == key)) {
return true;
}
}
return false;
}
public final Object get(int key)
{
int index = (key & 0x7FFFFFFF) % table.length;
for (Entry e = table[index] ; e != null ; e = e.next) {
if ((e.hash == key) && (e.key == key)) {
return e.value;
}
}
return null;
}
public final Object put(int key, Object value)
{
int index = ( key & 0x7FFFFFFF ) % table.length;
if (value == null) {
throw new IllegalArgumentException();
}
for (Entry e = table[index] ; e != null ; e = e.next) {
if ((e.hash == key) && (e.key == key)) {
Object old = e.value;
e.value = value;
return old;
}
}
if (count >= threshold) {
// Rehash the table if the threshold is exceeded.
rehash();
return put(key, value);
}
Entry e = new Entry();
e.hash = key;
e.key = key;
e.value = value;
e.next = table[index];
table[index] = e;
++count;
return null;
}
public final Object remove(int key)
{
int index = (key & 0x7FFFFFFF) % table.length;
for (Entry e = table[index], prev = null ; e != null ; prev = e, e = e.next) {
if ((e.hash == key) && (e.key == key)) {
if ( prev != null ) {
prev.next = e.next;
} else {
table[index] = e.next;
}
--count;
return e.value;
}
}
return null;
}
/*===================================================================
Map interface
===================================================================*/
public int size()
{
return count;
}
public boolean isEmpty()
{
return count == 0;
}
public Object get(Object key)
{
if (!(key instanceof Number)) {
throw new IllegalArgumentException("key is not an Number subclass");
}
return get(((Number)key).intValue());
}
public Object put(Object key, Object value)
{
if (!(key instanceof Number)) {
throw new IllegalArgumentException( "key cannot be null" );
}
return put(((Number)key).intValue(), value );
}
public void putAll(Map otherMap)
{
for (Iterator it = otherMap.keySet().iterator(); it.hasNext();) {
Object k = it.next();
put(k, otherMap.get(k));
}
}
public Object remove(Object key)
{
if (!(key instanceof Number)) {
throw new IllegalArgumentException("key cannot be null");
}
return remove(((Number)key).intValue());
}
public void clear()
{
Entry tab[] = table;
for (int index = tab.length; --index >= 0;) {
tab[index] = null;
}
count = 0;
}
public boolean containsKey(Object key)
{
if (!(key instanceof Number)) {
throw new InternalError( "key is not an Number subclass" );
}
return containsKey(((Number)key).intValue());
}
public boolean containsValue(Object value)
{
Entry tab[] = table;
if (value == null) {
throw new IllegalArgumentException();
}
for (int i = tab.length ; i-- > 0;) {
for (Entry e = tab[i] ; e != null ; e = e.next ) {
if (e.value.equals(value)) {
return true;
}
}
}
return false;
}
public Set keySet()
{
Set result = new HashSet();
for (Iterator it = new IntHashMapIterator(table, true); it.hasNext();) {
result.add(it.next());
}
return result;
}
public Collection values()
{
List result = new ArrayList();
for (Iterator it = new IntHashMapIterator(table, false); it.hasNext();) {
result.add(it.next());
}
return result;
}
public Set entrySet()
{
throw new UnsupportedOperationException("entrySet");
}
}
ognl-2.7.3.orig/src/java/ognl/BooleanExpression.java 0000644 0001750 0001750 00000003162 10646473765 022312 0 ustar drazzib drazzib /**
*
*/
package ognl;
import ognl.enhance.UnsupportedCompilationException;
/**
* Base class for boolean expressions.
*
* @author jkuhnert
*/
public abstract class BooleanExpression extends ExpressionNode implements NodeType
{
protected Class _getterClass;
public BooleanExpression(int id) {
super(id);
}
public BooleanExpression(OgnlParser p, int id) {
super(p, id);
}
public Class getGetterClass()
{
return _getterClass;
}
public Class getSetterClass()
{
return null;
}
public String toGetSourceString(OgnlContext context, Object target)
{
try {
Object value = getValueBody(context, target);
if (value != null && Boolean.class.isAssignableFrom(value.getClass()))
_getterClass = Boolean.TYPE;
else if (value != null)
_getterClass = value.getClass();
else
_getterClass = Boolean.TYPE;
String ret = super.toGetSourceString(context, target);
if ("(false)".equals(ret))
return "false";
else if ("(true)".equals(ret))
return "true";
return ret;
} catch (NullPointerException e) {
// expected to happen in some instances
e.printStackTrace();
throw new UnsupportedCompilationException("evaluation resulted in null expression.");
} catch (Throwable t)
{
throw OgnlOps.castToRuntime(t);
}
}
}
ognl-2.7.3.orig/src/java/ognl/ASTAnd.java 0000644 0001750 0001750 00000014650 10655154670 017720 0 ustar drazzib drazzib //--------------------------------------------------------------------------
// Copyright (c) 1998-2004, Drew Davidson and Luke Blanshard
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
// Neither the name of the Drew Davidson nor the names of its contributors
// may be used to endorse or promote products derived from this software
// without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
// COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
// OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
// AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
// DAMAGE.
//--------------------------------------------------------------------------
package ognl;
import ognl.enhance.ExpressionCompiler;
import ognl.enhance.UnsupportedCompilationException;
/**
* @author Luke Blanshard (blanshlu@netscape.net)
* @author Drew Davidson (drew@ognl.org)
*/
public class ASTAnd extends BooleanExpression
{
public ASTAnd(int id) {
super(id);
}
public ASTAnd(OgnlParser p, int id) {
super(p, id);
}
public void jjtClose() {
flattenTree();
}
protected Object getValueBody( OgnlContext context, Object source )
throws OgnlException
{
Object result = null;
int last = _children.length - 1;
for ( int i=0; i <= last; ++i )
{
result = _children[i].getValue( context, source );
if ( i != last && ! OgnlOps.booleanValue(result) )
break;
}
return result;
}
protected void setValueBody( OgnlContext context, Object target, Object value )
throws OgnlException
{
int last = _children.length - 1;
for ( int i=0; i < last; ++i )
{
Object v = _children[i].getValue( context, target );
if ( ! OgnlOps.booleanValue(v) )
return;
}
_children[last].setValue( context, target, value );
}
public String getExpressionOperator(int index)
{
return "&&";
}
public Class getGetterClass()
{
return null;
}
public String toGetSourceString(OgnlContext context, Object target)
{
if (_children.length != 2)
throw new UnsupportedCompilationException("Can only compile boolean expressions with two children.");
String result = "";
try {
String first = OgnlRuntime.getChildSource(context, target, _children[0]);
if (!OgnlOps.booleanValue(context.getCurrentObject()))
{
throw new UnsupportedCompilationException("And expression can't be compiled until all conditions are true.");
}
if (!OgnlRuntime.isBoolean(first) && !context.getCurrentType().isPrimitive())
first = OgnlRuntime.getCompiler().createLocalReference(context, first, context.getCurrentType());
String second = OgnlRuntime.getChildSource(context, target, _children[1]);
if (!OgnlRuntime.isBoolean(second) && !context.getCurrentType().isPrimitive())
second = OgnlRuntime.getCompiler().createLocalReference(context, second, context.getCurrentType());
result += "(ognl.OgnlOps.booleanValue(" + first + ")";
result += " ? ";
result += " ($w) (" + second + ")";
result += " : ";
result += " ($w) (" + first + ")";
result += ")";
context.setCurrentObject(target);
context.setCurrentType(Object.class);
} catch (NullPointerException e) {
throw new UnsupportedCompilationException("evaluation resulted in null expression.");
} catch (Throwable t)
{
throw OgnlOps.castToRuntime(t);
}
return result;
}
public String toSetSourceString(OgnlContext context, Object target)
{
if (_children.length != 2)
throw new UnsupportedCompilationException("Can only compile boolean expressions with two children.");
String pre = (String)context.get("_currentChain");
if (pre == null)
pre = "";
String result = "";
try {
if (!OgnlOps.booleanValue(_children[0].getValue(context, target)))
{
throw new UnsupportedCompilationException("And expression can't be compiled until all conditions are true.");
}
String first = ExpressionCompiler.getRootExpression(_children[0], context.getRoot(), context)
+ pre + _children[0].toGetSourceString(context, target);
_children[1].getValue(context, target);
String second = ExpressionCompiler.getRootExpression(_children[1], context.getRoot(), context)
+ pre + _children[1].toSetSourceString(context, target);
if (!OgnlRuntime.isBoolean(first))
result += "if(ognl.OgnlOps.booleanValue(" + first + ")){";
else
result += "if(" + first + "){";
result += second;
result += "; } ";
context.setCurrentObject(target);
context.setCurrentType(Object.class);
} catch (Throwable t)
{
throw OgnlOps.castToRuntime(t);
}
return result;
}
}
ognl-2.7.3.orig/src/java/ognl/OgnlRuntime.java 0000644 0001750 0001750 00000306333 10744211276 021106 0 ustar drazzib drazzib // --------------------------------------------------------------------------
// Copyright (c) 1998-2004, Drew Davidson and Luke Blanshard
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
// Neither the name of the Drew Davidson nor the names of its contributors
// may be used to endorse or promote products derived from this software
// without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
// COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
// OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
// AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
// DAMAGE.
// --------------------------------------------------------------------------
package ognl;
import ognl.enhance.ExpressionCompiler;
import ognl.enhance.OgnlExpressionCompiler;
import ognl.internal.ClassCache;
import ognl.internal.ClassCacheImpl;
import java.beans.*;
import java.lang.reflect.*;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.security.Permission;
import java.util.*;
/**
* Utility class used by internal OGNL API to do various things like:
*
*
* Handles majority of reflection logic / caching.
* Utility methods for casting strings / various numeric types used by {@link OgnlExpressionCompiler}.Core runtime configuration point for setting/using global {@link TypeConverter} / {@link OgnlExpressionCompiler} /
* {@link NullHandler} instances / etc..
*
*
* @author Luke Blanshard (blanshlu@netscape.net)
* @author Drew Davidson (drew@ognl.org)
*/
public class OgnlRuntime {
/**
* Constant expression used to indicate that a given method / property couldn't be found
* during reflection operations.
*/
public static final Object NotFound = new Object();
public static final List NotFoundList = new ArrayList();
public static final Map NotFoundMap = new HashMap();
public static final Object[] NoArguments = new Object[]{};
public static final Class[] NoArgumentTypes = new Class[]{};
/**
* Token returned by TypeConverter for no conversion possible
*/
public static final Object NoConversionPossible = "ognl.NoConversionPossible";
/**
* Not an indexed property
*/
public static int INDEXED_PROPERTY_NONE = 0;
/**
* JavaBeans IndexedProperty
*/
public static int INDEXED_PROPERTY_INT = 1;
/**
* OGNL ObjectIndexedProperty
*/
public static int INDEXED_PROPERTY_OBJECT = 2;
/**
* Constant string representation of null string.
*/
public static final String NULL_STRING = "" + null;
/**
* Java beans standard set method prefix.
*/
private static final String SET_PREFIX = "set";
/**
* Java beans standard get method prefix.
*/
private static final String GET_PREFIX = "get";
/**
* Java beans standard is boolean getter prefix.
*/
private static final String IS_PREFIX = "is";
/**
* Prefix padding for hexadecimal numbers to HEX_LENGTH.
*/
private static final Map HEX_PADDING = new HashMap();
private static final int HEX_LENGTH = 8;
/**
* Returned by getUniqueDescriptor() when the object is null.
*/
private static final String NULL_OBJECT_STRING = "";
/**
* Used to store the result of determining if current jvm is 1.5 language compatible.
*/
private static boolean _jdk15 = false;
private static boolean _jdkChecked = false;
static final ClassCache _methodAccessors = new ClassCacheImpl();
static final ClassCache _propertyAccessors = new ClassCacheImpl();
static final ClassCache _elementsAccessors = new ClassCacheImpl();
static final ClassCache _nullHandlers = new ClassCacheImpl();
static final ClassCache _propertyDescriptorCache = new ClassCacheImpl();
static final ClassCache _constructorCache = new ClassCacheImpl();
static final ClassCache _staticMethodCache = new ClassCacheImpl();
static final ClassCache _instanceMethodCache = new ClassCacheImpl();
static final ClassCache _invokePermissionCache = new ClassCacheImpl();
static final ClassCache _fieldCache = new ClassCacheImpl();
static final List _superclasses = new ArrayList(); /* Used by fieldCache lookup */
static final ClassCache[] _declaredMethods = new ClassCache[]{new ClassCacheImpl(), new ClassCacheImpl()};
static final Map _primitiveTypes = new HashMap(101);
static final ClassCache _primitiveDefaults = new ClassCacheImpl();
static final Map _methodParameterTypesCache = new HashMap(101);
static final Map _genericMethodParameterTypesCache = new HashMap(101);
static final Map _ctorParameterTypesCache = new HashMap(101);
static SecurityManager _securityManager = System.getSecurityManager();
static final EvaluationPool _evaluationPool = new EvaluationPool();
static final ObjectArrayPool _objectArrayPool = new ObjectArrayPool();
static final IntHashMap _methodAccessCache = new IntHashMap();
static final IntHashMap _methodPermCache = new IntHashMap();
static ClassCacheInspector _cacheInspector;
/**
* Expression compiler used by {@link Ognl#compileExpression(OgnlContext, Object, String)} calls.
*/
private static OgnlExpressionCompiler _compiler = new ExpressionCompiler();
private static IdentityHashMap PRIMITIVE_WRAPPER_CLASSES = new IdentityHashMap();
/**
* Used to provide primitive type equivalent conversions into and out of
* native / object types.
*/
static {
PRIMITIVE_WRAPPER_CLASSES.put(Boolean.TYPE, Boolean.class);
PRIMITIVE_WRAPPER_CLASSES.put(Boolean.class, Boolean.TYPE);
PRIMITIVE_WRAPPER_CLASSES.put(Byte.TYPE, Byte.class);
PRIMITIVE_WRAPPER_CLASSES.put(Byte.class, Byte.TYPE);
PRIMITIVE_WRAPPER_CLASSES.put(Character.TYPE, Character.class);
PRIMITIVE_WRAPPER_CLASSES.put(Character.class, Character.TYPE);
PRIMITIVE_WRAPPER_CLASSES.put(Short.TYPE, Short.class);
PRIMITIVE_WRAPPER_CLASSES.put(Short.class, Short.TYPE);
PRIMITIVE_WRAPPER_CLASSES.put(Integer.TYPE, Integer.class);
PRIMITIVE_WRAPPER_CLASSES.put(Integer.class, Integer.TYPE);
PRIMITIVE_WRAPPER_CLASSES.put(Long.TYPE, Long.class);
PRIMITIVE_WRAPPER_CLASSES.put(Long.class, Long.TYPE);
PRIMITIVE_WRAPPER_CLASSES.put(Float.TYPE, Float.class);
PRIMITIVE_WRAPPER_CLASSES.put(Float.class, Float.TYPE);
PRIMITIVE_WRAPPER_CLASSES.put(Double.TYPE, Double.class);
PRIMITIVE_WRAPPER_CLASSES.put(Double.class, Double.TYPE);
}
private static final Map NUMERIC_CASTS = new HashMap();
/**
* Constant strings for casting different primitive types.
*/
static {
NUMERIC_CASTS.put(Double.class, "(double)");
NUMERIC_CASTS.put(Float.class, "(float)");
NUMERIC_CASTS.put(Integer.class, "(int)");
NUMERIC_CASTS.put(Long.class, "(long)");
NUMERIC_CASTS.put(BigDecimal.class, "(double)");
NUMERIC_CASTS.put(BigInteger.class, "");
}
private static final Map NUMERIC_VALUES = new HashMap();
/**
* Constant strings for getting the primitive value of different
* native types on the generic {@link Number} object interface. (or the less
* generic BigDecimal/BigInteger types)
*/
static {
NUMERIC_VALUES.put(Double.class, "doubleValue()");
NUMERIC_VALUES.put(Float.class, "floatValue()");
NUMERIC_VALUES.put(Integer.class, "intValue()");
NUMERIC_VALUES.put(Long.class, "longValue()");
NUMERIC_VALUES.put(Short.class, "shortValue()");
NUMERIC_VALUES.put(Byte.class, "byteValue()");
NUMERIC_VALUES.put(BigDecimal.class, "doubleValue()");
NUMERIC_VALUES.put(BigInteger.class, "doubleValue()");
NUMERIC_VALUES.put(Boolean.class, "booleanValue()");
}
private static final Map NUMERIC_LITERALS = new HashMap();
/**
* Numeric primitive literal string expressions.
*/
static {
NUMERIC_LITERALS.put(Integer.class, "");
NUMERIC_LITERALS.put(Integer.TYPE, "");
NUMERIC_LITERALS.put(Long.class, "l");
NUMERIC_LITERALS.put(Long.TYPE, "l");
NUMERIC_LITERALS.put(BigInteger.class, "d");
NUMERIC_LITERALS.put(Float.class, "f");
NUMERIC_LITERALS.put(Float.TYPE, "f");
NUMERIC_LITERALS.put(Double.class, "d");
NUMERIC_LITERALS.put(Double.TYPE, "d");
NUMERIC_LITERALS.put(BigInteger.class, "d");
NUMERIC_LITERALS.put(BigDecimal.class, "d");
}
private static final Map NUMERIC_DEFAULTS = new HashMap();
static {
NUMERIC_DEFAULTS.put(Boolean.class, Boolean.FALSE);
NUMERIC_DEFAULTS.put(Byte.class, new Byte((byte) 0));
NUMERIC_DEFAULTS.put(Short.class, new Short((short) 0));
NUMERIC_DEFAULTS.put(Character.class, new Character((char) 0));
NUMERIC_DEFAULTS.put(Integer.class, new Integer(0));
NUMERIC_DEFAULTS.put(Long.class, new Long(0L));
NUMERIC_DEFAULTS.put(Float.class, new Float(0.0f));
NUMERIC_DEFAULTS.put(Double.class, new Double(0.0));
NUMERIC_DEFAULTS.put(BigInteger.class, new BigInteger("0"));
NUMERIC_DEFAULTS.put(BigDecimal.class, new BigDecimal(0.0));
}
static {
PropertyAccessor p = new ArrayPropertyAccessor();
setPropertyAccessor(Object.class, new ObjectPropertyAccessor());
setPropertyAccessor(byte[].class, p);
setPropertyAccessor(short[].class, p);
setPropertyAccessor(char[].class, p);
setPropertyAccessor(int[].class, p);
setPropertyAccessor(long[].class, p);
setPropertyAccessor(float[].class, p);
setPropertyAccessor(double[].class, p);
setPropertyAccessor(Object[].class, p);
setPropertyAccessor(List.class, new ListPropertyAccessor());
setPropertyAccessor(Map.class, new MapPropertyAccessor());
setPropertyAccessor(Set.class, new SetPropertyAccessor());
setPropertyAccessor(Iterator.class, new IteratorPropertyAccessor());
setPropertyAccessor(Enumeration.class, new EnumerationPropertyAccessor());
ElementsAccessor e = new ArrayElementsAccessor();
setElementsAccessor(Object.class, new ObjectElementsAccessor());
setElementsAccessor(byte[].class, e);
setElementsAccessor(short[].class, e);
setElementsAccessor(char[].class, e);
setElementsAccessor(int[].class, e);
setElementsAccessor(long[].class, e);
setElementsAccessor(float[].class, e);
setElementsAccessor(double[].class, e);
setElementsAccessor(Object[].class, e);
setElementsAccessor(Collection.class, new CollectionElementsAccessor());
setElementsAccessor(Map.class, new MapElementsAccessor());
setElementsAccessor(Iterator.class, new IteratorElementsAccessor());
setElementsAccessor(Enumeration.class, new EnumerationElementsAccessor());
setElementsAccessor(Number.class, new NumberElementsAccessor());
NullHandler nh = new ObjectNullHandler();
setNullHandler(Object.class, nh);
setNullHandler(byte[].class, nh);
setNullHandler(short[].class, nh);
setNullHandler(char[].class, nh);
setNullHandler(int[].class, nh);
setNullHandler(long[].class, nh);
setNullHandler(float[].class, nh);
setNullHandler(double[].class, nh);
setNullHandler(Object[].class, nh);
MethodAccessor ma = new ObjectMethodAccessor();
setMethodAccessor(Object.class, ma);
setMethodAccessor(byte[].class, ma);
setMethodAccessor(short[].class, ma);
setMethodAccessor(char[].class, ma);
setMethodAccessor(int[].class, ma);
setMethodAccessor(long[].class, ma);
setMethodAccessor(float[].class, ma);
setMethodAccessor(double[].class, ma);
setMethodAccessor(Object[].class, ma);
_primitiveTypes.put("boolean", Boolean.TYPE);
_primitiveTypes.put("byte", Byte.TYPE);
_primitiveTypes.put("short", Short.TYPE);
_primitiveTypes.put("char", Character.TYPE);
_primitiveTypes.put("int", Integer.TYPE);
_primitiveTypes.put("long", Long.TYPE);
_primitiveTypes.put("float", Float.TYPE);
_primitiveTypes.put("double", Double.TYPE);
_primitiveDefaults.put(Boolean.TYPE, Boolean.FALSE);
_primitiveDefaults.put(Boolean.class, Boolean.FALSE);
_primitiveDefaults.put(Byte.TYPE, new Byte((byte) 0));
_primitiveDefaults.put(Byte.class, new Byte((byte) 0));
_primitiveDefaults.put(Short.TYPE, new Short((short) 0));
_primitiveDefaults.put(Short.class, new Short((short) 0));
_primitiveDefaults.put(Character.TYPE, new Character((char) 0));
_primitiveDefaults.put(Integer.TYPE, new Integer(0));
_primitiveDefaults.put(Long.TYPE, new Long(0L));
_primitiveDefaults.put(Float.TYPE, new Float(0.0f));
_primitiveDefaults.put(Double.TYPE, new Double(0.0));
_primitiveDefaults.put(BigInteger.class, new BigInteger("0"));
_primitiveDefaults.put(BigDecimal.class, new BigDecimal(0.0));
}
/**
* Clears all of the cached reflection information normally used
* to improve the speed of expressions that operate on the same classes
* or are executed multiple times.
*
*
* Warning: Calling this too often can be a huge performance
* drain on your expressions - use with care.
*
*/
public static void clearCache()
{
_methodParameterTypesCache.clear();
_ctorParameterTypesCache.clear();
_propertyDescriptorCache.clear();
_constructorCache.clear();
_staticMethodCache.clear();
_instanceMethodCache.clear();
_invokePermissionCache.clear();
_fieldCache.clear();
_superclasses.clear();
_declaredMethods[0].clear();
_declaredMethods[1].clear();
_methodAccessCache.clear();
}
/**
* Checks if the current jvm is java language >= 1.5 compatible.
*
* @return True if jdk15 features are present.
*/
public static boolean isJdk15()
{
if (_jdkChecked)
return _jdk15;
try
{
Class.forName("java.lang.annotation.Annotation");
_jdk15 = true;
} catch (Exception e) { /* ignore */ }
_jdkChecked = true;
return _jdk15;
}
public static String getNumericValueGetter(Class type)
{
return (String) NUMERIC_VALUES.get(type);
}
public static Class getPrimitiveWrapperClass(Class primitiveClass)
{
return (Class) PRIMITIVE_WRAPPER_CLASSES.get(primitiveClass);
}
public static String getNumericCast(Class type)
{
return (String) NUMERIC_CASTS.get(type);
}
public static String getNumericLiteral(Class type)
{
return (String) NUMERIC_LITERALS.get(type);
}
public static void setCompiler(OgnlExpressionCompiler compiler)
{
_compiler = compiler;
}
public static OgnlExpressionCompiler getCompiler()
{
return _compiler;
}
public static void compileExpression(OgnlContext context, Node expression, Object root)
throws Exception
{
_compiler.compileExpression(context, expression, root);
}
/**
* Gets the "target" class of an object for looking up accessors that are registered on the
* target. If the object is a Class object this will return the Class itself, else it will
* return object's getClass() result.
*/
public static Class getTargetClass(Object o)
{
return (o == null) ? null : ((o instanceof Class) ? (Class) o : o.getClass());
}
/**
* Returns the base name (the class name without the package name prepended) of the object
* given.
*/
public static String getBaseName(Object o)
{
return (o == null) ? null : getClassBaseName(o.getClass());
}
/**
* Returns the base name (the class name without the package name prepended) of the class given.
*/
public static String getClassBaseName(Class c)
{
String s = c.getName();
return s.substring(s.lastIndexOf('.') + 1);
}
public static String getClassName(Object o, boolean fullyQualified)
{
if (!(o instanceof Class))
{
o = o.getClass();
}
return getClassName((Class) o, fullyQualified);
}
public static String getClassName(Class c, boolean fullyQualified)
{
return fullyQualified ? c.getName() : getClassBaseName(c);
}
/**
* Returns the package name of the object's class.
*/
public static String getPackageName(Object o)
{
return (o == null) ? null : getClassPackageName(o.getClass());
}
/**
* Returns the package name of the class given.
*/
public static String getClassPackageName(Class c)
{
String s = c.getName();
int i = s.lastIndexOf('.');
return (i < 0) ? null : s.substring(0, i);
}
/**
* Returns a "pointer" string in the usual format for these things - 0x.
*/
public static String getPointerString(int num)
{
StringBuffer result = new StringBuffer();
String hex = Integer.toHexString(num), pad;
Integer l = new Integer(hex.length());
// result.append(HEX_PREFIX);
if ((pad = (String) HEX_PADDING.get(l)) == null) {
StringBuffer pb = new StringBuffer();
for (int i = hex.length(); i < HEX_LENGTH; i++) {
pb.append('0');
}
pad = new String(pb);
HEX_PADDING.put(l, pad);
}
result.append(pad);
result.append(hex);
return new String(result);
}
/**
* Returns a "pointer" string in the usual format for these things - 0x for the
* object given. This will always return a unique value for each object.
*/
public static String getPointerString(Object o)
{
return getPointerString((o == null) ? 0 : System.identityHashCode(o));
}
/**
* Returns a unique descriptor string that includes the object's class and a unique integer
* identifier. If fullyQualified is true then the class name will be fully qualified to include
* the package name, else it will be just the class' base name.
*/
public static String getUniqueDescriptor(Object object, boolean fullyQualified)
{
StringBuffer result = new StringBuffer();
if (object != null) {
if (object instanceof Proxy) {
Class interfaceClass = object.getClass().getInterfaces()[0];
result.append(getClassName(interfaceClass, fullyQualified));
result.append('^');
object = Proxy.getInvocationHandler(object);
}
result.append(getClassName(object, fullyQualified));
result.append('@');
result.append(getPointerString(object));
} else {
result.append(NULL_OBJECT_STRING);
}
return new String(result);
}
/**
* Returns a unique descriptor string that includes the object's class' base name and a unique
* integer identifier.
*/
public static String getUniqueDescriptor(Object object)
{
return getUniqueDescriptor(object, false);
}
/**
* Utility to convert a List into an Object[] array. If the list is zero elements this will
* return a constant array; toArray() on List always returns a new object and this is wasteful
* for our purposes.
*/
public static Object[] toArray(List list)
{
Object[] result;
int size = list.size();
if (size == 0) {
result = NoArguments;
} else {
result = getObjectArrayPool().create(list.size());
for (int i = 0; i < size; i++) {
result[i] = list.get(i);
}
}
return result;
}
/**
* Returns the parameter types of the given method.
*/
public static Class[] getParameterTypes(Method m)
{
synchronized (_methodParameterTypesCache)
{
Class[] result;
if ((result = (Class[]) _methodParameterTypesCache.get(m)) == null)
{
_methodParameterTypesCache.put(m, result = m.getParameterTypes());
}
return result;
}
}
/**
* Finds the appropriate parameter types for the given {@link Method} and
* {@link Class} instance of the type the method is associated with. Correctly
* finds generic types if running in >= 1.5 jre as well.
*
* @param type The class type the method is being executed against.
* @param m The method to find types for.
* @return Array of parameter types for the given method.
*/
public static Class[] findParameterTypes(Class type, Method m)
{
if (type == null)
{
return getParameterTypes(m);
}
if (!isJdk15()
|| type.getGenericSuperclass() == null
|| !ParameterizedType.class.isInstance(type.getGenericSuperclass())
|| m.getDeclaringClass().getTypeParameters() == null)
{
return getParameterTypes(m);
}
synchronized (_genericMethodParameterTypesCache)
{
Class[] types;
if ((types = (Class[]) _genericMethodParameterTypesCache.get(m)) != null)
{
return types;
}
ParameterizedType param = (ParameterizedType)type.getGenericSuperclass();
Type[] genTypes = m.getGenericParameterTypes();
TypeVariable[] declaredTypes = m.getDeclaringClass().getTypeParameters();
types = new Class[genTypes.length];
typeSearch:
for (int i=0; i < genTypes.length; i++)
{
TypeVariable paramType = null;
if (TypeVariable.class.isInstance(genTypes[i]))
{
paramType = (TypeVariable)genTypes[i];
} else if (GenericArrayType.class.isInstance(genTypes[i]))
{
paramType = (TypeVariable) ((GenericArrayType)genTypes[i]).getGenericComponentType();
} else if (Class.class.isInstance(genTypes[i]))
{
types[i] = (Class) genTypes[i];
continue;
}
Class resolved = resolveType(param, paramType, declaredTypes);
if (resolved != null)
{
if (GenericArrayType.class.isInstance(genTypes[i]))
{
resolved = Array.newInstance(resolved, 0).getClass();
}
types[i] = resolved;
continue;
}
types[i] = m.getParameterTypes()[i];
}
_genericMethodParameterTypesCache.put(m, types);
return types;
}
}
static Class resolveType(ParameterizedType param, TypeVariable var, TypeVariable[] declaredTypes)
{
if (param.getActualTypeArguments().length < 1)
return null;
for (int i=0; i < declaredTypes.length; i++)
{
if (!TypeVariable.class.isInstance( param.getActualTypeArguments()[i])
&& declaredTypes[i].getName().equals(var.getName()))
{
return (Class) param.getActualTypeArguments()[i];
}
}
/*
for (int i=0; i < var.getBounds().length; i++)
{
Type t = var.getBounds()[i];
Class resolvedType = null;
if (ParameterizedType.class.isInstance(t))
{
ParameterizedType pparam = (ParameterizedType)t;
for (int e=0; e < pparam.getActualTypeArguments().length; e++)
{
if (!TypeVariable.class.isInstance(pparam.getActualTypeArguments()[e]))
continue;
resolvedType = resolveType(pparam, (TypeVariable)pparam.getActualTypeArguments()[e], declaredTypes);
}
} else
{
resolvedType = findType(param.getActualTypeArguments(), (Class)t);
}
if (resolvedType != null)
return resolvedType;
}
*/
return null;
}
static Class findType(Type[] types, Class type)
{
for (int i = 0; i < types.length; i++)
{
if (Class.class.isInstance(types[i]) && type.isAssignableFrom((Class)types[i]))
return (Class)types[i];
}
return null;
}
/**
* Returns the parameter types of the given method.
*/
public static Class[] getParameterTypes(Constructor c)
{
synchronized (_ctorParameterTypesCache) {
Class[] result;
if ((result = (Class[]) _ctorParameterTypesCache.get(c)) == null) {
_ctorParameterTypesCache.put(c, result = c.getParameterTypes());
}
return result;
}
}
/**
* Gets the SecurityManager that OGNL uses to determine permissions for invoking methods.
*
* @return SecurityManager for OGNL
*/
public static SecurityManager getSecurityManager()
{
return _securityManager;
}
/**
* Sets the SecurityManager that OGNL uses to determine permissions for invoking methods.
*
* @param value SecurityManager to set
*/
public static void setSecurityManager(SecurityManager value)
{
_securityManager = value;
}
/**
* Permission will be named "invoke..".
*/
public static Permission getPermission(Method method)
{
Permission result = null;
Class mc = method.getDeclaringClass();
synchronized (_invokePermissionCache) {
Map permissions = (Map) _invokePermissionCache.get(mc);
if (permissions == null) {
_invokePermissionCache.put(mc, permissions = new HashMap(101));
}
if ((result = (Permission) permissions.get(method.getName())) == null) {
result = new OgnlInvokePermission("invoke." + mc.getName() + "." + method.getName());
permissions.put(method.getName(), result);
}
}
return result;
}
public static Object invokeMethod(Object target, Method method, Object[] argsArray)
throws InvocationTargetException, IllegalAccessException
{
boolean syncInvoke = false;
boolean checkPermission = false;
int mHash = method.hashCode();
// only synchronize method invocation if it actually requires it
synchronized(method) {
if (_methodAccessCache.get(mHash) == null
|| _methodAccessCache.get(mHash) == Boolean.TRUE) {
syncInvoke = true;
}
if (_securityManager != null && _methodPermCache.get(mHash) == null
|| _methodPermCache.get(mHash) == Boolean.FALSE) {
checkPermission = true;
}
}
Object result;
boolean wasAccessible = true;
if (syncInvoke)
{
synchronized(method)
{
if (checkPermission)
{
try
{
_securityManager.checkPermission(getPermission(method));
_methodPermCache.put(mHash, Boolean.TRUE);
} catch (SecurityException ex) {
_methodPermCache.put(mHash, Boolean.FALSE);
throw new IllegalAccessException("Method [" + method + "] cannot be accessed.");
}
}
if (!Modifier.isPublic(method.getModifiers()) || !Modifier.isPublic(method.getDeclaringClass().getModifiers()))
{
if (!(wasAccessible = ((AccessibleObject) method).isAccessible()))
{
((AccessibleObject) method).setAccessible(true);
_methodAccessCache.put(mHash, Boolean.TRUE);
} else
{
_methodAccessCache.put(mHash, Boolean.FALSE);
}
} else
{
_methodAccessCache.put(mHash, Boolean.FALSE);
}
result = method.invoke(target, argsArray);
if (!wasAccessible)
{
((AccessibleObject) method).setAccessible(false);
}
}
} else
{
if (checkPermission)
{
try
{
_securityManager.checkPermission(getPermission(method));
_methodPermCache.put(mHash, Boolean.TRUE);
} catch (SecurityException ex) {
_methodPermCache.put(mHash, Boolean.FALSE);
throw new IllegalAccessException("Method [" + method + "] cannot be accessed.");
}
}
result = method.invoke(target, argsArray);
}
return result;
}
/**
* Gets the class for a method argument that is appropriate for looking up methods by
* reflection, by looking for the standard primitive wrapper classes and exchanging for them
* their underlying primitive class objects. Other classes are passed through unchanged.
*
* @param arg an object that is being passed to a method
* @return the class to use to look up the method
*/
public static final Class getArgClass(Object arg)
{
if (arg == null)
return null;
Class c = arg.getClass();
if (c == Boolean.class)
return Boolean.TYPE;
else if (c.getSuperclass() == Number.class) {
if (c == Integer.class)
return Integer.TYPE;
if (c == Double.class)
return Double.TYPE;
if (c == Byte.class)
return Byte.TYPE;
if (c == Long.class)
return Long.TYPE;
if (c == Float.class)
return Float.TYPE;
if (c == Short.class)
return Short.TYPE;
} else if (c == Character.class)
return Character.TYPE;
return c;
}
/**
* Tells whether the given object is compatible with the given class ---that is, whether the
* given object can be passed as an argument to a method or constructor whose parameter type is
* the given class. If object is null this will return true because null is compatible with any
* type.
*/
public static final boolean isTypeCompatible(Object object, Class c)
{
boolean result = true;
if (object != null) {
if (c.isPrimitive()) {
if (getArgClass(object) != c) {
result = false;
}
} else if (!c.isInstance(object)) {
result = false;
}
}
return result;
}
/**
* Tells whether the given array of objects is compatible with the given array of classes---that
* is, whether the given array of objects can be passed as arguments to a method or constructor
* whose parameter types are the given array of classes.
*/
public static boolean areArgsCompatible(Object[] args, Class[] classes)
{
return areArgsCompatible(args, classes, null);
}
public static boolean areArgsCompatible(Object[] args, Class[] classes, Method m)
{
boolean result = true;
boolean varArgs = m != null && isJdk15() && m.isVarArgs();
if (args.length != classes.length && !varArgs) {
result = false;
} else if (varArgs) {
for (int index = 0, count = args.length; result && (index < count); ++index) {
if (index >= classes.length){
break;
}
result = isTypeCompatible(args[index], classes[index]);
if (!result && classes[index].isArray()) {
result = isTypeCompatible(args[index], classes[index].getComponentType());
}
}
} else {
for (int index = 0, count = args.length; result && (index < count); ++index) {
result = isTypeCompatible(args[index], classes[index]);
}
}
return result;
}
/**
* Tells whether the first array of classes is more specific than the second. Assumes that the
* two arrays are of the same length.
*/
public static final boolean isMoreSpecific(Class[] classes1, Class[] classes2)
{
for (int index = 0, count = classes1.length; index < count; ++index) {
Class c1 = classes1[index], c2 = classes2[index];
if (c1 == c2)
continue;
else if (c1.isPrimitive())
return true;
else if (c1.isAssignableFrom(c2))
return false;
else if (c2.isAssignableFrom(c1))
return true;
}
// They are the same! So the first is not more specific than the second.
return false;
}
public static String getModifierString(int modifiers)
{
String result;
if (Modifier.isPublic(modifiers))
result = "public";
else if (Modifier.isProtected(modifiers))
result = "protected";
else if (Modifier.isPrivate(modifiers))
result = "private";
else
result = "";
if (Modifier.isStatic(modifiers))
result = "static " + result;
if (Modifier.isFinal(modifiers))
result = "final " + result;
if (Modifier.isNative(modifiers))
result = "native " + result;
if (Modifier.isSynchronized(modifiers))
result = "synchronized " + result;
if (Modifier.isTransient(modifiers))
result = "transient " + result;
return result;
}
public static Class classForName(OgnlContext context, String className)
throws ClassNotFoundException
{
Class result = (Class) _primitiveTypes.get(className);
if (result == null) {
ClassResolver resolver;
if ((context == null) || ((resolver = context.getClassResolver()) == null)) {
resolver = OgnlContext.DEFAULT_CLASS_RESOLVER;
}
result = resolver.classForName(className, context);
}
if (result == null)
throw new ClassNotFoundException("Unable to resolve class: " + className);
return result;
}
public static boolean isInstance(OgnlContext context, Object value, String className)
throws OgnlException
{
try {
Class c = classForName(context, className);
return c.isInstance(value);
} catch (ClassNotFoundException e) {
throw new OgnlException("No such class: " + className, e);
}
}
public static Object getPrimitiveDefaultValue(Class forClass)
{
return _primitiveDefaults.get(forClass);
}
public static Object getNumericDefaultValue(Class forClass)
{
return NUMERIC_DEFAULTS.get(forClass);
}
public static Object getConvertedType(OgnlContext context, Object target, Member member, String propertyName,
Object value, Class type)
{
return context.getTypeConverter().convertValue(context, target, member, propertyName, value, type);
}
public static boolean getConvertedTypes(OgnlContext context, Object target, Member member, String propertyName,
Class[] parameterTypes, Object[] args, Object[] newArgs)
{
boolean result = false;
if (parameterTypes.length == args.length) {
result = true;
for (int i = 0, ilast = parameterTypes.length - 1; result && (i <= ilast); i++) {
Object arg = args[i];
Class type = parameterTypes[i];
if (isTypeCompatible(arg, type)) {
newArgs[i] = arg;
} else {
Object v = getConvertedType(context, target, member, propertyName, arg, type);
if (v == OgnlRuntime.NoConversionPossible) {
result = false;
} else {
newArgs[i] = v;
}
}
}
}
return result;
}
public static Method getConvertedMethodAndArgs(OgnlContext context, Object target, String propertyName,
List methods, Object[] args, Object[] newArgs)
{
Method result = null;
TypeConverter converter = context.getTypeConverter();
if ((converter != null) && (methods != null))
{
for (int i = 0, icount = methods.size(); (result == null) && (i < icount); i++)
{
Method m = (Method) methods.get(i);
Class[] parameterTypes = findParameterTypes(target != null ? target.getClass() : null, m);//getParameterTypes(m);
if (getConvertedTypes(context, target, m, propertyName, parameterTypes, args, newArgs))
{
result = m;
}
}
}
return result;
}
public static Constructor getConvertedConstructorAndArgs(OgnlContext context, Object target, List constructors,
Object[] args, Object[] newArgs)
{
Constructor result = null;
TypeConverter converter = context.getTypeConverter();
if ((converter != null) && (constructors != null)) {
for (int i = 0, icount = constructors.size(); (result == null) && (i < icount); i++) {
Constructor ctor = (Constructor) constructors.get(i);
Class[] parameterTypes = getParameterTypes(ctor);
if (getConvertedTypes(context, target, ctor, null, parameterTypes, args, newArgs)) {
result = ctor;
}
}
}
return result;
}
/**
* Gets the appropriate method to be called for the given target, method name and arguments. If
* successful this method will return the Method within the target that can be called and the
* converted arguments in actualArgs. If unsuccessful this method will return null and the
* actualArgs will be empty.
*
* @param context The current execution context.
* @param source Target object to run against or method name.
* @param target Instance of object to be run against.
* @param propertyName Name of property to get method of.
* @param methods List of current known methods.
* @param args Arguments originally passed in.
* @param actualArgs Converted arguments.
*
* @return Best method match or null if none could be found.
*/
public static Method getAppropriateMethod(OgnlContext context, Object source, Object target, String propertyName,
List methods, Object[] args, Object[] actualArgs)
{
Method result = null;
Class[] resultParameterTypes = null;
if (methods != null)
{
for (int i = 0, icount = methods.size(); i < icount; i++)
{
Method m = (Method) methods.get(i);
Class typeClass = target != null ? target.getClass() : null;
if (typeClass == null && source != null && Class.class.isInstance(source))
{
typeClass = (Class)source;
}
Class[] mParameterTypes = findParameterTypes(typeClass, m);
if (areArgsCompatible(args, mParameterTypes, m)
&& ((result == null) || isMoreSpecific(mParameterTypes, resultParameterTypes)))
{
result = m;
resultParameterTypes = mParameterTypes;
System.arraycopy(args, 0, actualArgs, 0, args.length);
for (int j = 0; j < mParameterTypes.length; j++)
{
Class type = mParameterTypes[j];
if (type.isPrimitive() && (actualArgs[j] == null))
{
actualArgs[j] = getConvertedType(context, source, result, propertyName, null, type);
}
}
}
}
}
if (result == null)
{
result = getConvertedMethodAndArgs(context, target, propertyName, methods, args, actualArgs);
}
return result;
}
public static Object callAppropriateMethod(OgnlContext context, Object source, Object target, String methodName,
String propertyName, List methods, Object[] args)
throws MethodFailedException
{
Throwable reason = null;
Object[] actualArgs = _objectArrayPool.create(args.length);
try {
Method method = getAppropriateMethod(context, source, target, propertyName, methods, args, actualArgs);
if ((method == null) || !isMethodAccessible(context, source, method, propertyName))
{
StringBuffer buffer = new StringBuffer();
String className = "";
if (target != null)
{
className = target.getClass().getName() + ".";
}
for (int i = 0, ilast = args.length - 1; i <= ilast; i++)
{
Object arg = args[i];
buffer.append((arg == null) ? NULL_STRING : arg.getClass().getName());
if (i < ilast)
{
buffer.append(", ");
}
}
throw new NoSuchMethodException(className + methodName + "(" + buffer + ")");
}
Object[] convertedArgs = actualArgs;
if (isJdk15() && method.isVarArgs())
{
Class[] parmTypes = method.getParameterTypes();
// split arguments in to two dimensional array for varargs reflection invocation
// where it is expected that the parameter passed in to invoke the method
// will look like "new Object[] { arrayOfNonVarArgsArguments, arrayOfVarArgsArguments }"
for (int i=0; i < parmTypes.length; i++)
{
if (parmTypes[i].isArray())
{
convertedArgs = new Object[i + 1];
System.arraycopy(actualArgs, 0, convertedArgs, 0, convertedArgs.length);
Object[] varArgs;
// if they passed in varargs arguments grab them and dump in to new varargs array
if (actualArgs.length > i)
{
ArrayList varArgsList = new ArrayList();
for (int j=i; j < actualArgs.length; j++)
{
if (actualArgs[j] != null)
{
varArgsList.add(actualArgs[j]);
}
}
varArgs = varArgsList.toArray();
} else
{
varArgs = new Object[0];
}
convertedArgs[i] = varArgs;
break;
}
}
}
return invokeMethod(target, method, convertedArgs);
} catch (NoSuchMethodException e) {
reason = e;
} catch (IllegalAccessException e) {
reason = e;
} catch (InvocationTargetException e) {
reason = e.getTargetException();
} finally {
_objectArrayPool.recycle(actualArgs);
}
throw new MethodFailedException(source, methodName, reason);
}
public static Object callStaticMethod(OgnlContext context, String className, String methodName, Object[] args)
throws OgnlException
{
try {
Class targetClass = classForName(context, className);
if (targetClass == null)
throw new ClassNotFoundException("Unable to resolve class with name " + className);
MethodAccessor ma = getMethodAccessor(targetClass);
return ma.callStaticMethod(context, targetClass, methodName, args);
} catch (ClassNotFoundException ex) {
throw new MethodFailedException(className, methodName, ex);
}
}
/**
* Invokes the specified method against the target object.
*
* @param context
* The current execution context.
* @param target
* The object to invoke the method on.
* @param methodName
* Name of the method - as in "getValue" or "add", etc..
* @param propertyName
* Name of the property to call instead?
* @param args
* Optional arguments needed for method.
* @return Result of invoking method.
*
* @deprecated Use {@link #callMethod(OgnlContext, Object, String, Object[])} instead.
* @throws OgnlException For lots of different reasons.
*/
public static Object callMethod(OgnlContext context, Object target, String methodName, String propertyName, Object[] args)
throws OgnlException
{
return callMethod(context, target, methodName == null ? propertyName : methodName, args);
}
/**
* Invokes the specified method against the target object.
*
* @param context
* The current execution context.
* @param target
* The object to invoke the method on.
* @param methodName
* Name of the method - as in "getValue" or "add", etc..
* @param args
* Optional arguments needed for method.
* @return Result of invoking method.
*
* @throws OgnlException For lots of different reasons.
*/
public static Object callMethod(OgnlContext context, Object target, String methodName, Object[] args)
throws OgnlException
{
if (target == null)
throw new NullPointerException("target is null for method " + methodName);
return getMethodAccessor(target.getClass()).callMethod(context, target, methodName, args);
}
public static Object callConstructor(OgnlContext context, String className, Object[] args)
throws OgnlException
{
Throwable reason = null;
Object[] actualArgs = args;
try {
Constructor ctor = null;
Class[] ctorParameterTypes = null;
Class target = classForName(context, className);
List constructors = getConstructors(target);
for (int i = 0, icount = constructors.size(); i < icount; i++) {
Constructor c = (Constructor) constructors.get(i);
Class[] cParameterTypes = getParameterTypes(c);
if (areArgsCompatible(args, cParameterTypes)
&& (ctor == null || isMoreSpecific(cParameterTypes, ctorParameterTypes))) {
ctor = c;
ctorParameterTypes = cParameterTypes;
}
}
if (ctor == null) {
actualArgs = _objectArrayPool.create(args.length);
if ((ctor = getConvertedConstructorAndArgs(context, target, constructors, args, actualArgs)) == null) {
throw new NoSuchMethodException();
}
}
if (!context.getMemberAccess().isAccessible(context, target, ctor, null)) {
throw new IllegalAccessException(
"access denied to " + target.getName() + "()");
}
return ctor.newInstance(actualArgs);
} catch (ClassNotFoundException e) {
reason = e;
} catch (NoSuchMethodException e) {
reason = e;
} catch (IllegalAccessException e) {
reason = e;
} catch (InvocationTargetException e) {
reason = e.getTargetException();
} catch (InstantiationException e) {
reason = e;
} finally {
if (actualArgs != args) {
_objectArrayPool.recycle(actualArgs);
}
}
throw new MethodFailedException(className, "new", reason);
}
public static final Object getMethodValue(OgnlContext context, Object target, String propertyName)
throws OgnlException, IllegalAccessException, NoSuchMethodException, IntrospectionException
{
return getMethodValue(context, target, propertyName, false);
}
/**
* If the checkAccessAndExistence flag is true this method will check to see if the method
* exists and if it is accessible according to the context's MemberAccess. If neither test
* passes this will return NotFound.
*/
public static final Object getMethodValue(OgnlContext context, Object target, String propertyName,
boolean checkAccessAndExistence)
throws OgnlException, IllegalAccessException, NoSuchMethodException, IntrospectionException
{
Object result = null;
Method m = getGetMethod(context, (target == null) ? null : target.getClass() , propertyName);
if (m == null)
m = getReadMethod((target == null) ? null : target.getClass(), propertyName, 0);
if (checkAccessAndExistence)
{
if ((m == null) || !context.getMemberAccess().isAccessible(context, target, m, propertyName))
{
result = NotFound;
}
}
if (result == null) {
if (m != null) {
try {
result = invokeMethod(target, m, NoArguments);
} catch (InvocationTargetException ex) {
throw new OgnlException(propertyName, ex.getTargetException());
}
} else {
throw new NoSuchMethodException(propertyName);
}
}
return result;
}
public static boolean setMethodValue(OgnlContext context, Object target, String propertyName, Object value)
throws OgnlException, IllegalAccessException, NoSuchMethodException, IntrospectionException
{
return setMethodValue(context, target, propertyName, value, false);
}
public static boolean setMethodValue(OgnlContext context, Object target, String propertyName, Object value,
boolean checkAccessAndExistence)
throws OgnlException, IllegalAccessException, NoSuchMethodException, IntrospectionException
{
boolean result = true;
Method m = getSetMethod(context, (target == null) ? null : target.getClass(), propertyName);
if (checkAccessAndExistence)
{
if ((m == null) || !context.getMemberAccess().isAccessible(context, target, m, propertyName))
{
result = false;
}
}
if (result)
{
if (m != null)
{
Object[] args = _objectArrayPool.create(value);
try
{
callAppropriateMethod(context, target, target, m.getName(), propertyName,
Collections.nCopies(1, m), args);
} finally
{
_objectArrayPool.recycle(args);
}
} else
{
result = false;
}
}
return result;
}
public static List getConstructors(Class targetClass)
{
List result;
synchronized (_constructorCache) {
if ((result = (List) _constructorCache.get(targetClass)) == null) {
_constructorCache.put(targetClass, result = Arrays.asList(targetClass.getConstructors()));
}
}
return result;
}
public static Map getMethods(Class targetClass, boolean staticMethods)
{
ClassCache cache = (staticMethods ? _staticMethodCache : _instanceMethodCache);
Map result;
synchronized (cache)
{
if ((result = (Map) cache.get(targetClass)) == null)
{
cache.put(targetClass, result = new HashMap(23));
for (Class c = targetClass; c != null; c = c.getSuperclass())
{
Method[] ma = c.getDeclaredMethods();
for (int i = 0, icount = ma.length; i < icount; i++)
{
// skip over synthetic methods
if (!isMethodCallable(ma[i]))
continue;
if (Modifier.isStatic(ma[i].getModifiers()) == staticMethods)
{
List ml = (List) result.get(ma[i].getName());
if (ml == null)
result.put(ma[i].getName(), ml = new ArrayList());
ml.add(ma[i]);
}
}
}
}
}
return result;
}
public static List getMethods(Class targetClass, String name, boolean staticMethods)
{
return (List) getMethods(targetClass, staticMethods).get(name);
}
public static Map getFields(Class targetClass)
{
Map result;
synchronized (_fieldCache) {
if ((result = (Map) _fieldCache.get(targetClass)) == null) {
Field fa[];
result = new HashMap(23);
fa = targetClass.getDeclaredFields();
for (int i = 0; i < fa.length; i++) {
result.put(fa[i].getName(), fa[i]);
}
_fieldCache.put(targetClass, result);
}
}
return result;
}
public static Field getField(Class inClass, String name)
{
Field result = null;
synchronized (_fieldCache) {
Object o = getFields(inClass).get(name);
if (o == null) {
_superclasses.clear();
for (Class sc = inClass; (sc != null); sc = sc.getSuperclass()) {
if ((o = getFields(sc).get(name)) == NotFound)
break;
_superclasses.add(sc);
if ((result = (Field) o) != null)
break;
}
/*
* Bubble the found value (either cache miss or actual field) to all supeclasses
* that we saw for quicker access next time.
*/
for (int i = 0, icount = _superclasses.size(); i < icount; i++) {
getFields((Class) _superclasses.get(i)).put(name, (result == null) ? NotFound : result);
}
} else {
if (o instanceof Field) {
result = (Field) o;
} else {
if (result == NotFound)
result = null;
}
}
}
return result;
}
public static Object getFieldValue(OgnlContext context, Object target, String propertyName)
throws NoSuchFieldException
{
return getFieldValue(context, target, propertyName, false);
}
public static Object getFieldValue(OgnlContext context, Object target, String propertyName,
boolean checkAccessAndExistence)
throws NoSuchFieldException
{
Object result = null;
Field f = getField((target == null) ? null : target.getClass(), propertyName);
if (checkAccessAndExistence) {
if ((f == null) || !context.getMemberAccess().isAccessible(context, target, f, propertyName)) {
result = NotFound;
}
}
if (result == null) {
if (f == null) {
throw new NoSuchFieldException(propertyName);
} else {
try {
Object state = null;
if (!Modifier.isStatic(f.getModifiers())) {
state = context.getMemberAccess().setup(context, target, f, propertyName);
result = f.get(target);
context.getMemberAccess().restore(context, target, f, propertyName, state);
} else
throw new NoSuchFieldException(propertyName);
} catch (IllegalAccessException ex) {
throw new NoSuchFieldException(propertyName);
}
}
}
return result;
}
public static boolean setFieldValue(OgnlContext context, Object target, String propertyName, Object value)
throws OgnlException
{
boolean result = false;
try {
Field f = getField((target == null) ? null : target.getClass(), propertyName);
Object state;
if ((f != null) && !Modifier.isStatic(f.getModifiers())) {
state = context.getMemberAccess().setup(context, target, f, propertyName);
try {
if (isTypeCompatible(value, f.getType())
|| ((value = getConvertedType(context, target, f, propertyName, value, f.getType())) != null)) {
f.set(target, value);
result = true;
}
} finally {
context.getMemberAccess().restore(context, target, f, propertyName, state);
}
}
} catch (IllegalAccessException ex) {
throw new NoSuchPropertyException(target, propertyName, ex);
}
return result;
}
public static boolean isFieldAccessible(OgnlContext context, Object target, Class inClass, String propertyName)
{
return isFieldAccessible(context, target, getField(inClass, propertyName), propertyName);
}
public static boolean isFieldAccessible(OgnlContext context, Object target, Field field, String propertyName)
{
return context.getMemberAccess().isAccessible(context, target, field, propertyName);
}
public static boolean hasField(OgnlContext context, Object target, Class inClass, String propertyName)
{
Field f = getField(inClass, propertyName);
return (f != null) && isFieldAccessible(context, target, f, propertyName);
}
public static Object getStaticField(OgnlContext context, String className, String fieldName)
throws OgnlException
{
Exception reason = null;
try {
Class c = classForName(context, className);
if (c == null)
throw new OgnlException("Unable to find class " + className + " when resolving field name of " + fieldName);
/*
* Check for virtual static field "class"; this cannot interfere with normal static
* fields because it is a reserved word.
*/
if (fieldName.equals("class"))
{
return c;
} else if (OgnlRuntime.isJdk15() && c.isEnum())
{
return Enum.valueOf(c, fieldName);
} else
{
Field f = c.getField(fieldName);
if (!Modifier.isStatic(f.getModifiers()))
throw new OgnlException("Field " + fieldName + " of class " + className + " is not static");
return f.get(null);
}
} catch (ClassNotFoundException e) {
reason = e;
} catch (NoSuchFieldException e) {
reason = e;
} catch (SecurityException e) {
reason = e;
} catch (IllegalAccessException e) {
reason = e;
}
throw new OgnlException("Could not get static field " + fieldName + " from class " + className, reason);
}
public static List getDeclaredMethods(Class targetClass, String propertyName, boolean findSets)
{
List result = null;
ClassCache cache = _declaredMethods[findSets ? 0 : 1];
synchronized (cache) {
Map propertyCache = (Map) cache.get(targetClass);
if ((propertyCache == null) || ((result = (List) propertyCache.get(propertyName)) == null)) {
String baseName = Character.toUpperCase(propertyName.charAt(0)) + propertyName.substring(1);
for (Class c = targetClass; c != null; c = c.getSuperclass()) {
Method[] methods = c.getDeclaredMethods();
for (int i = 0; i < methods.length; i++) {
if (!isMethodCallable(methods[i]))
continue;
String ms = methods[i].getName();
if (ms.endsWith(baseName)) {
boolean isSet = false, isIs = false;
if ((isSet = ms.startsWith(SET_PREFIX)) || ms.startsWith(GET_PREFIX)
|| (isIs = ms.startsWith(IS_PREFIX))) {
int prefixLength = (isIs ? 2 : 3);
if (isSet == findSets) {
if (baseName.length() == (ms.length() - prefixLength)) {
if (result == null) {
result = new ArrayList();
}
result.add(methods[i]);
}
}
}
}
}
}
if (propertyCache == null) {
cache.put(targetClass, propertyCache = new HashMap(101));
}
propertyCache.put(propertyName, (result == null) ? NotFoundList : result);
}
return (result == NotFoundList) ? null : result;
}
}
/**
* Convenience used to check if a method is volatile or synthetic so as to avoid
* calling un-callable methods.
*
* @param m The method to check.
* @return True if the method should be callable, false otherwise.
*/
static boolean isMethodCallable(Method m)
{
if ((isJdk15() && m.isSynthetic()) || Modifier.isVolatile(m.getModifiers()))
return false;
return true;
}
public static Method getGetMethod(OgnlContext context, Class targetClass, String propertyName)
throws IntrospectionException, OgnlException
{
Method result = null;
List methods = getDeclaredMethods(targetClass, propertyName, false /* find 'get' methods */);
if (methods != null)
{
for (int i = 0, icount = methods.size(); i < icount; i++)
{
Method m = (Method) methods.get(i);
Class[] mParameterTypes = findParameterTypes(targetClass, m); //getParameterTypes(m);
if (mParameterTypes.length == 0)
{
result = m;
break;
}
}
}
return result;
}
public static boolean isMethodAccessible(OgnlContext context, Object target, Method method, String propertyName)
{
return (method != null) && context.getMemberAccess().isAccessible(context, target, method, propertyName);
}
public static boolean hasGetMethod(OgnlContext context, Object target, Class targetClass, String propertyName)
throws IntrospectionException, OgnlException
{
return isMethodAccessible(context, target, getGetMethod(context, targetClass, propertyName), propertyName);
}
public static Method getSetMethod(OgnlContext context, Class targetClass, String propertyName)
throws IntrospectionException, OgnlException
{
Method result = null;
List methods = getDeclaredMethods(targetClass, propertyName, true /* find 'set' methods */);
if (methods != null)
{
for (int i = 0, icount = methods.size(); i < icount; i++)
{
Method m = (Method) methods.get(i);
Class[] mParameterTypes = findParameterTypes(targetClass, m); //getParameterTypes(m);
if (mParameterTypes.length == 1) {
result = m;
break;
}
}
}
return result;
}
public static final boolean hasSetMethod(OgnlContext context, Object target, Class targetClass, String propertyName)
throws IntrospectionException, OgnlException
{
return isMethodAccessible(context, target, getSetMethod(context, targetClass, propertyName), propertyName);
}
public static final boolean hasGetProperty(OgnlContext context, Object target, Object oname)
throws IntrospectionException, OgnlException
{
Class targetClass = (target == null) ? null : target.getClass();
String name = oname.toString();
return hasGetMethod(context, target, targetClass, name) || hasField(context, target, targetClass, name);
}
public static final boolean hasSetProperty(OgnlContext context, Object target, Object oname)
throws IntrospectionException, OgnlException
{
Class targetClass = (target == null) ? null : target.getClass();
String name = oname.toString();
return hasSetMethod(context, target, targetClass, name) || hasField(context, target, targetClass, name);
}
private static final boolean indexMethodCheck(List methods)
{
boolean result = false;
if (methods.size() > 0) {
Method fm = (Method) methods.get(0);
Class[] fmpt = getParameterTypes(fm);
int fmpc = fmpt.length;
Class lastMethodClass = fm.getDeclaringClass();
result = true;
for (int i = 1; result && (i < methods.size()); i++) {
Method m = (Method) methods.get(i);
Class c = m.getDeclaringClass();
// Check to see if more than one method implemented per class
if (lastMethodClass == c) {
result = false;
} else {
Class[] mpt = getParameterTypes(fm);
int mpc = fmpt.length;
if (fmpc != mpc) {
result = false;
}
for (int j = 0; j < fmpc; j++) {
if (fmpt[j] != mpt[j]) {
result = false;
break;
}
}
}
lastMethodClass = c;
}
}
return result;
}
static void findObjectIndexedPropertyDescriptors(Class targetClass, Map intoMap)
throws OgnlException
{
Map allMethods = getMethods(targetClass, false);
Map pairs = new HashMap(101);
for (Iterator it = allMethods.keySet().iterator(); it.hasNext();) {
String methodName = (String) it.next();
List methods = (List) allMethods.get(methodName);
/*
* Only process set/get where there is exactly one implementation of the method per
* class and those implementations are all the same
*/
if (indexMethodCheck(methods)) {
boolean isGet = false, isSet = false;
Method m = (Method) methods.get(0);
if (((isSet = methodName.startsWith(SET_PREFIX)) || (isGet = methodName.startsWith(GET_PREFIX)))
&& (methodName.length() > 3)) {
String propertyName = Introspector.decapitalize(methodName.substring(3));
Class[] parameterTypes = getParameterTypes(m);
int parameterCount = parameterTypes.length;
if (isGet && (parameterCount == 1) && (m.getReturnType() != Void.TYPE)) {
List pair = (List) pairs.get(propertyName);
if (pair == null) {
pairs.put(propertyName, pair = new ArrayList());
}
pair.add(m);
}
if (isSet && (parameterCount == 2) && (m.getReturnType() == Void.TYPE)) {
List pair = (List) pairs.get(propertyName);
if (pair == null) {
pairs.put(propertyName, pair = new ArrayList());
}
pair.add(m);
}
}
}
}
for (Iterator it = pairs.keySet().iterator(); it.hasNext();) {
String propertyName = (String) it.next();
List methods = (List) pairs.get(propertyName);
if (methods.size() == 2) {
Method method1 = (Method) methods.get(0), method2 = (Method) methods.get(1), setMethod = (method1
.getParameterTypes().length == 2) ? method1 : method2, getMethod = (setMethod == method1) ? method2
: method1;
Class keyType = getMethod.getParameterTypes()[0], propertyType = getMethod.getReturnType();
if (keyType == setMethod.getParameterTypes()[0]) {
if (propertyType == setMethod.getParameterTypes()[1]) {
ObjectIndexedPropertyDescriptor propertyDescriptor;
try {
propertyDescriptor = new ObjectIndexedPropertyDescriptor(propertyName, propertyType,
getMethod, setMethod);
} catch (Exception ex) {
throw new OgnlException("creating object indexed property descriptor for '" + propertyName
+ "' in " + targetClass, ex);
}
intoMap.put(propertyName, propertyDescriptor);
}
}
}
}
}
/**
* This method returns the property descriptors for the given class as a Map.
*
* @param targetClass The class to get the descriptors for.
* @return Map map of property descriptors for class.
*
* @throws IntrospectionException on errors using {@link Introspector}.
* @throws OgnlException On general errors.
*/
public static Map getPropertyDescriptors(Class targetClass)
throws IntrospectionException, OgnlException
{
Map result;
synchronized (_propertyDescriptorCache) {
if ((result = (Map) _propertyDescriptorCache.get(targetClass)) == null)
{
PropertyDescriptor[] pda = Introspector.getBeanInfo(targetClass).getPropertyDescriptors();
result = new HashMap(101);
for (int i = 0, icount = pda.length; i < icount; i++)
{
// workaround for Introspector bug 6528714 (bugs.sun.com)
if (pda[i].getReadMethod() != null && !isMethodCallable(pda[i].getReadMethod()))
{
pda[i].setReadMethod(findClosestMatchingMethod(targetClass, pda[i].getReadMethod(), pda[i].getName(),
pda[i].getPropertyType(), true));
}
if (pda[i].getWriteMethod() != null && !isMethodCallable(pda[i].getWriteMethod()))
{
pda[i].setWriteMethod(findClosestMatchingMethod(targetClass, pda[i].getWriteMethod(), pda[i].getName(),
pda[i].getPropertyType(), false));
}
result.put(pda[i].getName(), pda[i]);
}
findObjectIndexedPropertyDescriptors(targetClass, result);
_propertyDescriptorCache.put(targetClass, result);
}
}
return result;
}
/**
* This method returns a PropertyDescriptor for the given class and property name using a Map
* lookup (using getPropertyDescriptorsMap()).
*/
public static PropertyDescriptor getPropertyDescriptor(Class targetClass, String propertyName)
throws IntrospectionException, OgnlException
{
if (targetClass == null)
return null;
return (PropertyDescriptor) getPropertyDescriptors(targetClass).get(propertyName);
}
static Method findClosestMatchingMethod(Class targetClass, Method m, String propertyName,
Class propertyType, boolean isReadMethod)
{
List methods = getDeclaredMethods(targetClass, propertyName, !isReadMethod);
for (int i=0; i < methods.size(); i++)
{
Method method = (Method) methods.get(i);
if (method.getName().equals(m.getName())
&& m.getReturnType().isAssignableFrom(m.getReturnType())
&& method.getReturnType() == propertyType
&& method.getParameterTypes().length == m.getParameterTypes().length) {
return method;
}
}
return m;
}
public static PropertyDescriptor[] getPropertyDescriptorsArray(Class targetClass)
throws IntrospectionException
{
PropertyDescriptor[] result = null;
if (targetClass != null) {
synchronized (_propertyDescriptorCache) {
if ((result = (PropertyDescriptor[]) _propertyDescriptorCache.get(targetClass)) == null) {
_propertyDescriptorCache.put(targetClass, result = Introspector.getBeanInfo(targetClass)
.getPropertyDescriptors());
}
}
}
return result;
}
/**
* Gets the property descriptor with the given name for the target class given.
*
* @param targetClass Class for which property descriptor is desired
* @param name Name of property
* @return PropertyDescriptor of the named property or null if the class has no property with
* the given name
*/
public static PropertyDescriptor getPropertyDescriptorFromArray(Class targetClass, String name)
throws IntrospectionException
{
PropertyDescriptor result = null;
PropertyDescriptor[] pda = getPropertyDescriptorsArray(targetClass);
for (int i = 0, icount = pda.length; (result == null) && (i < icount); i++) {
if (pda[i].getName().compareTo(name) == 0) {
result = pda[i];
}
}
return result;
}
public static void setMethodAccessor(Class cls, MethodAccessor accessor)
{
synchronized (_methodAccessors) {
_methodAccessors.put(cls, accessor);
}
}
public static MethodAccessor getMethodAccessor(Class cls)
throws OgnlException
{
MethodAccessor answer = (MethodAccessor) getHandler(cls, _methodAccessors);
if (answer != null)
return answer;
throw new OgnlException("No method accessor for " + cls);
}
public static void setPropertyAccessor(Class cls, PropertyAccessor accessor)
{
synchronized (_propertyAccessors) {
_propertyAccessors.put(cls, accessor);
}
}
public static PropertyAccessor getPropertyAccessor(Class cls)
throws OgnlException
{
PropertyAccessor answer = (PropertyAccessor) getHandler(cls, _propertyAccessors);
if (answer != null)
return answer;
throw new OgnlException("No property accessor for class " + cls);
}
public static ElementsAccessor getElementsAccessor(Class cls)
throws OgnlException
{
ElementsAccessor answer = (ElementsAccessor) getHandler(cls, _elementsAccessors);
if (answer != null)
return answer;
throw new OgnlException("No elements accessor for class " + cls);
}
public static void setElementsAccessor(Class cls, ElementsAccessor accessor)
{
synchronized (_elementsAccessors) {
_elementsAccessors.put(cls, accessor);
}
}
public static NullHandler getNullHandler(Class cls)
throws OgnlException
{
NullHandler answer = (NullHandler) getHandler(cls, _nullHandlers);
if (answer != null)
return answer;
throw new OgnlException("No null handler for class " + cls);
}
public static void setNullHandler(Class cls, NullHandler handler)
{
synchronized (_nullHandlers) {
_nullHandlers.put(cls, handler);
}
}
private static Object getHandler(Class forClass, ClassCache handlers)
{
Object answer = null;
synchronized (handlers) {
if ((answer = handlers.get(forClass)) == null) {
Class keyFound;
if (forClass.isArray()) {
answer = handlers.get(Object[].class);
keyFound = null;
} else {
keyFound = forClass;
outer:
for (Class c = forClass; c != null; c = c.getSuperclass()) {
answer = handlers.get(c);
if (answer == null) {
Class[] interfaces = c.getInterfaces();
for (int index = 0, count = interfaces.length; index < count; ++index) {
Class iface = interfaces[index];
answer = handlers.get(iface);
if (answer == null) {
/* Try super-interfaces */
answer = getHandler(iface, handlers);
}
if (answer != null) {
keyFound = iface;
break outer;
}
}
} else {
keyFound = c;
break;
}
}
}
if (answer != null) {
if (keyFound != forClass) {
handlers.put(forClass, answer);
}
}
}
}
return answer;
}
public static Object getProperty(OgnlContext context, Object source, Object name)
throws OgnlException
{
PropertyAccessor accessor;
if (source == null)
{
throw new OgnlException("source is null for getProperty(null, \"" + name + "\")");
}
if ((accessor = getPropertyAccessor(getTargetClass(source))) == null)
{
throw new OgnlException("No property accessor for " + getTargetClass(source).getName());
}
return accessor.getProperty(context, source, name);
}
public static void setProperty(OgnlContext context, Object target, Object name, Object value)
throws OgnlException
{
PropertyAccessor accessor;
if (target == null) {
throw new OgnlException("target is null for setProperty(null, \"" + name + "\", " + value + ")");
}
if ((accessor = getPropertyAccessor(getTargetClass(target))) == null) {
throw new OgnlException("No property accessor for " + getTargetClass(target).getName());
}
accessor.setProperty(context, target, name, value);
}
/**
* Determines the index property type, if any. Returns INDEXED_PROPERTY_NONE if
* the property is not index-accessible as determined by OGNL or JavaBeans. If it is indexable
* then this will return whether it is a JavaBeans indexed property, conforming to the indexed
* property patterns (returns INDEXED_PROPERTY_INT) or if it conforms to the
* OGNL arbitrary object indexable (returns INDEXED_PROPERTY_OBJECT).
*/
public static int getIndexedPropertyType(OgnlContext context, Class sourceClass, String name)
throws OgnlException
{
int result = INDEXED_PROPERTY_NONE;
try {
PropertyDescriptor pd = getPropertyDescriptor(sourceClass, name);
if (pd != null) {
if (pd instanceof IndexedPropertyDescriptor) {
result = INDEXED_PROPERTY_INT;
} else {
if (pd instanceof ObjectIndexedPropertyDescriptor) {
result = INDEXED_PROPERTY_OBJECT;
}
}
}
} catch (Exception ex) {
throw new OgnlException("problem determining if '" + name + "' is an indexed property", ex);
}
return result;
}
public static Object getIndexedProperty(OgnlContext context, Object source, String name, Object index)
throws OgnlException
{
Object[] args = _objectArrayPool.create(index);
try {
PropertyDescriptor pd = getPropertyDescriptor((source == null) ? null : source.getClass(), name);
Method m;
if (pd instanceof IndexedPropertyDescriptor) {
m = ((IndexedPropertyDescriptor) pd).getIndexedReadMethod();
} else {
if (pd instanceof ObjectIndexedPropertyDescriptor) {
m = ((ObjectIndexedPropertyDescriptor) pd).getIndexedReadMethod();
} else {
throw new OgnlException("property '" + name + "' is not an indexed property");
}
}
return callMethod(context, source, m.getName(), args);
} catch (OgnlException ex) {
throw ex;
} catch (Exception ex) {
throw new OgnlException("getting indexed property descriptor for '" + name + "'", ex);
} finally {
_objectArrayPool.recycle(args);
}
}
public static void setIndexedProperty(OgnlContext context, Object source, String name, Object index,
Object value)
throws OgnlException
{
Object[] args = _objectArrayPool.create(index, value);
try {
PropertyDescriptor pd = getPropertyDescriptor((source == null) ? null : source.getClass(), name);
Method m;
if (pd instanceof IndexedPropertyDescriptor) {
m = ((IndexedPropertyDescriptor) pd).getIndexedWriteMethod();
} else {
if (pd instanceof ObjectIndexedPropertyDescriptor) {
m = ((ObjectIndexedPropertyDescriptor) pd).getIndexedWriteMethod();
} else {
throw new OgnlException("property '" + name + "' is not an indexed property");
}
}
callMethod(context, source, m.getName(), args);
} catch (OgnlException ex) {
throw ex;
} catch (Exception ex) {
throw new OgnlException("getting indexed property descriptor for '" + name + "'", ex);
} finally {
_objectArrayPool.recycle(args);
}
}
public static EvaluationPool getEvaluationPool()
{
return _evaluationPool;
}
public static ObjectArrayPool getObjectArrayPool()
{
return _objectArrayPool;
}
/**
* Registers the specified {@link ClassCacheInspector} with all class reflection based internal
* caches. This may have a significant performance impact so be careful using this in production scenarios.
*
* @param inspector
* The inspector instance that will be registered with all internal cache instances.
*/
public static void setClassCacheInspector(ClassCacheInspector inspector)
{
_cacheInspector = inspector;
_propertyDescriptorCache.setClassInspector(_cacheInspector);
_constructorCache.setClassInspector(_cacheInspector);
_staticMethodCache.setClassInspector(_cacheInspector);
_instanceMethodCache.setClassInspector(_cacheInspector);
_invokePermissionCache.setClassInspector(_cacheInspector);
_fieldCache.setClassInspector(_cacheInspector);
_declaredMethods[0].setClassInspector(_cacheInspector);
_declaredMethods[1].setClassInspector(_cacheInspector);
}
public static Method getMethod(OgnlContext context, Class target, String name,
Node[] children, boolean includeStatic)
throws Exception
{
Class[] parms;
if (children != null && children.length > 0)
{
parms = new Class[children.length];
// used to reset context after loop
Class currType = context.getCurrentType();
Class currAccessor = context.getCurrentAccessor();
Object cast = context.get(ExpressionCompiler.PRE_CAST);
context.setCurrentObject(context.getRoot());
context.setCurrentType(context.getRoot() != null ? context.getRoot().getClass() : null);
context.setCurrentAccessor(null);
context.setPreviousType(null);
for (int i=0; i < children.length; i++)
{
children[i].toGetSourceString(context, context.getRoot());
parms[i] = context.getCurrentType();
}
context.put(ExpressionCompiler.PRE_CAST, cast);
context.setCurrentType(currType);
context.setCurrentAccessor(currAccessor);
context.setCurrentObject(target);
} else
{
parms = new Class[0];
}
List methods = OgnlRuntime.getMethods(target, name, includeStatic);
if (methods == null)
return null;
for (int i = 0; i < methods.size(); i++)
{
Method m = (Method) methods.get(i);
boolean varArgs = isJdk15() && m.isVarArgs();
if (parms.length != m.getParameterTypes().length && !varArgs)
continue;
Class[] mparms = m.getParameterTypes();
boolean matched = true;
for (int p = 0; p < mparms.length; p++)
{
if (varArgs && mparms[p].isArray()){
continue;
}
if (parms[p] == null)
{
matched = false;
break;
}
if (parms[p] == mparms[p])
continue;
if (mparms[p].isPrimitive()
&& Character.TYPE != mparms[p] && Byte.TYPE != mparms[p]
&& Number.class.isAssignableFrom(parms[p])
&& OgnlRuntime.getPrimitiveWrapperClass(parms[p]) == mparms[p])
{
continue;
}
matched = false;
break;
}
if (matched)
return m;
}
return null;
}
/**
* Finds the best possible match for a method on the specified target class with a matching
* name.
*
*
* The name matched will also try different combinations like is + name, has + name, get + name, etc..
*
*
* @param target
* The class to find a matching method against.
* @param name
* The name of the method.
* @return The most likely matching {@link Method}, or null if none could be found.
*/
public static Method getReadMethod(Class target, String name)
{
return getReadMethod(target, name, -1);
}
public static Method getReadMethod(Class target, String name, int numParms)
{
try {
name = name.replaceAll("\"", "").toLowerCase();
BeanInfo info = Introspector.getBeanInfo(target);
MethodDescriptor[] methods = info.getMethodDescriptors();
// exact matches first
Method m = null;
for (int i = 0; i < methods.length; i++)
{
if (!isMethodCallable(methods[i].getMethod()))
continue;
if ((methods[i].getName().equalsIgnoreCase(name)
|| methods[i].getName().toLowerCase().equals(name)
|| methods[i].getName().toLowerCase().equals("get" + name)
|| methods[i].getName().toLowerCase().equals("has" + name)
|| methods[i].getName().toLowerCase().equals("is" + name))
&& !methods[i].getName().startsWith("set"))
{
if (numParms > 0 && methods[i].getMethod().getParameterTypes().length == numParms)
return methods[i].getMethod();
else if (numParms < 0)
{
if ((m != null && m.getParameterTypes().length > methods[i].getMethod().getParameterTypes().length)
|| m == null)
{
m = methods[i].getMethod();
}
}
}
}
if (m != null)
return m;
for (int i = 0; i < methods.length; i++)
{
if (!isMethodCallable(methods[i].getMethod()))
continue;
if (methods[i].getName().toLowerCase().endsWith(name)
&& !methods[i].getName().startsWith("set")
&& methods[i].getMethod().getReturnType() != Void.TYPE) {
if (numParms > 0 && methods[i].getMethod().getParameterTypes().length == numParms)
return methods[i].getMethod();
else if (numParms < 0)
{
if ((m != null && m.getParameterTypes().length > methods[i].getMethod().getParameterTypes().length)
|| m == null)
{
m = methods[i].getMethod();
}
}
}
}
if (m != null)
return m;
// try one last time adding a get to beginning
if (!name.startsWith("get"))
return OgnlRuntime.getReadMethod(target, "get" + name, numParms);
} catch (Throwable t)
{
throw OgnlOps.castToRuntime(t);
}
return null;
}
public static Method getWriteMethod(Class target, String name)
{
return getWriteMethod(target, name, -1);
}
public static Method getWriteMethod(Class target, String name, int numParms)
{
try {
name = name.replaceAll("\"", "");
BeanInfo info = Introspector.getBeanInfo(target);
MethodDescriptor[] methods = info.getMethodDescriptors();
for (int i = 0; i < methods.length; i++) {
if (!isMethodCallable(methods[i].getMethod()))
continue;
if ((methods[i].getName().equalsIgnoreCase(name)
|| methods[i].getName().toLowerCase().equals(name.toLowerCase())
|| methods[i].getName().toLowerCase().equals("set" + name.toLowerCase()))
&& !methods[i].getName().startsWith("get")) {
if (numParms > 0 && methods[i].getMethod().getParameterTypes().length == numParms)
return methods[i].getMethod();
else if (numParms < 0)
return methods[i].getMethod();
}
}
// try again on pure class
Method[] cmethods = target.getClass().getMethods();
for (int i = 0; i < cmethods.length; i++) {
if (!isMethodCallable(cmethods[i]))
continue;
if ((cmethods[i].getName().equalsIgnoreCase(name)
|| cmethods[i].getName().toLowerCase().equals(name.toLowerCase())
|| cmethods[i].getName().toLowerCase().equals("set" + name.toLowerCase()))
&& !cmethods[i].getName().startsWith("get")) {
if (numParms > 0 && cmethods[i].getParameterTypes().length == numParms)
return cmethods[i];
else if (numParms < 0)
return cmethods[i];
}
}
// try one last time adding a set to beginning
if (!name.startsWith("set")) {
return OgnlRuntime.getReadMethod(target, "set" + name, numParms);
}
} catch (Throwable t)
{
throw OgnlOps.castToRuntime(t);
}
return null;
}
public static PropertyDescriptor getProperty(Class target, String name)
{
try {
BeanInfo info = Introspector.getBeanInfo(target);
PropertyDescriptor[] pds = info.getPropertyDescriptors();
for (int i = 0; i < pds.length; i++) {
if (pds[i].getName().equalsIgnoreCase(name)
|| pds[i].getName().toLowerCase().equals(name.toLowerCase())
|| pds[i].getName().toLowerCase().endsWith(name.toLowerCase()))
return pds[i];
}
} catch (Throwable t)
{
throw OgnlOps.castToRuntime(t);
}
return null;
}
public static boolean isBoolean(String expression)
{
if (expression == null)
return false;
if ("true".equals(expression) || "false".equals(expression)
|| "!true".equals(expression) || "!false".equals(expression)
|| "(true)".equals(expression)
|| "!(true)".equals(expression)
|| "(false)".equals(expression)
|| "!(false)".equals(expression)
|| expression.startsWith("ognl.OgnlOps"))
return true;
return false;
}
/**
* Compares the {@link OgnlContext#getCurrentType()} and {@link OgnlContext#getPreviousType()} class types
* on the stack to determine if a numeric expression should force object conversion.
*
*
* Normally used in conjunction with the forceConversion parameter of
* {@link OgnlRuntime#getChildSource(OgnlContext,Object,Node,boolean)}.
*
*
* @param context The current context.
* @return True, if the class types on the stack wouldn't be comparable in a pure numeric expression such as o1 >= o2.
*/
public static boolean shouldConvertNumericTypes(OgnlContext context)
{
if (context.getCurrentType() == null || context.getPreviousType() == null)
return true;
if (context.getCurrentType() == context.getPreviousType()
&& context.getCurrentType().isPrimitive() && context.getPreviousType().isPrimitive())
return false;
return context.getCurrentType() != null && !context.getCurrentType().isArray()
&& context.getPreviousType() != null && !context.getPreviousType().isArray();
}
/**
* Attempts to get the java source string represented by the specific child expression
* via the {@link JavaSource#toGetSourceString(OgnlContext,Object)} interface method.
*
* @param context The ognl context to pass to the child.
* @param target The current object target to use.
* @param child The child expression.
* @return The result of calling {@link JavaSource#toGetSourceString(OgnlContext,Object)} plus additional
* enclosures of {@link OgnlOps#convertValue(Object,Class,boolean)} for conversions.
* @throws OgnlException Mandatory exception throwing catching.. (blehh)
*/
public static String getChildSource(OgnlContext context, Object target, Node child)
throws OgnlException
{
return getChildSource(context, target, child, false);
}
/**
* Attempts to get the java source string represented by the specific child expression
* via the {@link JavaSource#toGetSourceString(OgnlContext,Object)} interface method.
*
* @param context The ognl context to pass to the child.
* @param target The current object target to use.
* @param child The child expression.
* @param forceConversion If true, forces {@link OgnlOps#convertValue(Object,Class)} conversions on the objects.
* @return The result of calling {@link JavaSource#toGetSourceString(OgnlContext,Object)} plus additional
* enclosures of {@link OgnlOps#convertValue(Object,Class,boolean)} for conversions.
* @throws OgnlException Mandatory exception throwing catching.. (blehh)
*/
public static String getChildSource(OgnlContext context, Object target, Node child, boolean forceConversion)
throws OgnlException
{
String pre = (String) context.get("_currentChain");
if (pre == null)
pre = "";
try
{
child.getValue(context, target);
} catch (NullPointerException e)
{
// ignore
} catch (ArithmeticException e)
{
context.setCurrentType(int.class);
return "0";
} catch (Throwable t)
{
throw OgnlOps.castToRuntime(t);
}
String source = null;
try
{
source = child.toGetSourceString(context, target);
}
catch (Throwable t)
{
throw OgnlOps.castToRuntime(t);
}
// handle root / method expressions that may not have proper root java source access
if (!ASTConst.class.isInstance(child)
&& (target == null || context.getRoot() != target))
{
source = pre + source;
}
if (context.getRoot() != null)
{
source = ExpressionCompiler.getRootExpression(child, context.getRoot(), context) + source;
context.setCurrentAccessor(context.getRoot().getClass());
}
if (ASTChain.class.isInstance(child))
{
String cast = (String) context.remove(ExpressionCompiler.PRE_CAST);
if (cast == null)
cast = "";
source = cast + source;
}
if (source == null || source.trim().length() < 1)
source = "null";
return source;
}
}
ognl-2.7.3.orig/src/java/ognl/Token.java 0000644 0001750 0001750 00000007343 10746450726 017731 0 ustar drazzib drazzib /* Generated By:JavaCC: Do not edit this line. Token.java Version 4.1 */
/* JavaCCOptions:TOKEN_EXTENDS=,KEEP_LINE_COL=null */
package ognl;
/**
* Describes the input token stream.
*/
public class Token {
/**
* An integer that describes the kind of this token. This numbering
* system is determined by JavaCCParser, and a table of these numbers is
* stored in the file ...Constants.java.
*/
public int kind;
/** The line number of the first character of this Token. */
public int beginLine;
/** The column number of the first character of this Token. */
public int beginColumn;
/** The line number of the last character of this Token. */
public int endLine;
/** The column number of the last character of this Token. */
public int endColumn;
/**
* The string image of the token.
*/
public String image;
/**
* A reference to the next regular (non-special) token from the input
* stream. If this is the last token from the input stream, or if the
* token manager has not read tokens beyond this one, this field is
* set to null. This is true only if this token is also a regular
* token. Otherwise, see below for a description of the contents of
* this field.
*/
public Token next;
/**
* This field is used to access special tokens that occur prior to this
* token, but after the immediately preceding regular (non-special) token.
* If there are no such special tokens, this field is set to null.
* When there are more than one such special token, this field refers
* to the last of these special tokens, which in turn refers to the next
* previous special token through its specialToken field, and so on
* until the first special token (whose specialToken field is null).
* The next fields of special tokens refer to other special tokens that
* immediately follow it (without an intervening regular token). If there
* is no such token, this field is null.
*/
public Token specialToken;
/**
* An optional attribute value of the Token.
* Tokens which are not used as syntactic sugar will often contain
* meaningful values that will be used later on by the compiler or
* interpreter. This attribute value is often different from the image.
* Any subclass of Token that actually wants to return a non-null value can
* override this method as appropriate.
*/
public Object getValue() {
return null;
}
/**
* No-argument contructor
*/
public Token() {}
/**
* Constructs a new token for the specified Image.
*/
public Token(int kind)
{
this(kind, null);
}
/**
* Constructs a new token for the specified Image and Kind.
*/
public Token(int kind, String image)
{
this.kind = kind;
this.image = image;
}
/**
* Returns the image.
*/
public String toString()
{
return image;
}
/**
* Returns a new Token object, by default. However, if you want, you
* can create and return subclass objects based on the value of ofKind.
* Simply add the cases to the switch for all those special cases.
* For example, if you have a subclass of Token called IDToken that
* you want to create if ofKind is ID, simply add something like :
*
* case MyParserConstants.ID : return new IDToken(ofKind, image);
*
* to the following switch statement. Then you can cast matchedToken
* variable to the appropriate type and use sit in your lexical actions.
*/
public static Token newToken(int ofKind, String image)
{
switch(ofKind)
{
default : return new Token(ofKind, image);
}
}
public static Token newToken(int ofKind)
{
return newToken(ofKind, null);
}
}
/* JavaCC - OriginalChecksum=771cf4338e4d91b53163152263c004d8 (do not edit this line) */
ognl-2.7.3.orig/src/java/ognl/EnumerationPropertyAccessor.java 0000644 0001750 0001750 00000006177 10561411075 024360 0 ustar drazzib drazzib //--------------------------------------------------------------------------
// Copyright (c) 1998-2004, Drew Davidson and Luke Blanshard
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
// Neither the name of the Drew Davidson nor the names of its contributors
// may be used to endorse or promote products derived from this software
// without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
// COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
// OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
// AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
// DAMAGE.
//--------------------------------------------------------------------------
package ognl;
import java.util.*;
/**
* Implementation of PropertyAccessor that provides "property" reference to
* "nextElement" (aliases to "next" also) and "hasMoreElements" (also aliased
* to "hasNext").
* @author Luke Blanshard (blanshlu@netscape.net)
* @author Drew Davidson (drew@ognl.org)
*/
public class EnumerationPropertyAccessor extends ObjectPropertyAccessor
implements PropertyAccessor // This is here to make javadoc show this class as an implementor
{
public Object getProperty( Map context, Object target, Object name ) throws OgnlException
{
Object result;
Enumeration e = (Enumeration)target;
if ( name instanceof String ) {
if (name.equals("next") || name.equals("nextElement")) {
result = e.nextElement();
} else {
if (name.equals("hasNext") || name.equals("hasMoreElements")) {
result = e.hasMoreElements() ? Boolean.TRUE : Boolean.FALSE;
} else {
result = super.getProperty( context, target, name );
}
}
} else {
result = super.getProperty(context, target, name);
}
return result;
}
public void setProperty( Map context, Object target, Object name, Object value ) throws OgnlException
{
throw new IllegalArgumentException( "can't set property " + name + " on Enumeration" );
}
}
ognl-2.7.3.orig/src/java/ognl/ognl.jj 0000644 0001750 0001750 00000223762 10746450726 017277 0 ustar drazzib drazzib /*@bgen(jjtree) Generated By:JJTree: Do not edit this line. src/java/ognl/ognl.jj */
/*@egen*///--------------------------------------------------------------------------
// Copyright (c) 1998-2004, Drew Davidson and Luke Blanshard
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
// Neither the name of the Drew Davidson nor the names of its contributors
// may be used to endorse or promote products derived from this software
// without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
// COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
// OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
// AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
// DAMAGE.
//--------------------------------------------------------------------------
/*
* This file defines the syntax of OGNL, the Object-Graph Navigation Language. This
* language was devised by Drew Davidson, who called it Key-Value Coding Language. Luke
* Blanshard then made up the new name and reimplemented it using ANTLR, refining and
* polishing the language a bit on the way. Drew maintained the system for a couple of
* years; then Luke converted the ANTLR grammar to JavaCC, to eliminate the run-time
* dependency on ANTLR.
*
* See package.html for a description of the language.
*/
options {
// Parser options
LOOKAHEAD = 1;
STATIC = false;
JAVA_UNICODE_ESCAPE = true;
UNICODE_INPUT = true;
}
PARSER_BEGIN(OgnlParser)
package ognl;
import java.math.*;
/**
* OgnlParser is a JavaCC parser class; it translates OGNL expressions into abstract
* syntax trees (ASTs) that can then be interpreted by the getValue and setValue methods.
*/
public class OgnlParser/*@bgen(jjtree)*/implements OgnlParserTreeConstants/*@egen*/
{/*@bgen(jjtree)*/
protected JJTOgnlParserState jjtree = new JJTOgnlParserState();
/*@egen*/
}
PARSER_END(OgnlParser)
/**
* This is the top-level construct of OGNL.
*/
Node topLevelExpression() : {}
{
expression() { return jjtree.rootNode(); }
}
// sequence (level 14)
void expression() : {}
{
assignmentExpression() ( ","/*@bgen(jjtree) #Sequence( 2) */
{
ASTSequence jjtn001 = new ASTSequence(JJTSEQUENCE);
boolean jjtc001 = true;
jjtree.openNodeScope(jjtn001);
}
try {
/*@egen*/ assignmentExpression()/*@bgen(jjtree)*/
} catch (Throwable jjte001) {
if (jjtc001) {
jjtree.clearNodeScope(jjtn001);
jjtc001 = false;
} else {
jjtree.popNode();
}
if (jjte001 instanceof RuntimeException) {
throw (RuntimeException)jjte001;
}
if (jjte001 instanceof ParseException) {
throw (ParseException)jjte001;
}
throw (Error)jjte001;
} finally {
if (jjtc001) {
jjtree.closeNodeScope(jjtn001, 2);
}
}
/*@egen*/ )*
}
// assignment expression (level 13)
void assignmentExpression() : {}
{
conditionalTestExpression() [ "="/*@bgen(jjtree) #Assign( 2) */
{
ASTAssign jjtn001 = new ASTAssign(JJTASSIGN);
boolean jjtc001 = true;
jjtree.openNodeScope(jjtn001);
}
try {
/*@egen*/ assignmentExpression()/*@bgen(jjtree)*/
} catch (Throwable jjte001) {
if (jjtc001) {
jjtree.clearNodeScope(jjtn001);
jjtc001 = false;
} else {
jjtree.popNode();
}
if (jjte001 instanceof RuntimeException) {
throw (RuntimeException)jjte001;
}
if (jjte001 instanceof ParseException) {
throw (ParseException)jjte001;
}
throw (Error)jjte001;
} finally {
if (jjtc001) {
jjtree.closeNodeScope(jjtn001, 2);
}
}
/*@egen*/ ]
}
// conditional test (level 12)
void conditionalTestExpression() : {}
{
logicalOrExpression()
[ "?" conditionalTestExpression() ":"/*@bgen(jjtree) #Test( 3) */
{
ASTTest jjtn001 = new ASTTest(JJTTEST);
boolean jjtc001 = true;
jjtree.openNodeScope(jjtn001);
}
try {
/*@egen*/ conditionalTestExpression()/*@bgen(jjtree)*/
} catch (Throwable jjte001) {
if (jjtc001) {
jjtree.clearNodeScope(jjtn001);
jjtc001 = false;
} else {
jjtree.popNode();
}
if (jjte001 instanceof RuntimeException) {
throw (RuntimeException)jjte001;
}
if (jjte001 instanceof ParseException) {
throw (ParseException)jjte001;
}
throw (Error)jjte001;
} finally {
if (jjtc001) {
jjtree.closeNodeScope(jjtn001, 3);
}
}
/*@egen*/ ]
}
// logical or (||) (level 11)
void logicalOrExpression() : {}
{
logicalAndExpression() (("||" | "or")/*@bgen(jjtree) #Or( 2) */
{
ASTOr jjtn001 = new ASTOr(JJTOR);
boolean jjtc001 = true;
jjtree.openNodeScope(jjtn001);
}
try {
/*@egen*/ logicalAndExpression()/*@bgen(jjtree)*/
} catch (Throwable jjte001) {
if (jjtc001) {
jjtree.clearNodeScope(jjtn001);
jjtc001 = false;
} else {
jjtree.popNode();
}
if (jjte001 instanceof RuntimeException) {
throw (RuntimeException)jjte001;
}
if (jjte001 instanceof ParseException) {
throw (ParseException)jjte001;
}
throw (Error)jjte001;
} finally {
if (jjtc001) {
jjtree.closeNodeScope(jjtn001, 2);
}
}
/*@egen*/ )*
}
// logical and (&&) (level 10)
void logicalAndExpression() : {}
{
inclusiveOrExpression() (("&&" | "and")/*@bgen(jjtree) #And( 2) */
{
ASTAnd jjtn001 = new ASTAnd(JJTAND);
boolean jjtc001 = true;
jjtree.openNodeScope(jjtn001);
}
try {
/*@egen*/ inclusiveOrExpression()/*@bgen(jjtree)*/
} catch (Throwable jjte001) {
if (jjtc001) {
jjtree.clearNodeScope(jjtn001);
jjtc001 = false;
} else {
jjtree.popNode();
}
if (jjte001 instanceof RuntimeException) {
throw (RuntimeException)jjte001;
}
if (jjte001 instanceof ParseException) {
throw (ParseException)jjte001;
}
throw (Error)jjte001;
} finally {
if (jjtc001) {
jjtree.closeNodeScope(jjtn001, 2);
}
}
/*@egen*/ )*
}
// bitwise or non-short-circuiting or (|) (level 9)
void inclusiveOrExpression() : {}
{
exclusiveOrExpression() (("|" | "bor")/*@bgen(jjtree) #BitOr( 2) */
{
ASTBitOr jjtn001 = new ASTBitOr(JJTBITOR);
boolean jjtc001 = true;
jjtree.openNodeScope(jjtn001);
}
try {
/*@egen*/ exclusiveOrExpression()/*@bgen(jjtree)*/
} catch (Throwable jjte001) {
if (jjtc001) {
jjtree.clearNodeScope(jjtn001);
jjtc001 = false;
} else {
jjtree.popNode();
}
if (jjte001 instanceof RuntimeException) {
throw (RuntimeException)jjte001;
}
if (jjte001 instanceof ParseException) {
throw (ParseException)jjte001;
}
throw (Error)jjte001;
} finally {
if (jjtc001) {
jjtree.closeNodeScope(jjtn001, 2);
}
}
/*@egen*/ )*
}
// exclusive or (^) (level 8)
void exclusiveOrExpression() : {}
{
andExpression() (("^" | "xor")/*@bgen(jjtree) #Xor( 2) */
{
ASTXor jjtn001 = new ASTXor(JJTXOR);
boolean jjtc001 = true;
jjtree.openNodeScope(jjtn001);
}
try {
/*@egen*/ andExpression()/*@bgen(jjtree)*/
} catch (Throwable jjte001) {
if (jjtc001) {
jjtree.clearNodeScope(jjtn001);
jjtc001 = false;
} else {
jjtree.popNode();
}
if (jjte001 instanceof RuntimeException) {
throw (RuntimeException)jjte001;
}
if (jjte001 instanceof ParseException) {
throw (ParseException)jjte001;
}
throw (Error)jjte001;
} finally {
if (jjtc001) {
jjtree.closeNodeScope(jjtn001, 2);
}
}
/*@egen*/ )*
}
// bitwise or non-short-circuiting and (&) (level 7)
void andExpression() : {}
{
equalityExpression() (("&" | "band")/*@bgen(jjtree) #BitAnd( 2) */
{
ASTBitAnd jjtn001 = new ASTBitAnd(JJTBITAND);
boolean jjtc001 = true;
jjtree.openNodeScope(jjtn001);
}
try {
/*@egen*/ equalityExpression()/*@bgen(jjtree)*/
} catch (Throwable jjte001) {
if (jjtc001) {
jjtree.clearNodeScope(jjtn001);
jjtc001 = false;
} else {
jjtree.popNode();
}
if (jjte001 instanceof RuntimeException) {
throw (RuntimeException)jjte001;
}
if (jjte001 instanceof ParseException) {
throw (ParseException)jjte001;
}
throw (Error)jjte001;
} finally {
if (jjtc001) {
jjtree.closeNodeScope(jjtn001, 2);
}
}
/*@egen*/ )*
}
// equality/inequality (==/!=) (level 6)
void equalityExpression() : {}
{
relationalExpression()
(
("==" | "eq")/*@bgen(jjtree) #Eq( 2) */
{
ASTEq jjtn001 = new ASTEq(JJTEQ);
boolean jjtc001 = true;
jjtree.openNodeScope(jjtn001);
}
try {
/*@egen*/ relationalExpression()/*@bgen(jjtree)*/
} catch (Throwable jjte001) {
if (jjtc001) {
jjtree.clearNodeScope(jjtn001);
jjtc001 = false;
} else {
jjtree.popNode();
}
if (jjte001 instanceof RuntimeException) {
throw (RuntimeException)jjte001;
}
if (jjte001 instanceof ParseException) {
throw (ParseException)jjte001;
}
throw (Error)jjte001;
} finally {
if (jjtc001) {
jjtree.closeNodeScope(jjtn001, 2);
}
}
/*@egen*/
|
("!=" | "neq")/*@bgen(jjtree) #NotEq( 2) */
{
ASTNotEq jjtn002 = new ASTNotEq(JJTNOTEQ);
boolean jjtc002 = true;
jjtree.openNodeScope(jjtn002);
}
try {
/*@egen*/ relationalExpression()/*@bgen(jjtree)*/
} catch (Throwable jjte002) {
if (jjtc002) {
jjtree.clearNodeScope(jjtn002);
jjtc002 = false;
} else {
jjtree.popNode();
}
if (jjte002 instanceof RuntimeException) {
throw (RuntimeException)jjte002;
}
if (jjte002 instanceof ParseException) {
throw (ParseException)jjte002;
}
throw (Error)jjte002;
} finally {
if (jjtc002) {
jjtree.closeNodeScope(jjtn002, 2);
}
}
/*@egen*/
)*
}
// boolean relational expressions (level 5)
void relationalExpression() : {}
{
shiftExpression()
(
("<" | "lt")/*@bgen(jjtree) #Less( 2) */
{
ASTLess jjtn001 = new ASTLess(JJTLESS);
boolean jjtc001 = true;
jjtree.openNodeScope(jjtn001);
}
try {
/*@egen*/ shiftExpression()/*@bgen(jjtree)*/
} catch (Throwable jjte001) {
if (jjtc001) {
jjtree.clearNodeScope(jjtn001);
jjtc001 = false;
} else {
jjtree.popNode();
}
if (jjte001 instanceof RuntimeException) {
throw (RuntimeException)jjte001;
}
if (jjte001 instanceof ParseException) {
throw (ParseException)jjte001;
}
throw (Error)jjte001;
} finally {
if (jjtc001) {
jjtree.closeNodeScope(jjtn001, 2);
}
}
/*@egen*/
|
(">" | "gt")/*@bgen(jjtree) #Greater( 2) */
{
ASTGreater jjtn002 = new ASTGreater(JJTGREATER);
boolean jjtc002 = true;
jjtree.openNodeScope(jjtn002);
}
try {
/*@egen*/ shiftExpression()/*@bgen(jjtree)*/
} catch (Throwable jjte002) {
if (jjtc002) {
jjtree.clearNodeScope(jjtn002);
jjtc002 = false;
} else {
jjtree.popNode();
}
if (jjte002 instanceof RuntimeException) {
throw (RuntimeException)jjte002;
}
if (jjte002 instanceof ParseException) {
throw (ParseException)jjte002;
}
throw (Error)jjte002;
} finally {
if (jjtc002) {
jjtree.closeNodeScope(jjtn002, 2);
}
}
/*@egen*/
|
("<=" | "lte")/*@bgen(jjtree) #LessEq( 2) */
{
ASTLessEq jjtn003 = new ASTLessEq(JJTLESSEQ);
boolean jjtc003 = true;
jjtree.openNodeScope(jjtn003);
}
try {
/*@egen*/ shiftExpression()/*@bgen(jjtree)*/
} catch (Throwable jjte003) {
if (jjtc003) {
jjtree.clearNodeScope(jjtn003);
jjtc003 = false;
} else {
jjtree.popNode();
}
if (jjte003 instanceof RuntimeException) {
throw (RuntimeException)jjte003;
}
if (jjte003 instanceof ParseException) {
throw (ParseException)jjte003;
}
throw (Error)jjte003;
} finally {
if (jjtc003) {
jjtree.closeNodeScope(jjtn003, 2);
}
}
/*@egen*/
|
(">=" | "gte")/*@bgen(jjtree) #GreaterEq( 2) */
{
ASTGreaterEq jjtn004 = new ASTGreaterEq(JJTGREATEREQ);
boolean jjtc004 = true;
jjtree.openNodeScope(jjtn004);
}
try {
/*@egen*/ shiftExpression()/*@bgen(jjtree)*/
} catch (Throwable jjte004) {
if (jjtc004) {
jjtree.clearNodeScope(jjtn004);
jjtc004 = false;
} else {
jjtree.popNode();
}
if (jjte004 instanceof RuntimeException) {
throw (RuntimeException)jjte004;
}
if (jjte004 instanceof ParseException) {
throw (ParseException)jjte004;
}
throw (Error)jjte004;
} finally {
if (jjtc004) {
jjtree.closeNodeScope(jjtn004, 2);
}
}
/*@egen*/
|
"in"/*@bgen(jjtree) #In( 2) */
{
ASTIn jjtn005 = new ASTIn(JJTIN);
boolean jjtc005 = true;
jjtree.openNodeScope(jjtn005);
}
try {
/*@egen*/ shiftExpression()/*@bgen(jjtree)*/
} catch (Throwable jjte005) {
if (jjtc005) {
jjtree.clearNodeScope(jjtn005);
jjtc005 = false;
} else {
jjtree.popNode();
}
if (jjte005 instanceof RuntimeException) {
throw (RuntimeException)jjte005;
}
if (jjte005 instanceof ParseException) {
throw (ParseException)jjte005;
}
throw (Error)jjte005;
} finally {
if (jjtc005) {
jjtree.closeNodeScope(jjtn005, 2);
}
}
/*@egen*/
|
"not" "in"/*@bgen(jjtree) #NotIn( 2) */
{
ASTNotIn jjtn006 = new ASTNotIn(JJTNOTIN);
boolean jjtc006 = true;
jjtree.openNodeScope(jjtn006);
}
try {
/*@egen*/ shiftExpression()/*@bgen(jjtree)*/
} catch (Throwable jjte006) {
if (jjtc006) {
jjtree.clearNodeScope(jjtn006);
jjtc006 = false;
} else {
jjtree.popNode();
}
if (jjte006 instanceof RuntimeException) {
throw (RuntimeException)jjte006;
}
if (jjte006 instanceof ParseException) {
throw (ParseException)jjte006;
}
throw (Error)jjte006;
} finally {
if (jjtc006) {
jjtree.closeNodeScope(jjtn006, 2);
}
}
/*@egen*/
)*
}
// bit shift expressions (level 4)
void shiftExpression() : {}
{
additiveExpression()
(
("<<" | "shl")/*@bgen(jjtree) #ShiftLeft( 2) */
{
ASTShiftLeft jjtn001 = new ASTShiftLeft(JJTSHIFTLEFT);
boolean jjtc001 = true;
jjtree.openNodeScope(jjtn001);
}
try {
/*@egen*/ additiveExpression()/*@bgen(jjtree)*/
} catch (Throwable jjte001) {
if (jjtc001) {
jjtree.clearNodeScope(jjtn001);
jjtc001 = false;
} else {
jjtree.popNode();
}
if (jjte001 instanceof RuntimeException) {
throw (RuntimeException)jjte001;
}
if (jjte001 instanceof ParseException) {
throw (ParseException)jjte001;
}
throw (Error)jjte001;
} finally {
if (jjtc001) {
jjtree.closeNodeScope(jjtn001, 2);
}
}
/*@egen*/
|
(">>" | "shr")/*@bgen(jjtree) #ShiftRight( 2) */
{
ASTShiftRight jjtn002 = new ASTShiftRight(JJTSHIFTRIGHT);
boolean jjtc002 = true;
jjtree.openNodeScope(jjtn002);
}
try {
/*@egen*/ additiveExpression()/*@bgen(jjtree)*/
} catch (Throwable jjte002) {
if (jjtc002) {
jjtree.clearNodeScope(jjtn002);
jjtc002 = false;
} else {
jjtree.popNode();
}
if (jjte002 instanceof RuntimeException) {
throw (RuntimeException)jjte002;
}
if (jjte002 instanceof ParseException) {
throw (ParseException)jjte002;
}
throw (Error)jjte002;
} finally {
if (jjtc002) {
jjtree.closeNodeScope(jjtn002, 2);
}
}
/*@egen*/
|
(">>>" | "ushr")/*@bgen(jjtree) #UnsignedShiftRight( 2) */
{
ASTUnsignedShiftRight jjtn003 = new ASTUnsignedShiftRight(JJTUNSIGNEDSHIFTRIGHT);
boolean jjtc003 = true;
jjtree.openNodeScope(jjtn003);
}
try {
/*@egen*/ additiveExpression()/*@bgen(jjtree)*/
} catch (Throwable jjte003) {
if (jjtc003) {
jjtree.clearNodeScope(jjtn003);
jjtc003 = false;
} else {
jjtree.popNode();
}
if (jjte003 instanceof RuntimeException) {
throw (RuntimeException)jjte003;
}
if (jjte003 instanceof ParseException) {
throw (ParseException)jjte003;
}
throw (Error)jjte003;
} finally {
if (jjtc003) {
jjtree.closeNodeScope(jjtn003, 2);
}
}
/*@egen*/
)*
}
// binary addition/subtraction (level 3)
void additiveExpression() : {}
{
multiplicativeExpression()
(
"+"/*@bgen(jjtree) #Add( 2) */
{
ASTAdd jjtn001 = new ASTAdd(JJTADD);
boolean jjtc001 = true;
jjtree.openNodeScope(jjtn001);
}
try {
/*@egen*/ multiplicativeExpression()/*@bgen(jjtree)*/
} catch (Throwable jjte001) {
if (jjtc001) {
jjtree.clearNodeScope(jjtn001);
jjtc001 = false;
} else {
jjtree.popNode();
}
if (jjte001 instanceof RuntimeException) {
throw (RuntimeException)jjte001;
}
if (jjte001 instanceof ParseException) {
throw (ParseException)jjte001;
}
throw (Error)jjte001;
} finally {
if (jjtc001) {
jjtree.closeNodeScope(jjtn001, 2);
}
}
/*@egen*/
|
"-"/*@bgen(jjtree) #Subtract( 2) */
{
ASTSubtract jjtn002 = new ASTSubtract(JJTSUBTRACT);
boolean jjtc002 = true;
jjtree.openNodeScope(jjtn002);
}
try {
/*@egen*/ multiplicativeExpression()/*@bgen(jjtree)*/
} catch (Throwable jjte002) {
if (jjtc002) {
jjtree.clearNodeScope(jjtn002);
jjtc002 = false;
} else {
jjtree.popNode();
}
if (jjte002 instanceof RuntimeException) {
throw (RuntimeException)jjte002;
}
if (jjte002 instanceof ParseException) {
throw (ParseException)jjte002;
}
throw (Error)jjte002;
} finally {
if (jjtc002) {
jjtree.closeNodeScope(jjtn002, 2);
}
}
/*@egen*/
)*
}
// multiplication/division/remainder (level 2)
void multiplicativeExpression() : {}
{
unaryExpression()
(
"*"/*@bgen(jjtree) #Multiply( 2) */
{
ASTMultiply jjtn001 = new ASTMultiply(JJTMULTIPLY);
boolean jjtc001 = true;
jjtree.openNodeScope(jjtn001);
}
try {
/*@egen*/ unaryExpression()/*@bgen(jjtree)*/
} catch (Throwable jjte001) {
if (jjtc001) {
jjtree.clearNodeScope(jjtn001);
jjtc001 = false;
} else {
jjtree.popNode();
}
if (jjte001 instanceof RuntimeException) {
throw (RuntimeException)jjte001;
}
if (jjte001 instanceof ParseException) {
throw (ParseException)jjte001;
}
throw (Error)jjte001;
} finally {
if (jjtc001) {
jjtree.closeNodeScope(jjtn001, 2);
}
}
/*@egen*/
|
"/"/*@bgen(jjtree) #Divide( 2) */
{
ASTDivide jjtn002 = new ASTDivide(JJTDIVIDE);
boolean jjtc002 = true;
jjtree.openNodeScope(jjtn002);
}
try {
/*@egen*/ unaryExpression()/*@bgen(jjtree)*/
} catch (Throwable jjte002) {
if (jjtc002) {
jjtree.clearNodeScope(jjtn002);
jjtc002 = false;
} else {
jjtree.popNode();
}
if (jjte002 instanceof RuntimeException) {
throw (RuntimeException)jjte002;
}
if (jjte002 instanceof ParseException) {
throw (ParseException)jjte002;
}
throw (Error)jjte002;
} finally {
if (jjtc002) {
jjtree.closeNodeScope(jjtn002, 2);
}
}
/*@egen*/
|
"%"/*@bgen(jjtree) #Remainder( 2) */
{
ASTRemainder jjtn003 = new ASTRemainder(JJTREMAINDER);
boolean jjtc003 = true;
jjtree.openNodeScope(jjtn003);
}
try {
/*@egen*/ unaryExpression()/*@bgen(jjtree)*/
} catch (Throwable jjte003) {
if (jjtc003) {
jjtree.clearNodeScope(jjtn003);
jjtc003 = false;
} else {
jjtree.popNode();
}
if (jjte003 instanceof RuntimeException) {
throw (RuntimeException)jjte003;
}
if (jjte003 instanceof ParseException) {
throw (ParseException)jjte003;
}
throw (Error)jjte003;
} finally {
if (jjtc003) {
jjtree.closeNodeScope(jjtn003, 2);
}
}
/*@egen*/
)*
}
// unary (level 1)
void unaryExpression() : {
StringBuffer sb;
Token t;
ASTInstanceof ionode;
}
{
(
"-"/*@bgen(jjtree) #Negate( 1) */
{
ASTNegate jjtn001 = new ASTNegate(JJTNEGATE);
boolean jjtc001 = true;
jjtree.openNodeScope(jjtn001);
}
try {
/*@egen*/ unaryExpression()/*@bgen(jjtree)*/
} catch (Throwable jjte001) {
if (jjtc001) {
jjtree.clearNodeScope(jjtn001);
jjtc001 = false;
} else {
jjtree.popNode();
}
if (jjte001 instanceof RuntimeException) {
throw (RuntimeException)jjte001;
}
if (jjte001 instanceof ParseException) {
throw (ParseException)jjte001;
}
throw (Error)jjte001;
} finally {
if (jjtc001) {
jjtree.closeNodeScope(jjtn001, 1);
}
}
/*@egen*/
|
"+" unaryExpression() // Just leave it there
|
"~"/*@bgen(jjtree) #BitNegate( 1) */
{
ASTBitNegate jjtn002 = new ASTBitNegate(JJTBITNEGATE);
boolean jjtc002 = true;
jjtree.openNodeScope(jjtn002);
}
try {
/*@egen*/ unaryExpression()/*@bgen(jjtree)*/
} catch (Throwable jjte002) {
if (jjtc002) {
jjtree.clearNodeScope(jjtn002);
jjtc002 = false;
} else {
jjtree.popNode();
}
if (jjte002 instanceof RuntimeException) {
throw (RuntimeException)jjte002;
}
if (jjte002 instanceof ParseException) {
throw (ParseException)jjte002;
}
throw (Error)jjte002;
} finally {
if (jjtc002) {
jjtree.closeNodeScope(jjtn002, 1);
}
}
/*@egen*/
|
("!" | "not")/*@bgen(jjtree) #Not( 1) */
{
ASTNot jjtn003 = new ASTNot(JJTNOT);
boolean jjtc003 = true;
jjtree.openNodeScope(jjtn003);
}
try {
/*@egen*/ unaryExpression()/*@bgen(jjtree)*/
} catch (Throwable jjte003) {
if (jjtc003) {
jjtree.clearNodeScope(jjtn003);
jjtc003 = false;
} else {
jjtree.popNode();
}
if (jjte003 instanceof RuntimeException) {
throw (RuntimeException)jjte003;
}
if (jjte003 instanceof ParseException) {
throw (ParseException)jjte003;
}
throw (Error)jjte003;
} finally {
if (jjtc003) {
jjtree.closeNodeScope(jjtn003, 1);
}
}
/*@egen*/
|
navigationChain()
[
"instanceof"
t = /*@bgen(jjtree) #Instanceof( 1) */
{
ASTInstanceof jjtn004 = new ASTInstanceof(JJTINSTANCEOF);
boolean jjtc004 = true;
jjtree.openNodeScope(jjtn004);
}
try {
/*@egen*//*@bgen(jjtree)*/
{
jjtree.closeNodeScope(jjtn004, 1);
jjtc004 = false;
}
/*@egen*/ { sb = new StringBuffer(t.image); ionode = jjtn004; }/*@bgen(jjtree)*/
} finally {
if (jjtc004) {
jjtree.closeNodeScope(jjtn004, 1);
}
}
/*@egen*/
( "." t = { sb.append('.').append( t.image ); }
)* { ionode.setTargetType( new String(sb) ); }
]
)
}
// navigation chain: property references, method calls, projections, selections, etc.
void navigationChain() : {}
{
primaryExpression()
( "."/*@bgen(jjtree) #Chain( 2) */
{
ASTChain jjtn001 = new ASTChain(JJTCHAIN);
boolean jjtc001 = true;
jjtree.openNodeScope(jjtn001);
}
try {
/*@egen*/
( /* Prevent the "eval" ambiguity from issuing a warning; see discussion below. */
( LOOKAHEAD(2) methodCall() | propertyName() )
// Also handle "{", which requires a lookahead of 2.
| ( LOOKAHEAD(2) projection() | selection() )
| "(" expression() ")"
)/*@bgen(jjtree)*/
} catch (Throwable jjte001) {
if (jjtc001) {
jjtree.clearNodeScope(jjtn001);
jjtc001 = false;
} else {
jjtree.popNode();
}
if (jjte001 instanceof RuntimeException) {
throw (RuntimeException)jjte001;
}
if (jjte001 instanceof ParseException) {
throw (ParseException)jjte001;
}
throw (Error)jjte001;
} finally {
if (jjtc001) {
jjtree.closeNodeScope(jjtn001, 2);
}
}
/*@egen*/
|/*@bgen(jjtree) #Chain( 2) */
{
ASTChain jjtn002 = new ASTChain(JJTCHAIN);
boolean jjtc002 = true;
jjtree.openNodeScope(jjtn002);
}
try {
/*@egen*/ index()/*@bgen(jjtree)*/
} catch (Throwable jjte002) {
if (jjtc002) {
jjtree.clearNodeScope(jjtn002);
jjtc002 = false;
} else {
jjtree.popNode();
}
if (jjte002 instanceof RuntimeException) {
throw (RuntimeException)jjte002;
}
if (jjte002 instanceof ParseException) {
throw (ParseException)jjte002;
}
throw (Error)jjte002;
} finally {
if (jjtc002) {
jjtree.closeNodeScope(jjtn002, 2);
}
}
/*@egen*/
| "(" expression()/*@bgen(jjtree) #Eval( 2) */
{
ASTEval jjtn003 = new ASTEval(JJTEVAL);
boolean jjtc003 = true;
jjtree.openNodeScope(jjtn003);
}
try {
/*@egen*/ ")"/*@bgen(jjtree)*/
} finally {
if (jjtc003) {
jjtree.closeNodeScope(jjtn003, 2);
}
}
/*@egen*/
/* Using parentheses to indicate evaluation of the current
object makes this language ambiguous, because the
expression "ident(args)" could be seen as a single
method call or as a property name followed by an
evaluation. We always put the method call first and
turn off the ambiguity warning; we always want to
interpret this as a method call. */
)*
}
void primaryExpression() : {
Token t;
String className = null;
}
{
(
( | | | | )/*@bgen(jjtree) #Const( 0) */
{
ASTConst jjtn001 = new ASTConst(JJTCONST);
boolean jjtc001 = true;
jjtree.openNodeScope(jjtn001);
}
try {
/*@egen*//*@bgen(jjtree)*/
{
jjtree.closeNodeScope(jjtn001, 0);
jjtc001 = false;
}
/*@egen*/
{ jjtn001.setValue( token_source.literalValue ); }/*@bgen(jjtree)*/
} finally {
if (jjtc001) {
jjtree.closeNodeScope(jjtn001, 0);
}
}
/*@egen*/
|
"true"/*@bgen(jjtree) #Const( 0) */
{
ASTConst jjtn002 = new ASTConst(JJTCONST);
boolean jjtc002 = true;
jjtree.openNodeScope(jjtn002);
}
try {
/*@egen*//*@bgen(jjtree)*/
{
jjtree.closeNodeScope(jjtn002, 0);
jjtc002 = false;
}
/*@egen*/ { jjtn002.setValue( Boolean.TRUE ); }/*@bgen(jjtree)*/
} finally {
if (jjtc002) {
jjtree.closeNodeScope(jjtn002, 0);
}
}
/*@egen*/
|
"false"/*@bgen(jjtree) #Const( 0) */
{
ASTConst jjtn003 = new ASTConst(JJTCONST);
boolean jjtc003 = true;
jjtree.openNodeScope(jjtn003);
}
try {
/*@egen*//*@bgen(jjtree)*/
{
jjtree.closeNodeScope(jjtn003, 0);
jjtc003 = false;
}
/*@egen*/ { jjtn003.setValue( Boolean.FALSE ); }/*@bgen(jjtree)*/
} finally {
if (jjtc003) {
jjtree.closeNodeScope(jjtn003, 0);
}
}
/*@egen*/
|/*@bgen(jjtree) #Const( 0) */
{
ASTConst jjtn004 = new ASTConst(JJTCONST);
boolean jjtc004 = true;
jjtree.openNodeScope(jjtn004);
}
try {
/*@egen*/
"null"/*@bgen(jjtree)*/
} finally {
if (jjtc004) {
jjtree.closeNodeScope(jjtn004, 0);
}
}
/*@egen*/ // Null is the default value in an ASTConst
|
LOOKAHEAD(2) "#this"/*@bgen(jjtree) #ThisVarRef( 0) */
{
ASTThisVarRef jjtn005 = new ASTThisVarRef(JJTTHISVARREF);
boolean jjtc005 = true;
jjtree.openNodeScope(jjtn005);
}
try {
/*@egen*//*@bgen(jjtree)*/
{
jjtree.closeNodeScope(jjtn005, 0);
jjtc005 = false;
}
/*@egen*/ { jjtn005.setName( "this" ); }/*@bgen(jjtree)*/
} finally {
if (jjtc005) {
jjtree.closeNodeScope(jjtn005, 0);
}
}
/*@egen*/
|
LOOKAHEAD(2) "#root"/*@bgen(jjtree) #RootVarRef( 0) */
{
ASTRootVarRef jjtn006 = new ASTRootVarRef(JJTROOTVARREF);
boolean jjtc006 = true;
jjtree.openNodeScope(jjtn006);
}
try {
/*@egen*//*@bgen(jjtree)*/
{
jjtree.closeNodeScope(jjtn006, 0);
jjtc006 = false;
}
/*@egen*/ { jjtn006.setName( "root" ); }/*@bgen(jjtree)*/
} finally {
if (jjtc006) {
jjtree.closeNodeScope(jjtn006, 0);
}
}
/*@egen*/
|
LOOKAHEAD(2) "#" t=/*@bgen(jjtree) #VarRef( 0) */
{
ASTVarRef jjtn007 = new ASTVarRef(JJTVARREF);
boolean jjtc007 = true;
jjtree.openNodeScope(jjtn007);
}
try {
/*@egen*//*@bgen(jjtree)*/
{
jjtree.closeNodeScope(jjtn007, 0);
jjtc007 = false;
}
/*@egen*/ { jjtn007.setName( t.image ); }/*@bgen(jjtree)*/
} finally {
if (jjtc007) {
jjtree.closeNodeScope(jjtn007, 0);
}
}
/*@egen*/
|
LOOKAHEAD(2) ":" "[" expression() "]"/*@bgen(jjtree) #Const( 1) */
{
ASTConst jjtn008 = new ASTConst(JJTCONST);
boolean jjtc008 = true;
jjtree.openNodeScope(jjtn008);
}
try {
/*@egen*//*@bgen(jjtree)*/
{
jjtree.closeNodeScope(jjtn008, 1);
jjtc008 = false;
}
/*@egen*/ { jjtn008.setValue( jjtn008.jjtGetChild(0) ); }/*@bgen(jjtree)*/
} finally {
if (jjtc008) {
jjtree.closeNodeScope(jjtn008, 1);
}
}
/*@egen*/
|
staticReference()
|
LOOKAHEAD(2) constructorCall()
|
// Prevent the "eval" ambiguity from issuing a warning; see discussion elsewhere.
( LOOKAHEAD(2) methodCall() | propertyName() )
|
index()
|
"(" expression() ")"
|
"{"/*@bgen(jjtree) List */
{
ASTList jjtn009 = new ASTList(JJTLIST);
boolean jjtc009 = true;
jjtree.openNodeScope(jjtn009);
}
try {
/*@egen*/ [assignmentExpression() ("," assignmentExpression())*]/*@bgen(jjtree)*/
} catch (Throwable jjte009) {
if (jjtc009) {
jjtree.clearNodeScope(jjtn009);
jjtc009 = false;
} else {
jjtree.popNode();
}
if (jjte009 instanceof RuntimeException) {
throw (RuntimeException)jjte009;
}
if (jjte009 instanceof ParseException) {
throw (ParseException)jjte009;
}
throw (Error)jjte009;
} finally {
if (jjtc009) {
jjtree.closeNodeScope(jjtn009, true);
}
}
/*@egen*/ "}"
|
LOOKAHEAD(2)/*@bgen(jjtree) Map */
{
ASTMap jjtn010 = new ASTMap(JJTMAP);
boolean jjtc010 = true;
jjtree.openNodeScope(jjtn010);
}
try {
/*@egen*/ ( "#" (className=classReference())? "{" [keyValueExpression() ("," keyValueExpression())*] { jjtn010.setClassName(className); } "}" )/*@bgen(jjtree)*/
} catch (Throwable jjte010) {
if (jjtc010) {
jjtree.clearNodeScope(jjtn010);
jjtc010 = false;
} else {
jjtree.popNode();
}
if (jjte010 instanceof RuntimeException) {
throw (RuntimeException)jjte010;
}
if (jjte010 instanceof ParseException) {
throw (ParseException)jjte010;
}
throw (Error)jjte010;
} finally {
if (jjtc010) {
jjtree.closeNodeScope(jjtn010, true);
}
}
/*@egen*/
)
}
void keyValueExpression() : {}
{/*@bgen(jjtree) KeyValue */
{
ASTKeyValue jjtn001 = new ASTKeyValue(JJTKEYVALUE);
boolean jjtc001 = true;
jjtree.openNodeScope(jjtn001);
}
try {
/*@egen*/
( assignmentExpression() (":" assignmentExpression())? )/*@bgen(jjtree)*/
} catch (Throwable jjte001) {
if (jjtc001) {
jjtree.clearNodeScope(jjtn001);
jjtc001 = false;
} else {
jjtree.popNode();
}
if (jjte001 instanceof RuntimeException) {
throw (RuntimeException)jjte001;
}
if (jjte001 instanceof ParseException) {
throw (ParseException)jjte001;
}
throw (Error)jjte001;
} finally {
if (jjtc001) {
jjtree.closeNodeScope(jjtn001, true);
}
}
/*@egen*/
}
void staticReference() : {
String className = "java.lang.Math";
Token t;
}
{
className=classReference()
( // Prevent the "eval" ambiguity from issuing a warning; see discussion elsewhere.
LOOKAHEAD(2)
staticMethodCall( className )
|
t=/*@bgen(jjtree) #StaticField( 0) */
{
ASTStaticField jjtn001 = new ASTStaticField(JJTSTATICFIELD);
boolean jjtc001 = true;
jjtree.openNodeScope(jjtn001);
}
try {
/*@egen*//*@bgen(jjtree)*/
{
jjtree.closeNodeScope(jjtn001, 0);
jjtc001 = false;
}
/*@egen*/ { jjtn001.init( className, t.image ); }/*@bgen(jjtree)*/
} finally {
if (jjtc001) {
jjtree.closeNodeScope(jjtn001, 0);
}
}
/*@egen*/
)
}
String classReference(): {
String result = "java.lang.Math";
}
{
"@" ( result=className() )? "@" { return result; }
}
String className(): {
Token t;
StringBuffer result;
}
{
t= { result = new StringBuffer( t.image ); }
( "." t= { result.append('.').append( t.image ); }
)* { return new String(result); }
}
void constructorCall() : {/*@bgen(jjtree) Ctor */
ASTCtor jjtn000 = new ASTCtor(JJTCTOR);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/
String className;
Token t;
StringBuffer sb;
}
{/*@bgen(jjtree) Ctor */
try {
/*@egen*/
"new" className=className()
(
LOOKAHEAD(2) (
"(" [ assignmentExpression() ( "," assignmentExpression() )* ] ")"/*@bgen(jjtree)*/
{
jjtree.closeNodeScope(jjtn000, true);
jjtc000 = false;
}
/*@egen*/
{
jjtn000.setClassName(className);
}
)
|
LOOKAHEAD(2) (
"[" "]" "{"/*@bgen(jjtree) List */
{
ASTList jjtn001 = new ASTList(JJTLIST);
boolean jjtc001 = true;
jjtree.openNodeScope(jjtn001);
}
try {
/*@egen*/ [assignmentExpression() ("," assignmentExpression())*]/*@bgen(jjtree)*/
} catch (Throwable jjte001) {
if (jjtc001) {
jjtree.clearNodeScope(jjtn001);
jjtc001 = false;
} else {
jjtree.popNode();
}
if (jjte001 instanceof RuntimeException) {
throw (RuntimeException)jjte001;
}
if (jjte001 instanceof ParseException) {
throw (ParseException)jjte001;
}
throw (Error)jjte001;
} finally {
if (jjtc001) {
jjtree.closeNodeScope(jjtn001, true);
}
}
/*@egen*/ "}"/*@bgen(jjtree)*/
{
jjtree.closeNodeScope(jjtn000, true);
jjtc000 = false;
}
/*@egen*/
{
jjtn000.setClassName(className);
jjtn000.setArray(true);
}
)
|
LOOKAHEAD(2) (
"[" assignmentExpression() "]"/*@bgen(jjtree)*/
{
jjtree.closeNodeScope(jjtn000, true);
jjtc000 = false;
}
/*@egen*/
{
jjtn000.setClassName(className);
jjtn000.setArray(true);
}
)
)/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
void propertyName() : {/*@bgen(jjtree) Property */
ASTProperty jjtn000 = new ASTProperty(JJTPROPERTY);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/
Token t;
}
{/*@bgen(jjtree) Property */
try {
/*@egen*/
t=/*@bgen(jjtree) Const */
{
ASTConst jjtn001 = new ASTConst(JJTCONST);
boolean jjtc001 = true;
jjtree.openNodeScope(jjtn001);
}
try {
/*@egen*//*@bgen(jjtree)*/
{
jjtree.closeNodeScope(jjtn001, true);
jjtc001 = false;
}
/*@egen*/ { jjtn001.setValue( t.image ); }/*@bgen(jjtree)*/
} finally {
if (jjtc001) {
jjtree.closeNodeScope(jjtn001, true);
}
}
/*@egen*/ /*@bgen(jjtree)*/
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
void staticMethodCall( String className ) : {/*@bgen(jjtree) StaticMethod */
ASTStaticMethod jjtn000 = new ASTStaticMethod(JJTSTATICMETHOD);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/
Token t;
}
{/*@bgen(jjtree) StaticMethod */
try {
/*@egen*/
t= "(" [ assignmentExpression() ( "," assignmentExpression() )* ] ")"/*@bgen(jjtree)*/
{
jjtree.closeNodeScope(jjtn000, true);
jjtc000 = false;
}
/*@egen*/
{ jjtn000.init( className, t.image ); }/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
void methodCall() : {/*@bgen(jjtree) Method */
ASTMethod jjtn000 = new ASTMethod(JJTMETHOD);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/
Token t;
}
{/*@bgen(jjtree) Method */
try {
/*@egen*/
t= "(" [ assignmentExpression() ( "," assignmentExpression() )* ] ")"/*@bgen(jjtree)*/
{
jjtree.closeNodeScope(jjtn000, true);
jjtc000 = false;
}
/*@egen*/
{ jjtn000.setMethodName( t.image ); }/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
/**
* Apply an expression to all elements of a collection, creating a new collection
* as the result.
*/
void projection() : {/*@bgen(jjtree) Project */
ASTProject jjtn000 = new ASTProject(JJTPROJECT);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) Project */
try {
/*@egen*/
"{" expression() "}"/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
void selection() : {}
{
LOOKAHEAD(2) selectAll()
|
LOOKAHEAD(2) selectFirst()
|
LOOKAHEAD(2) selectLast()
}
/**
* Apply a boolean expression to all elements of a collection, creating a new collection
* containing those elements for which the expression returned true.
*/
void selectAll() : {/*@bgen(jjtree) Select */
ASTSelect jjtn000 = new ASTSelect(JJTSELECT);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) Select */
try {
/*@egen*/
"{" "?" expression() "}"/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
/**
* Apply a boolean expression to all elements of a collection, creating a new collection
* containing those elements for the first element for which the expression returned true.
*/
void selectFirst() : {/*@bgen(jjtree) SelectFirst */
ASTSelectFirst jjtn000 = new ASTSelectFirst(JJTSELECTFIRST);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) SelectFirst */
try {
/*@egen*/
"{" "^" expression() "}"/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
/**
* Apply a boolean expression to all elements of a collection, creating a new collection
* containing those elements for the first element for which the expression returned true.
*/
void selectLast() : {/*@bgen(jjtree) SelectLast */
ASTSelectLast jjtn000 = new ASTSelectLast(JJTSELECTLAST);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) SelectLast */
try {
/*@egen*/
"{" "$" expression() "}"/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
void index() : {/*@bgen(jjtree) Property */
ASTProperty jjtn000 = new ASTProperty(JJTPROPERTY);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) Property */
try {
/*@egen*/
"[" expression() "]"/*@bgen(jjtree)*/
{
jjtree.closeNodeScope(jjtn000, true);
jjtc000 = false;
}
/*@egen*/ { jjtn000.setIndexedAccess(true); }
|
/*@bgen(jjtree) Const */
{
ASTConst jjtn001 = new ASTConst(JJTCONST);
boolean jjtc001 = true;
jjtree.openNodeScope(jjtn001);
}
try {
/*@egen*//*@bgen(jjtree)*/
{
jjtree.closeNodeScope(jjtn001, true);
jjtc001 = false;
}
/*@egen*/ { jjtn001.setValue( token_source.literalValue ); }/*@bgen(jjtree)*/
} finally {
if (jjtc001) {
jjtree.closeNodeScope(jjtn001, true);
}
}
/*@egen*/ /*@bgen(jjtree)*/
{
jjtree.closeNodeScope(jjtn000, true);
jjtc000 = false;
}
/*@egen*/
{
jjtn000.setIndexedAccess(true);
}/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
// LEXER PRODUCTIONS
TOKEN_MGR_DECLS:
{
/** Holds the last value computed by a constant token. */
Object literalValue;
/** Holds the last character escaped or in a character literal. */
private char charValue;
/** Holds char literal start token. */
private char charLiteralStartQuote;
/** Holds the last string literal parsed. */
private StringBuffer stringBuffer;
/** Converts an escape sequence into a character value. */
private char escapeChar()
{
int ofs = image.length() - 1;
switch ( image.charAt(ofs) ) {
case 'n': return '\n';
case 'r': return '\r';
case 't': return '\t';
case 'b': return '\b';
case 'f': return '\f';
case '\\': return '\\';
case '\'': return '\'';
case '\"': return '\"';
}
// Otherwise, it's an octal number. Find the backslash and convert.
while ( image.charAt(--ofs) != '\\' )
{}
int value = 0;
while ( ++ofs < image.length() )
value = (value << 3) | (image.charAt(ofs) - '0');
return (char) value;
}
private Object makeInt()
{
Object result;
String s = image.toString();
int base = 10;
if ( s.charAt(0) == '0' )
base = (s.length() > 1 && (s.charAt(1) == 'x' || s.charAt(1) == 'X'))? 16 : 8;
if ( base == 16 )
s = s.substring(2); // Trim the 0x off the front
switch ( s.charAt(s.length()-1) ) {
case 'l': case 'L':
result = Long.valueOf( s.substring(0,s.length()-1), base );
break;
case 'h': case 'H':
result = new BigInteger( s.substring(0,s.length()-1), base );
break;
default:
result = Integer.valueOf( s, base );
break;
}
return result;
}
private Object makeFloat()
{
String s = image.toString();
switch ( s.charAt(s.length()-1) ) {
case 'f': case 'F':
return Float.valueOf( s );
case 'b': case 'B':
return new BigDecimal( s.substring(0,s.length()-1) );
case 'd': case 'D':
default:
return Double.valueOf( s );
}
}
}
// Whitespace -- ignored
SKIP:
{ " " | "\t" | "\f" | "\r" | "\n" }
// An identifier.
TOKEN:
{
< IDENT: (|)* >
|
< #LETTER: [
"$",
"A"-"Z",
"_",
"a"-"z",
"\u00c0"-"\u00d6",
"\u00d8"-"\u00f6",
"\u00f8"-"\u00ff",
"\u0100"-"\u1fff",
"\u3040"-"\u318f",
"\u3300"-"\u337f",
"\u3400"-"\u3d2d",
"\u4e00"-"\u9fff",
"\uf900"-"\ufaff"
] >
|
< #DIGIT:
[
"0"-"9",
"\u0660"-"\u0669",
"\u06f0"-"\u06f9",
"\u0966"-"\u096f",
"\u09e6"-"\u09ef",
"\u0a66"-"\u0a6f",
"\u0ae6"-"\u0aef",
"\u0b66"-"\u0b6f",
"\u0be7"-"\u0bef",
"\u0c66"-"\u0c6f",
"\u0ce6"-"\u0cef",
"\u0d66"-"\u0d6f",
"\u0e50"-"\u0e59",
"\u0ed0"-"\u0ed9",
"\u1040"-"\u1049"
] >
}
/**
* Token for "dynamic subscripts", which are one of: [^], [|], [$], and [*]. The
* appropriate constant from the DynamicSubscript class is stored in the token manager's
* "value" field.
*/
TOKEN:
{
< DYNAMIC_SUBSCRIPT: "[" ["^","|","$","*"] "]" >
{
switch (image.charAt(1)) {
case '^': literalValue = DynamicSubscript.first; break;
case '|': literalValue = DynamicSubscript.mid; break;
case '$': literalValue = DynamicSubscript.last; break;
case '*': literalValue = DynamicSubscript.all; break;
}
}
}
/**
* Character and string literals, whose object value is stored in the token manager's
* "literalValue" field.
*/
MORE:
{
"`" : WithinBackCharLiteral
|
"'" { stringBuffer = new StringBuffer(); }: WithinCharLiteral
|
"\"" { stringBuffer = new StringBuffer(); }: WithinStringLiteral
}
MORE:
{
< ESC: "\\" ( ["n","r","t","b","f","\\","'","`","\""]
| (["0"-"3"])? ["0"-"7"] (["0"-"7"])?
)
>
{ charValue = escapeChar(); stringBuffer.append(charValue); }
|
< (~["'","\\"]) >
{ charValue = image.charAt( image.length()-1 ); stringBuffer.append(charValue); }
}
TOKEN:
{
< CHAR_LITERAL: "'">
{
if (stringBuffer.length() == 1) {
literalValue = new Character( charValue );
} else {
literalValue = new String( stringBuffer );
}
}
: DEFAULT
}
MORE:
{
< BACK_CHAR_ESC: >
{ charValue = escapeChar(); }
|
< (~["`","\\"]) >
{ charValue = image.charAt( image.length()-1 ); }
}
TOKEN:
{
< BACK_CHAR_LITERAL: "`">
{ literalValue = new Character( charValue ); }: DEFAULT
}
MORE:
{
< STRING_ESC: >
{ stringBuffer.append( escapeChar() ); }
|
< (~["\"","\\"]) >
{ stringBuffer.append( image.charAt(image.length()-1) ); }
}
TOKEN:
{
{ literalValue = new String( stringBuffer ); }
: DEFAULT
}
/**
* Integer or real Numeric literal, whose object value is stored in the token manager's
* "literalValue" field.
*/
TOKEN:
{
< INT_LITERAL:
( "0" (["0"-"7"])* | ["1"-"9"] (["0"-"9"])* | "0" ["x","X"] (["0"-"9","a"-"f","A"-"F"])+ )
(["l","L","h","H"])?
>
{ literalValue =
makeInt(); }
|
< FLT_LITERAL:
( ()? ()?
| ()?
|
)
>
{ literalValue = makeFloat(); }
| < #DEC_FLT: (["0"-"9"])+ "." (["0"-"9"])* | "." (["0"-"9"])+ >
| < #DEC_DIGITS: (["0"-"9"])+ >
| < #EXPONENT: ["e","E"] (["+","-"])? (["0"-"9"])+ >
| < #FLT_SUFF: ["d","D","f","F","b","B"] >
}
ognl-2.7.3.orig/src/java/ognl/ASTSequence.java 0000644 0001750 0001750 00000012575 10720374205 020761 0 ustar drazzib drazzib //--------------------------------------------------------------------------
// Copyright (c) 1998-2004, Drew Davidson and Luke Blanshard
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
// Neither the name of the Drew Davidson nor the names of its contributors
// may be used to endorse or promote products derived from this software
// without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
// COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
// OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
// AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
// DAMAGE.
//--------------------------------------------------------------------------
package ognl;
import ognl.enhance.ExpressionCompiler;
import ognl.enhance.OrderedReturn;
/**
* @author Luke Blanshard (blanshlu@netscape.net)
* @author Drew Davidson (drew@ognl.org)
*/
public class ASTSequence extends SimpleNode implements NodeType, OrderedReturn
{
private Class _getterClass;
private String _lastExpression;
private String _coreExpression;
public ASTSequence(int id) {
super(id);
}
public ASTSequence(OgnlParser p, int id) {
super(p, id);
}
public void jjtClose() {
flattenTree();
}
protected Object getValueBody( OgnlContext context, Object source ) throws OgnlException
{
Object result = null;
for ( int i=0; i < _children.length; ++i )
{
result = _children[i].getValue( context, source );
}
return result; // The result is just the last one we saw.
}
protected void setValueBody( OgnlContext context, Object target, Object value ) throws OgnlException {
int last = _children.length - 1;
for ( int i=0; i < last; ++i ) {
_children[i].getValue( context, target );
}
_children[last].setValue( context, target, value );
}
public Class getGetterClass()
{
return _getterClass;
}
public Class getSetterClass()
{
return null;
}
public String getLastExpression()
{
return _lastExpression;
}
public String getCoreExpression()
{
return _coreExpression;
}
public String toString()
{
String result = "";
for ( int i=0; i < _children.length; ++i ) {
if (i > 0) {
result = result + ", ";
}
result = result + _children[i];
}
return result;
}
public String toSetSourceString(OgnlContext context, Object target)
{
return "";
}
public String toGetSourceString(OgnlContext context, Object target)
{
String result = "";
NodeType _lastType = null;
for (int i = 0; i < _children.length; ++i)
{
//System.out.println("astsequence child : " + _children[i].getClass().getName());
String seqValue = _children[i].toGetSourceString(context, target);
if ((i + 1) < _children.length
&& ASTOr.class.isInstance(_children[i])) {
seqValue = "(" + seqValue + ")";
}
if (i > 0 && ASTProperty.class.isInstance(_children[i])
&& seqValue != null && seqValue.trim().length() > 0)
{
String pre = (String)context.get("_currentChain");
if (pre == null)
pre = "";
seqValue = ExpressionCompiler.getRootExpression(_children[i], context.getRoot(), context) + pre + seqValue;
context.setCurrentAccessor(context.getRoot().getClass());
}
if ((i + 1) >= _children.length)
{
_coreExpression = result;
_lastExpression = seqValue;
}
if (seqValue != null && seqValue.trim().length() > 0 && (i + 1) < _children.length)
result += seqValue + ";";
else if (seqValue != null && seqValue.trim().length() > 0)
result += seqValue;
// set last known type from last child with a type
if (NodeType.class.isInstance(_children[i]) && ((NodeType)_children[i]).getGetterClass() != null)
_lastType = (NodeType)_children[i];
}
if (_lastType != null)
{
_getterClass = _lastType.getGetterClass();
}
return result;
}
}
ognl-2.7.3.orig/src/java/ognl/ASTDivide.java 0000644 0001750 0001750 00000004535 10566476144 020427 0 ustar drazzib drazzib //--------------------------------------------------------------------------
// Copyright (c) 1998-2004, Drew Davidson and Luke Blanshard
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
// Neither the name of the Drew Davidson nor the names of its contributors
// may be used to endorse or promote products derived from this software
// without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
// COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
// OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
// AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
// DAMAGE.
//--------------------------------------------------------------------------
package ognl;
/**
* @author Luke Blanshard (blanshlu@netscape.net)
* @author Drew Davidson (drew@ognl.org)
*/
class ASTDivide extends NumericExpression
{
public ASTDivide(int id) {
super(id);
}
public ASTDivide(OgnlParser p, int id) {
super(p, id);
}
protected Object getValueBody( OgnlContext context, Object source ) throws OgnlException
{
Object v1 = _children[0].getValue( context, source );
Object v2 = _children[1].getValue( context, source );
return OgnlOps.divide( v1, v2 );
}
public String getExpressionOperator(int index)
{
return "/";
}
}
ognl-2.7.3.orig/src/java/ognl/NoSuchPropertyException.java 0000644 0001750 0001750 00000005502 10577301171 023456 0 ustar drazzib drazzib //--------------------------------------------------------------------------
// Copyright (c) 1998-2004, Drew Davidson and Luke Blanshard
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
// Neither the name of the Drew Davidson nor the names of its contributors
// may be used to endorse or promote products derived from this software
// without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
// COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
// OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
// AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
// DAMAGE.
//--------------------------------------------------------------------------
package ognl;
/**
* Exception thrown if a property is attempted to be extracted from an object that does
* not have such a property.
*
* @author Luke Blanshard (blanshlu@netscape.net)
* @author Drew Davidson (drew@ognl.org)
*/
public class NoSuchPropertyException extends OgnlException
{
private Object target;
private Object name;
public NoSuchPropertyException( Object target, Object name )
{
super( getReason(target, name) );
}
public NoSuchPropertyException( Object target, Object name, Throwable reason )
{
super( getReason(target, name), reason );
this.target = target;
this.name = name;
}
static String getReason(Object target, Object name)
{
String ret = null;
if (target == null)
ret = "null";
else if (target instanceof Class)
ret = ((Class)target).getName();
else
ret = target.getClass().getName();
ret += "." + name;
return ret;
}
public Object getTarget()
{
return target;
}
public Object getName()
{
return name;
}
}
ognl-2.7.3.orig/src/java/ognl/ASTShiftLeft.java 0000644 0001750 0001750 00000004545 10566476144 021114 0 ustar drazzib drazzib //--------------------------------------------------------------------------
// Copyright (c) 1998-2004, Drew Davidson and Luke Blanshard
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
// Neither the name of the Drew Davidson nor the names of its contributors
// may be used to endorse or promote products derived from this software
// without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
// COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
// OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
// AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
// DAMAGE.
//--------------------------------------------------------------------------
package ognl;
/**
* @author Luke Blanshard (blanshlu@netscape.net)
* @author Drew Davidson (drew@ognl.org)
*/
class ASTShiftLeft extends NumericExpression
{
public ASTShiftLeft(int id) {
super(id);
}
public ASTShiftLeft(OgnlParser p, int id) {
super(p, id);
}
protected Object getValueBody( OgnlContext context, Object source ) throws OgnlException
{
Object v1 = _children[0].getValue( context, source );
Object v2 = _children[1].getValue( context, source );
return OgnlOps.shiftLeft( v1, v2 );
}
public String getExpressionOperator(int index)
{
return "<<";
}
}
ognl-2.7.3.orig/src/java/ognl/ASTTest.java 0000644 0001750 0001750 00000012667 10655154670 020143 0 ustar drazzib drazzib //--------------------------------------------------------------------------
// Copyright (c) 1998-2004, Drew Davidson and Luke Blanshard
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
// Neither the name of the Drew Davidson nor the names of its contributors
// may be used to endorse or promote products derived from this software
// without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
// COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
// OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
// AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
// DAMAGE.
//--------------------------------------------------------------------------
package ognl;
import ognl.enhance.UnsupportedCompilationException;
/**
* @author Luke Blanshard (blanshlu@netscape.net)
* @author Drew Davidson (drew@ognl.org)
*/
class ASTTest extends ExpressionNode
{
public ASTTest(int id) {
super(id);
}
public ASTTest(OgnlParser p, int id) {
super(p, id);
}
protected Object getValueBody( OgnlContext context, Object source ) throws OgnlException
{
Object test = _children[0].getValue( context, source );
int branch = OgnlOps.booleanValue(test)? 1 : 2;
return _children[branch].getValue( context, source );
}
protected void setValueBody( OgnlContext context, Object target, Object value ) throws OgnlException
{
Object test = _children[0].getValue( context, target );
int branch = OgnlOps.booleanValue(test)? 1 : 2;
_children[branch].setValue( context, target, value );
}
public String getExpressionOperator(int index)
{
return (index == 1) ? "?" : ":";
}
public String toGetSourceString(OgnlContext context, Object target)
{
if (target == null)
throw new UnsupportedCompilationException("evaluation resulted in null expression.");
if (_children.length != 3)
throw new UnsupportedCompilationException("Can only compile test expressions with two children." + _children.length);
String result = "";
try {
String first = OgnlRuntime.getChildSource(context, target, _children[0]);
if (!OgnlRuntime.isBoolean(first) && !context.getCurrentType().isPrimitive())
first = OgnlRuntime.getCompiler().createLocalReference(context, first, context.getCurrentType());
if (ExpressionNode.class.isInstance(_children[0]))
{
first = "(" + first + ")";
}
String second = OgnlRuntime.getChildSource(context, target, _children[1]);
Class secondType = context.getCurrentType();
if (!OgnlRuntime.isBoolean(second) && !context.getCurrentType().isPrimitive())
second = OgnlRuntime.getCompiler().createLocalReference(context, second, context.getCurrentType());
if (ExpressionNode.class.isInstance(_children[1]))
{
second = "(" + second + ")";
}
String third = OgnlRuntime.getChildSource(context, target, _children[2]);
Class thirdType = context.getCurrentType();
if (!OgnlRuntime.isBoolean(third) && !context.getCurrentType().isPrimitive())
third = OgnlRuntime.getCompiler().createLocalReference(context, third, context.getCurrentType());
if (ExpressionNode.class.isInstance(_children[2]))
{
third = "(" + third + ")";
}
boolean mismatched = (secondType.isPrimitive() && !thirdType.isPrimitive())
|| (!secondType.isPrimitive() && thirdType.isPrimitive()) ? true : false;
result += "ognl.OgnlOps.booleanValue(" + first + ")";
result += " ? ";
result += (mismatched ? " ($w) " : "") + second;
result += " : ";
result += (mismatched ? " ($w) " : "") + third;
context.setCurrentObject(target);
context.setCurrentType(mismatched ? Object.class : secondType);
return result;
} catch (NullPointerException e) {
// expected to happen in some instances
throw new UnsupportedCompilationException("evaluation resulted in null expression.");
} catch (Throwable t)
{
throw OgnlOps.castToRuntime(t);
}
}
}
ognl-2.7.3.orig/src/java/ognl/JavaSource.java 0000644 0001750 0001750 00000002076 10566476144 020713 0 ustar drazzib drazzib /**
*
*/
package ognl;
import ognl.enhance.ExpressionAccessor;
/**
* Defines an object that can return a representation of itself and any objects it contains
* in the form of a {@link String} embedded with literal java statements.
*
* @author jkuhnert
*/
public interface JavaSource
{
/**
* Expected to return a java source representation of itself such that
* it could be turned into a literal java expression to be compiled and
* executed for {@link ExpressionAccessor#get(OgnlContext, Object)} calls.
*
* @return Literal java string representation of an object get.
*/
String toGetSourceString(OgnlContext context, Object target);
/**
* Expected to return a java source representation of itself such that
* it could be turned into a literal java expression to be compiled and
* executed for {@link ExpressionAccessor#get(OgnlContext, Object)} calls.
*
* @return Literal java string representation of an object get.
*/
String toSetSourceString(OgnlContext context, Object target);
}
ognl-2.7.3.orig/src/java/ognl/ObjectElementsAccessor.java 0000644 0001750 0001750 00000004750 10561411075 023223 0 ustar drazzib drazzib //--------------------------------------------------------------------------
// Copyright (c) 1998-2004, Drew Davidson and Luke Blanshard
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
// Neither the name of the Drew Davidson nor the names of its contributors
// may be used to endorse or promote products derived from this software
// without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
// COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
// OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
// AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
// DAMAGE.
//--------------------------------------------------------------------------
package ognl;
import java.util.*;
/**
* Implementation of ElementsAccessor that returns a single-element iterator, containing
* the original target object.
* @author Luke Blanshard (blanshlu@netscape.net)
* @author Drew Davidson (drew@ognl.org)
*/
public class ObjectElementsAccessor implements ElementsAccessor
{
public Enumeration getElements( Object target )
{
final Object object = target;
return new Enumeration() {
private boolean seen = false;
public boolean hasMoreElements() {
return !seen;
}
public Object nextElement() {
Object result = null;
if (!seen) {
result = object;
seen = true;
}
return result;
}
};
}
}
ognl-2.7.3.orig/src/java/ognl/MethodFailedException.java 0000644 0001750 0001750 00000004401 10577301171 023034 0 ustar drazzib drazzib //--------------------------------------------------------------------------
// Copyright (c) 1998-2004, Drew Davidson and Luke Blanshard
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
// Neither the name of the Drew Davidson nor the names of its contributors
// may be used to endorse or promote products derived from this software
// without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
// COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
// OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
// AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
// DAMAGE.
//--------------------------------------------------------------------------
package ognl;
/**
* Exception thrown if a method or constructor call fails.
*
* @author Luke Blanshard (blanshlu@netscape.net)
* @author Drew Davidson (drew@ognl.org)
*/
public class MethodFailedException extends OgnlException
{
public MethodFailedException( Object source, String name)
{
super( "Method \"" + name + "\" failed for object " + source);
}
public MethodFailedException( Object source, String name, Throwable reason )
{
super( "Method \"" + name + "\" failed for object " + source, reason );
}
}
ognl-2.7.3.orig/src/java/ognl/ParseException.java 0000644 0001750 0001750 00000015006 10746450726 021575 0 ustar drazzib drazzib /* Generated By:JavaCC: Do not edit this line. ParseException.java Version 4.1 */
/* JavaCCOptions:KEEP_LINE_COL=null */
package ognl;
/**
* This exception is thrown when parse errors are encountered.
* You can explicitly create objects of this exception type by
* calling the method generateParseException in the generated
* parser.
*
* You can modify this class to customize your error reporting
* mechanisms so long as you retain the public fields.
*/
public class ParseException extends Exception {
/**
* This constructor is used by the method "generateParseException"
* in the generated parser. Calling this constructor generates
* a new object of this type with the fields "currentToken",
* "expectedTokenSequences", and "tokenImage" set. The boolean
* flag "specialConstructor" is also set to true to indicate that
* this constructor was used to create this object.
* This constructor calls its super class with the empty string
* to force the "toString" method of parent class "Throwable" to
* print the error message in the form:
* ParseException:
*/
public ParseException(Token currentTokenVal,
int[][] expectedTokenSequencesVal,
String[] tokenImageVal
)
{
super("");
specialConstructor = true;
currentToken = currentTokenVal;
expectedTokenSequences = expectedTokenSequencesVal;
tokenImage = tokenImageVal;
}
/**
* The following constructors are for use by you for whatever
* purpose you can think of. Constructing the exception in this
* manner makes the exception behave in the normal way - i.e., as
* documented in the class "Throwable". The fields "errorToken",
* "expectedTokenSequences", and "tokenImage" do not contain
* relevant information. The JavaCC generated code does not use
* these constructors.
*/
public ParseException() {
super();
specialConstructor = false;
}
/** Constructor with message. */
public ParseException(String message) {
super(message);
specialConstructor = false;
}
/**
* This variable determines which constructor was used to create
* this object and thereby affects the semantics of the
* "getMessage" method (see below).
*/
protected boolean specialConstructor;
/**
* This is the last token that has been consumed successfully. If
* this object has been created due to a parse error, the token
* followng this token will (therefore) be the first error token.
*/
public Token currentToken;
/**
* Each entry in this array is an array of integers. Each array
* of integers represents a sequence of tokens (by their ordinal
* values) that is expected at this point of the parse.
*/
public int[][] expectedTokenSequences;
/**
* This is a reference to the "tokenImage" array of the generated
* parser within which the parse error occurred. This array is
* defined in the generated ...Constants interface.
*/
public String[] tokenImage;
/**
* This method has the standard behavior when this object has been
* created using the standard constructors. Otherwise, it uses
* "currentToken" and "expectedTokenSequences" to generate a parse
* error message and returns it. If this object has been created
* due to a parse error, and you do not catch it (it gets thrown
* from the parser), then this method is called during the printing
* of the final stack trace, and hence the correct error message
* gets displayed.
*/
public String getMessage() {
if (!specialConstructor) {
return super.getMessage();
}
StringBuffer expected = new StringBuffer();
int maxSize = 0;
for (int i = 0; i < expectedTokenSequences.length; i++) {
if (maxSize < expectedTokenSequences[i].length) {
maxSize = expectedTokenSequences[i].length;
}
for (int j = 0; j < expectedTokenSequences[i].length; j++) {
expected.append(tokenImage[expectedTokenSequences[i][j]]).append(' ');
}
if (expectedTokenSequences[i][expectedTokenSequences[i].length - 1] != 0) {
expected.append("...");
}
expected.append(eol).append(" ");
}
String retval = "Encountered \"";
Token tok = currentToken.next;
for (int i = 0; i < maxSize; i++) {
if (i != 0) retval += " ";
if (tok.kind == 0) {
retval += tokenImage[0];
break;
}
retval += " " + tokenImage[tok.kind];
retval += " \"";
retval += add_escapes(tok.image);
retval += " \"";
tok = tok.next;
}
retval += "\" at line " + currentToken.next.beginLine + ", column " + currentToken.next.beginColumn;
retval += "." + eol;
if (expectedTokenSequences.length == 1) {
retval += "Was expecting:" + eol + " ";
} else {
retval += "Was expecting one of:" + eol + " ";
}
retval += expected.toString();
return retval;
}
/**
* The end of line string for this machine.
*/
protected String eol = System.getProperty("line.separator", "\n");
/**
* Used to convert raw characters to their escaped version
* when these raw version cannot be used as part of an ASCII
* string literal.
*/
protected String add_escapes(String str) {
StringBuffer retval = new StringBuffer();
char ch;
for (int i = 0; i < str.length(); i++) {
switch (str.charAt(i))
{
case 0 :
continue;
case '\b':
retval.append("\\b");
continue;
case '\t':
retval.append("\\t");
continue;
case '\n':
retval.append("\\n");
continue;
case '\f':
retval.append("\\f");
continue;
case '\r':
retval.append("\\r");
continue;
case '\"':
retval.append("\\\"");
continue;
case '\'':
retval.append("\\\'");
continue;
case '\\':
retval.append("\\\\");
continue;
default:
if ((ch = str.charAt(i)) < 0x20 || ch > 0x7e) {
String s = "0000" + Integer.toString(ch, 16);
retval.append("\\u" + s.substring(s.length() - 4, s.length()));
} else {
retval.append(ch);
}
continue;
}
}
return retval.toString();
}
}
/* JavaCC - OriginalChecksum=a0a2f59968d58ccc3e57dbd91056ba6e (do not edit this line) */
ognl-2.7.3.orig/src/java/ognl/ASTProperty.java 0000644 0001750 0001750 00000063631 10776755160 021052 0 ustar drazzib drazzib // --------------------------------------------------------------------------
// Copyright (c) 1998-2004, Drew Davidson and Luke Blanshard
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
// Neither the name of the Drew Davidson nor the names of its contributors
// may be used to endorse or promote products derived from this software
// without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
// COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
// OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
// AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
// DAMAGE.
// --------------------------------------------------------------------------
package ognl;
import ognl.enhance.ExpressionCompiler;
import ognl.enhance.UnsupportedCompilationException;
import java.beans.IndexedPropertyDescriptor;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Method;
import java.util.Iterator;
/**
* @author Luke Blanshard (blanshlu@netscape.net)
* @author Drew Davidson (drew@ognl.org)
*/
public class ASTProperty extends SimpleNode implements NodeType
{
private boolean _indexedAccess = false;
private Class _getterClass;
private Class _setterClass;
public ASTProperty(int id)
{
super(id);
}
public void setIndexedAccess(boolean value)
{
_indexedAccess = value;
}
/**
* Returns true if this property is itself an index reference.
*/
public boolean isIndexedAccess()
{
return _indexedAccess;
}
/**
* 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
{
Class type = context.getCurrentType();
Class prevType = context.getPreviousType();
try
{
if (!isIndexedAccess())
{
Object property = getProperty(context, source);
if (property instanceof String)
{
return OgnlRuntime.getIndexedPropertyType(context, (source == null)
? null
: OgnlRuntime.getCompiler().getInterfaceClass(source.getClass()), (String) property);
}
}
return OgnlRuntime.INDEXED_PROPERTY_NONE;
} finally
{
context.setCurrentObject(source);
context.setCurrentType(type);
context.setPreviousType(prevType);
}
}
public Object getProperty(OgnlContext context, Object source)
throws OgnlException
{
return _children[0].getValue(context, context.getRoot());
}
protected Object getValueBody(OgnlContext context, Object source)
throws OgnlException
{
Object property = getProperty(context, source);
Object result = OgnlRuntime.getProperty(context, source, property);
if (result == null)
{
result = OgnlRuntime.getNullHandler(OgnlRuntime.getTargetClass(source)).nullPropertyValue(context, source, property);
}
return result;
}
protected void setValueBody(OgnlContext context, Object target, Object value)
throws OgnlException
{
OgnlRuntime.setProperty(context, target, getProperty(context, target), value);
}
public boolean isNodeSimpleProperty(OgnlContext context)
throws OgnlException
{
return (_children != null) && (_children.length == 1) && ((SimpleNode) _children[0]).isConstant(context);
}
public Class getGetterClass()
{
return _getterClass;
}
public Class getSetterClass()
{
return _setterClass;
}
public String toString()
{
String result;
if (isIndexedAccess())
{
result = "[" + _children[0] + "]";
} else
{
result = ((ASTConst) _children[0]).getValue().toString();
}
return result;
}
public String toGetSourceString(OgnlContext context, Object target)
{
if (context.getCurrentObject() == null)
throw new UnsupportedCompilationException("Current target is null.");
String result = "";
Method m = null;
try {
/* System.out.println("astproperty is indexed? : " + isIndexedAccess() + " child: " + _children[0].getClass().getName()
+ " target: " + target.getClass().getName() + " current object: " + context.getCurrentObject().getClass().getName());*/
if (isIndexedAccess())
{
Object value = _children[0].getValue(context, context.getRoot());
if (value == null || DynamicSubscript.class.isAssignableFrom(value.getClass()))
throw new UnsupportedCompilationException("Value passed as indexed property was null or not supported.");
// Get root cast string if the child is a type that needs it (like a nested ASTProperty)
String srcString = _children[0].toGetSourceString(context, context.getRoot());
srcString = ExpressionCompiler.getRootExpression(_children[0], context.getRoot(), context) + srcString;
if (ASTChain.class.isInstance(_children[0]))
{
String cast = (String)context.remove(ExpressionCompiler.PRE_CAST);
if (cast != null)
srcString = cast + srcString;
}
if (ASTConst.class.isInstance(_children[0]) && String.class.isInstance(context.getCurrentObject()))
srcString = "\"" + srcString + "\"";
// System.out.println("indexed getting with child srcString: " + srcString + " value class: " + value.getClass() + " and child: " + _children[0].getClass());
if (context.get("_indexedMethod") != null)
{
m = (Method)context.remove("_indexedMethod");
_getterClass = m.getReturnType();
Object indexedValue = OgnlRuntime.callMethod(context, target, m.getName(), new Object[]{value});
context.setCurrentType(_getterClass);
context.setCurrentObject(indexedValue);
context.setCurrentAccessor(OgnlRuntime.getCompiler().getSuperOrInterfaceClass(m, m.getDeclaringClass()));
return "." + m.getName() + "(" + srcString + ")";
} else
{
PropertyAccessor p = OgnlRuntime.getPropertyAccessor(target.getClass());
// System.out.println("child value : " + _children[0].getValue(context, context.getCurrentObject()) + " using propaccessor " + p.getClass().getName()
// + " and srcString " + srcString + " on target: " + target);
Object currObj = context.getCurrentObject();
Class currType = context.getCurrentType();
Class prevType = context.getPreviousType();
Object indexVal = p.getProperty(context, target, value);
// reset current object for accessor
context.setCurrentObject(currObj);
context.setCurrentType(currType);
context.setPreviousType(prevType);
/* System.out.println("astprop srcString: " + srcString
+ " from child class " + _children[0].getClass().getName()
+ " and indexVal " + indexVal
+ " propertyAccessor : " + p.getClass().getName() + " context obj " + context.getCurrentObject()
+ " context obj is array? : " + context.getCurrentObject().getClass().isArray()
+ " current type: " + context.getCurrentType());*/
if (ASTConst.class.isInstance(_children[0]) && Number.class.isInstance(context.getCurrentObject()))
context.setCurrentType(OgnlRuntime.getPrimitiveWrapperClass(context.getCurrentObject().getClass()));
result = p.getSourceAccessor(context, target, srcString);
_getterClass = context.getCurrentType();
context.setCurrentObject(indexVal);
return result;
}
}
String name = ((ASTConst) _children[0]).getValue().toString();
if (!Iterator.class.isAssignableFrom(context.getCurrentObject().getClass())
|| (Iterator.class.isAssignableFrom(context.getCurrentObject().getClass()) && name.indexOf("next") < 0))
{
Object currObj = target;
try
{
target = getValue(context, context.getCurrentObject());
} catch (NoSuchPropertyException e)
{
try {
target = getValue(context, context.getRoot());
} catch (NoSuchPropertyException ex) {
// ignore
}
} finally
{
context.setCurrentObject(currObj);
}
}
PropertyDescriptor pd = OgnlRuntime.getPropertyDescriptor(context.getCurrentObject().getClass(), name);
if (pd != null && pd.getReadMethod() != null
&& !context.getMemberAccess().isAccessible(context, context.getCurrentObject(), pd.getReadMethod(), name))
{
throw new UnsupportedCompilationException("Member access forbidden for property " + name + " on class " + context.getCurrentObject().getClass());
}
if (this.getIndexedPropertyType(context, context.getCurrentObject()) > 0 && pd != null)
{
// if an indexed method accessor need to use special property descriptors to find methods
if (pd instanceof IndexedPropertyDescriptor)
{
m = ((IndexedPropertyDescriptor) pd).getIndexedReadMethod();
} else
{
if (pd instanceof ObjectIndexedPropertyDescriptor)
m = ((ObjectIndexedPropertyDescriptor) pd).getIndexedReadMethod();
else
throw new OgnlException("property '" + name + "' is not an indexed property");
}
if (_parent == null)
{
// the above pd will be the wrong result sometimes, such as methods like getValue(int) vs String[] getValue()
m = OgnlRuntime.getReadMethod(context.getCurrentObject().getClass(), name);
result = m.getName() + "()";
_getterClass = m.getReturnType();
} else
{
context.put("_indexedMethod", m);
}
} else
{
/* System.out.println("astproperty trying to get " + name + " on object target: " + context.getCurrentObject().getClass().getName()
+ " current type " + context.getCurrentType() + " current accessor " + context.getCurrentAccessor()
+ " prev type " + context.getPreviousType() + " prev accessor " + context.getPreviousAccessor());*/
PropertyAccessor pa = OgnlRuntime.getPropertyAccessor(context.getCurrentObject().getClass());
if (context.getCurrentObject().getClass().isArray())
{
if (pd == null)
{
pd = OgnlRuntime.getProperty(context.getCurrentObject().getClass(), name);
if (pd != null && pd.getReadMethod() != null)
{
m = pd.getReadMethod();
result = pd.getName();
} else
{
_getterClass = int.class;
context.setCurrentAccessor(context.getCurrentObject().getClass());
context.setCurrentType(int.class);
result = "." + name;
}
}
} else
{
if (pd != null && pd.getReadMethod() != null)
{
m = pd.getReadMethod();
result = "." + m.getName() + "()";
} else if (pa != null)
{
Object currObj = context.getCurrentObject();
Class currType = context.getCurrentType();
Class prevType = context.getPreviousType();
String srcString = _children[0].toGetSourceString(context, context.getRoot());
if (ASTConst.class.isInstance(_children[0]) &&
String.class.isInstance(context.getCurrentObject()))
srcString = "\"" + srcString + "\"";
context.setCurrentObject(currObj);
context.setCurrentType(currType);
context.setPreviousType(prevType);
result = pa.getSourceAccessor(context, context.getCurrentObject(), srcString);
_getterClass = context.getCurrentType();
}
}
}
} catch (Throwable t)
{
throw OgnlOps.castToRuntime(t);
}
// set known property types for NodeType interface when possible
if (m != null)
{
_getterClass = m.getReturnType();
context.setCurrentType(m.getReturnType());
context.setCurrentAccessor(OgnlRuntime.getCompiler().getSuperOrInterfaceClass(m, m.getDeclaringClass()));
}
context.setCurrentObject(target);
return result;
}
Method getIndexedWriteMethod(PropertyDescriptor pd)
{
if (IndexedPropertyDescriptor.class.isInstance(pd))
{
return ((IndexedPropertyDescriptor)pd).getIndexedWriteMethod();
} else if (ObjectIndexedPropertyDescriptor.class.isInstance(pd))
{
return ((ObjectIndexedPropertyDescriptor)pd).getIndexedWriteMethod();
}
return null;
}
public String toSetSourceString(OgnlContext context, Object target)
{
String result = "";
Method m = null;
if (context.getCurrentObject() == null)
throw new UnsupportedCompilationException("Current target is null.");
/*System.out.println("astproperty(setter) is indexed? : " + isIndexedAccess() + " child: " + _children[0].getClass().getName()
+ " target: " + target.getClass().getName() + " children length: " + _children.length);*/
try {
if (isIndexedAccess())
{
Object value = _children[0].getValue(context, context.getRoot());
if (value == null)
throw new UnsupportedCompilationException("Value passed as indexed property is null, can't enhance statement to bytecode.");
String srcString = _children[0].toGetSourceString(context, context.getRoot());
srcString = ExpressionCompiler.getRootExpression(_children[0], context.getRoot(), context) + srcString;
if (ASTChain.class.isInstance(_children[0]))
{
String cast = (String)context.remove(ExpressionCompiler.PRE_CAST);
if (cast != null)
srcString = cast + srcString;
}
if (ASTConst.class.isInstance(_children[0]) && String.class.isInstance(context.getCurrentObject()))
{
srcString = "\"" + srcString + "\"";
}
// System.out.println("astproperty setter using indexed value " + value + " and srcString: " + srcString);
if (context.get("_indexedMethod") != null)
{
m = (Method)context.remove("_indexedMethod");
PropertyDescriptor pd = (PropertyDescriptor)context.remove("_indexedDescriptor");
boolean lastChild = lastChild(context);
if (lastChild)
{
m = getIndexedWriteMethod(pd);
if (m == null)
throw new UnsupportedCompilationException("Indexed property has no corresponding write method.");
}
_setterClass = m.getParameterTypes()[0];
Object indexedValue = null;
if (!lastChild)
indexedValue = OgnlRuntime.callMethod(context, target, m.getName(), new Object[]{value});
context.setCurrentType(_setterClass);
context.setCurrentAccessor(OgnlRuntime.getCompiler().getSuperOrInterfaceClass(m, m.getDeclaringClass()));
if (!lastChild)
{
context.setCurrentObject(indexedValue);
return "." + m.getName() + "(" + srcString + ")";
} else {
return "." + m.getName() + "(" + srcString + ", $3)";
}
} else
{
PropertyAccessor p = OgnlRuntime.getPropertyAccessor(target.getClass());
Object currObj = context.getCurrentObject();
Class currType = context.getCurrentType();
Class prevType = context.getPreviousType();
Object indexVal = p.getProperty(context, target, value);
// reset current object for accessor
context.setCurrentObject(currObj);
context.setCurrentType(currType);
context.setPreviousType(prevType);
if (ASTConst.class.isInstance(_children[0]) && Number.class.isInstance(context.getCurrentObject()))
context.setCurrentType(OgnlRuntime.getPrimitiveWrapperClass(context.getCurrentObject().getClass()));
result = lastChild(context) ? p.getSourceSetter(context, target, srcString) : p.getSourceAccessor(context, target, srcString);
/*System.out.println("ASTProperty using propertyaccessor and isLastChild? " + lastChild(context)
+ " generated source of: " + result + " using accessor class: " + p.getClass().getName());*/
//result = p.getSourceAccessor(context, target, srcString);
_getterClass = context.getCurrentType();
context.setCurrentObject(indexVal);
/* PropertyAccessor p = OgnlRuntime.getPropertyAccessor(target.getClass());
if (ASTConst.class.isInstance(_children[0]) && Number.class.isInstance(context.getCurrentObject()))
{
context.setCurrentType(OgnlRuntime.getPrimitiveWrapperClass(context.getCurrentObject().getClass()));
}
result = p.getSourceSetter(context, target, srcString);
context.setCurrentObject(value);
context.setCurrentType(_getterClass);*/
return result;
}
}
String name = ((ASTConst) _children[0]).getValue().toString();
// System.out.println(" astprop(setter) : trying to set " + name + " on object target " + context.getCurrentObject().getClass().getName());
if (!Iterator.class.isAssignableFrom(context.getCurrentObject().getClass())
|| (Iterator.class.isAssignableFrom(context.getCurrentObject().getClass()) && name.indexOf("next") < 0)) {
Object currObj = target;
try {
target = getValue(context, context.getCurrentObject());
} catch (NoSuchPropertyException e) {
try {
target = getValue(context, context.getRoot());
} catch (NoSuchPropertyException ex) { }
} finally {
context.setCurrentObject(currObj);
}
}
PropertyDescriptor pd = OgnlRuntime.getPropertyDescriptor(OgnlRuntime.getCompiler().getInterfaceClass(context.getCurrentObject().getClass()), name);
if (pd != null)
{
Method pdMethod = lastChild(context) ? pd.getWriteMethod() : pd.getReadMethod();
if (pdMethod != null && !context.getMemberAccess().isAccessible(context, context.getCurrentObject(), pdMethod, name))
{
throw new UnsupportedCompilationException("Member access forbidden for property " + name + " on class " + context.getCurrentObject().getClass());
}
}
if (pd != null && this.getIndexedPropertyType(context, context.getCurrentObject()) > 0)
{
// if an indexed method accessor need to use special property descriptors to find methods
if (pd instanceof IndexedPropertyDescriptor)
{
IndexedPropertyDescriptor ipd = (IndexedPropertyDescriptor)pd;
m = lastChild(context) ? ipd.getIndexedWriteMethod() : ipd.getIndexedReadMethod();
} else
{
if (pd instanceof ObjectIndexedPropertyDescriptor)
{
ObjectIndexedPropertyDescriptor opd = (ObjectIndexedPropertyDescriptor)pd;
m = lastChild(context) ? opd.getIndexedWriteMethod() : opd.getIndexedReadMethod();
} else
{
throw new OgnlException("property '" + name + "' is not an indexed property");
}
}
if (_parent == null)
{
// the above pd will be the wrong result sometimes, such as methods like getValue(int) vs String[] getValue()
m = OgnlRuntime.getWriteMethod(context.getCurrentObject().getClass(), name);
Class parm = m.getParameterTypes()[0];
String cast = parm.isArray() ? ExpressionCompiler.getCastString(parm) : parm.getName();
result = m.getName() + "((" + cast + ")$3)";
_setterClass = parm;
} else
{
context.put("_indexedMethod", m);
context.put("_indexedDescriptor", pd);
}
} else {
PropertyAccessor pa = OgnlRuntime.getPropertyAccessor(context.getCurrentObject().getClass());
/*System.out.println("astproperty trying to set " + name + " on object target: " + context.getCurrentObject().getClass().getName()
+ " using propertyaccessor type: " + pa);*/
if (target != null)
_setterClass = target.getClass();
if (_parent != null && pd != null && pa == null)
{
m = pd.getReadMethod();
result = m.getName() + "()";
} else
{
if (context.getCurrentObject().getClass().isArray())
{
result = "";
} else if (pa != null)
{
Object currObj = context.getCurrentObject();
//Class currType = context.getCurrentType();
//Class prevType = context.getPreviousType();
String srcString = _children[0].toGetSourceString(context, context.getRoot());
if (ASTConst.class.isInstance(_children[0]) && String.class.isInstance(context.getCurrentObject()))
{
srcString = "\"" + srcString + "\"";
}
context.setCurrentObject(currObj);
//context.setCurrentType(currType);
//context.setPreviousType(prevType);
if (!lastChild(context))
{
result = pa.getSourceAccessor(context, context.getCurrentObject(), srcString);
} else
{
result = pa.getSourceSetter(context, context.getCurrentObject(), srcString);
}
_getterClass = context.getCurrentType();
}
}
}
} catch (Throwable t)
{
throw OgnlOps.castToRuntime(t);
}
context.setCurrentObject(target);
if (m != null)
{
context.setCurrentType(m.getReturnType());
context.setCurrentAccessor(OgnlRuntime.getCompiler().getSuperOrInterfaceClass(m, m.getDeclaringClass()));
}
return result;
}
}
ognl-2.7.3.orig/docbook.xml 0000644 0001750 0001750 00000034056 10633055306 015470 0 ustar drazzib drazzib
Cannot run docbook: DocBook XML is required at extlib/docbook-xml-4.2
Please download at:
http://www.docbook.org/xml/4.2/docbook-xml-4.2.zip
Cannot run docbook: DocBook XSL is required at extlib/docbook-xsl-1.65.1
Please download at:
http://sourceforge.net/project/showfiles.php?group_id=21935&package_id=16608
Cannot run docbook: FOP is required at extlib/fop-0.20.5
Please download at:
http://www.apache.org/dyn/closer.cgi/xml/fop
Converting FO to PDF ...
ognl-2.7.3.orig/osbuild.xml 0000644 0001750 0001750 00000015522 10643500625 015506 0 ustar drazzib drazzib