* <definemacro name=macro-name [global=true|false]> .... </definemacro> ** The text (.....) has any leading and trailing whitespace * removed. *
* To expand a macro: <macro-name name1=value1 ...>.
* All ${...} constructs in The previously saved macro body
* are processed, and the result replaces the macro-name
* tag. Attributes provided in the macro name override any variables
* that exist in the request properties.
*
* Several special variables are supplied, as if they were specified * as attributes, but only if otherwise not already defined * either as an attribute or as a property, *
isSingleton
* args
*
* Templates are processed by reading the input "document" a tag
* at a time to generate the output document.
* By default, the macro body is pushed onto the not-yet-processed
* input stream; any tags contained in the macro body will be processed.
* If the defer attribute is present,
* the macro body is placed onto the output stream instead.
* This is more efficient, but requires an additional filter pass
* if the body of the macro contains tags that need to be processed
* in the current context.
*
*
* This is an experiment. The current implementation is flawed, although * it is less flawed than the previous one. *
* NOTE:
* The init files in previous releases used java properties format
* files to define macros; This version uses xml templates. See "main"
* below for a utility to convert the old properties format files to
* the new format.
*
* @author Stephen Uhler
* @version MacroTemplate.java 2.11
*/
public class MacroTemplate extends Template {
public Properties macroTable=null; // session specific definitions
Properties initial=null; // initial and global properties
boolean shouldSubst = false;
/**
* Read in the inital macros, if needed.
*/
public boolean
init(RewriteContext hr) {
hr.addClosingTag("definemacro");
shouldSubst = (hr.request.props.getProperty(hr.prefix + "subst") != null);
// Load in initial macros if macro table doesn't yet exist
if (macroTable == null) {
initial = (Properties)
SessionManager.getSession(hr.prefix, "Macros",
Properties.class);
String init = hr.request.props.getProperty(hr.prefix + "init");
if (init != null && initial.isEmpty()) {
loadInitial(hr, init);
}
macroTable = new Properties(initial);
}
return super.init(hr);
}
/**
* load initial macros, if any.
* XXX We should load from an XML file, not a properties file.
*/
void loadInitial_old(RewriteContext hr, String init) {
try {
InputStream in = ResourceHandler.getResourceStream(
hr.request.props, hr.prefix, init);
initial.load(in);
in.close();
hr.request.log(Server.LOG_DIAGNOSTIC, hr.prefix,
"loading initial macros: " + initial.toString());
} catch (IOException e) {
hr.request.log(Server.LOG_WARNING, hr.prefix,
"Can't find macro init file: " + init);
}
}
/**
* Load initial macros from xml file. All markup outside of
* the "definemacro" and "/definemacro" tags are ignored
* If a "subst" attribute is found, then evaluate all ${..} against
* server.props before saving the macro body. "subst" only applies
* for the "init" macro table.
*/
void loadInitial(RewriteContext hr, String init) {
String src = null;
try {
src = ResourceHandler.getResourceString(
hr.request.props, hr.prefix, init);
} catch (IOException e) {
hr.request.log(Server.LOG_WARNING, hr.prefix,
"Can't find macro init file: " + init);
}
LexML lex = new LexML(src);
while (lex.nextToken()) {
if (lex.getType()==LexML.TAG &&
lex.getTag().equals("definemacro")) {
String name=Format.deQuote(lex.getAttributes().get("name"));
if (name==null || name.trim().equals("")) {
continue;
}
boolean doSubst = (lex.getAttributes().get("subst") != null);
String value = snarfTillClose(lex, "definemacro").trim();
if (doSubst) {
value = Format.subst(hr.server.props, value);
}
if (!value.equals("")) {
initial.put(name, value);
hr.request.log(Server.LOG_DIAGNOSTIC, hr.prefix,
"initial macro: [" + name + "] (" + value.length() +
" chars)");
} else {
initial.remove(name);
}
} else {
// System.out.println("Skipping tag: " + lex.getToken());
}
}
// initial.save(System.out, hr.prefix + " initial macros");
}
/**
* Grab all the markup starting from the current tag until
* the matching closing tag, and return as a string.
*/
public static String snarfTillClose(LexML lex, String tag) {
if (!lex.isSingleton()) {
StringBuffer sb = new StringBuffer();
String start = "<" + tag + " ";
String end = ""; // XXX not quite
int nest = 0; // set nesting level
sb = new StringBuffer();
while (lex.nextToken()) {
String t = lex.getToken();
lex.getTag(); // force singleton checking!
if (t.startsWith(start) && !lex.isSingleton()) {
nest++;
} else if (t.equals(end) && (--nest < 0)) {
break;
}
sb.append(t);
}
return sb.toString();
} else {
return "";
}
}
/**
* Define a new macro. use "name" as the macro name. Once defined, the tag
* <name ...> will be replaced by the contents of the macro
* named "name".
*
* <definemacro name=nnn [global=true|false]>...</definemacro>
*
* <definemacro nnn> is a shortcut for
* <definemacro name=nnn>
*
* If the parameter defer=true is present, the text of the macro is output
* directly, with only ${..} substitutions performed. Otherwise, the markup in the macro
* body is rescanned and processed.
*/
public void
defaultTag(RewriteContext hr) {
String tag = hr.getTag();
String script = macroTable.getProperty(tag);
if (script != null) {
debug(hr);
String body = Format.subst(new Props(hr), script);
if (!hr.isTrue("defer")) {
String rest = hr.lex.rest();
if (rest != null) {
hr.lex.replace(body + rest);
} else {
hr.lex.replace(body);
}
hr.killToken();
} else {
hr.append(body);
}
} else if (shouldSubst) {
Enumeration e = hr.keys();
while (e.hasMoreElements()) {
String key = (String) e.nextElement();
hr.put(key, hr.get(key));
}
}
}
/**
* Special Properties class for use with format.subst() that will
* return any formal parameters first, then look in request props.
*/
static class Props extends Properties {
RewriteContext hr;
String args = null;
Props(RewriteContext hr) {
this.hr=hr;
}
public String
getProperty(String key) {
String value = hr.get(key);
if (value == null &&
(value = hr.request.props.getProperty(key)) == null) {
if (key.equals("isSingleton")) {
value = hr.isSingleton() ? "true" : "false";
} else if (key.equals("args")) {
return hr.getArgs();
}
}
return value;
}
}
/**
* Convert stdin properties format macro definition files
* to the new template style. Use this to update to the new
* initial macro template format.
*/
public static void main(String args[]) throws IOException {
Properties in = new Properties();
in.load(System.in);
System.out.println("");
Enumeration e = in.keys();
while (e.hasMoreElements()) {
String key = (String) e.nextElement();
String value = in.getProperty(key);
System.out.println("\n