| Methods Summary |
|---|
| public java.lang.Object | evaluateAtCompileTime()Returns an object representing the compile-time evaluation
of an expression. We are only using this for function-available
and element-available at this time.
return getResult() ? Boolean.TRUE : Boolean.FALSE;
|
| public boolean | getResult()Reports on whether the function specified in the argument to
xslt function 'function-available' was found.
if (_nameOfFunct == null) {
return false;
}
if (isInternalNamespace()) {
final Parser parser = getParser();
_isFunctionAvailable =
parser.functionSupported(Util.getLocalName(_nameOfFunct));
}
return _isFunctionAvailable;
|
| private boolean | hasMethods()for external java functions only: reports on whether or not
the specified method is found in the specifed class.
LiteralExpr arg = (LiteralExpr)_arg;
// Get the class name from the namespace uri
String className = getClassNameFromUri(_namespaceOfFunct);
// Get the method name from the argument to function-available
String methodName = null;
int colonIndex = _nameOfFunct.indexOf(":");
if (colonIndex > 0) {
String functionName = _nameOfFunct.substring(colonIndex+1);
int lastDotIndex = functionName.lastIndexOf('.");
if (lastDotIndex > 0) {
methodName = functionName.substring(lastDotIndex+1);
if (className != null && !className.equals(""))
className = className + "." + functionName.substring(0, lastDotIndex);
else
className = functionName.substring(0, lastDotIndex);
}
else
methodName = functionName;
}
else
methodName = _nameOfFunct;
if (className == null || methodName == null) {
return false;
}
// Replace the '-' characters in the method name
if (methodName.indexOf('-") > 0)
methodName = replaceDash(methodName);
try {
final Class clazz = ObjectFactory.findProviderClass(
className, ObjectFactory.findClassLoader(), true);
if (clazz == null) {
return false;
}
final Method[] methods = clazz.getMethods();
for (int i = 0; i < methods.length; i++) {
final int mods = methods[i].getModifiers();
if (Modifier.isPublic(mods) && Modifier.isStatic(mods)
&& methods[i].getName().equals(methodName))
{
return true;
}
}
}
catch (ClassNotFoundException e) {
return false;
}
return false;
|
| private boolean | isInternalNamespace()Return true if the namespace uri is null or it is the XSLTC translet uri.
return (_namespaceOfFunct == null ||
_namespaceOfFunct.equals(EMPTYSTRING) ||
_namespaceOfFunct.equals(TRANSLET_URI));
|
| public void | translate(com.sun.org.apache.xalan.internal.xsltc.compiler.util.ClassGenerator classGen, com.sun.org.apache.xalan.internal.xsltc.compiler.util.MethodGenerator methodGen)Calls to 'function-available' are resolved at compile time since
the namespaces declared in the stylsheet are not available at run
time. Consequently, arguments to this function must be literals.
final ConstantPoolGen cpg = classGen.getConstantPool();
methodGen.getInstructionList().append(new PUSH(cpg, getResult()));
|
| public com.sun.org.apache.xalan.internal.xsltc.compiler.util.Type | typeCheck(com.sun.org.apache.xalan.internal.xsltc.compiler.SymbolTable stable)Argument of function-available call must be literal, typecheck
returns the type of function-available to be boolean.
if (_type != null) {
return _type;
}
if (_arg instanceof LiteralExpr) {
return _type = Type.Boolean;
}
ErrorMsg err = new ErrorMsg(ErrorMsg.NEED_LITERAL_ERR,
"function-available", this);
throw new TypeCheckError(err);
|
