in velocity-engine-core/src/main/java/org/apache/velocity/runtime/parser/node/ASTReference.java [926:1131]
private String getRoot()
{
Token t = getFirstToken();
/*
* we have a special case where something like
* $(\\)*!, where the user want's to see something
* like $!blargh in the output, but the ! prevents it from showing.
* I think that at this point, this isn't a reference.
*/
/* so, see if we have "\\!" */
int slashbang = t.image.indexOf("\\!");
if (slashbang != -1)
{
if (strictEscape)
{
// If we are in strict escape mode, then we consider this type of
// pattern a non-reference, and we print it out as schmoo...
nullString = literal();
escaped = true;
return nullString;
}
/*
* lets do all the work here. I would argue that if this occurs,
* it's not a reference at all, so preceding \ characters in front
* of the $ are just schmoo. So we just do the escape processing
* trick (even | odd) and move on. This kind of breaks the rule
* pattern of $ and # but '!' really tosses a wrench into things.
*/
/*
* count the escapes: even # -> not escaped, odd -> escaped
*/
int i = 0;
int len = t.image.length();
i = t.image.indexOf(rsvc.getParserConfiguration().getDollarChar());
if (i == -1)
{
/* yikes! */
log.error("ASTReference.getRoot(): internal error: "
+ "no $ found for slashbang.");
computableReference = false;
nullString = t.image;
return nullString;
}
while (i < len && t.image.charAt(i) != '\\')
{
i++;
}
/* ok, i is the first \ char */
int start = i;
int count = 0;
while (i < len && t.image.charAt(i++) == '\\')
{
count++;
}
/*
* now construct the output string. We really don't care about
* leading slashes as this is not a reference. It's quasi-schmoo
*/
nullString = t.image.substring(0,start); // prefix up to the first
nullString += t.image.substring(start, start + count-1 ); // get the slashes
nullString += t.image.substring(start+count); // and the rest, including the
/*
* this isn't a valid reference, so lets short circuit the value
* and set calcs
*/
computableReference = false;
return nullString;
}
/*
* we need to see if this reference is escaped. if so
* we will clean off the leading \'s and let the
* regular behavior determine if we should output this
* as \$foo or $foo later on in render(). Laziness..
*/
escaped = false;
if (t.image.startsWith("\\"))
{
/*
* count the escapes: even # -> not escaped, odd -> escaped
*/
int i = 0;
int len = t.image.length();
while (i < len && t.image.charAt(i) == '\\')
{
i++;
}
if ((i % 2) != 0)
escaped = true;
if (i > 0)
escPrefix = t.image.substring(0, i / 2 );
t.image = t.image.substring(i);
}
/*
* Look for preceding stuff like '#' and '$'
* and snip it off, except for the
* last $
*/
int loc1 = t.image.lastIndexOf(rsvc.getParserConfiguration().getDollarChar());
/*
* if we have extra stuff, loc > 0
* ex. '#$foo' so attach that to
* the prefix.
*/
if (loc1 > 0)
{
morePrefix = morePrefix + t.image.substring(0, loc1);
t.image = t.image.substring(loc1);
}
/*
* Now it should be clean. Get the literal in case this reference
* isn't backed by the context at runtime, and then figure out what
* we are working with.
*/
// FIXME: this is the key to render nulls as literals, we need to look at context(refname+".literal")
nullString = literal();
if (t.image.startsWith("$!"))
{
referenceType = QUIET_REFERENCE;
/*
* only if we aren't escaped do we want to null the output
*/
if (!escaped)
nullString = "";
if (t.image.startsWith("$!{"))
{
/*
* ex: $!{provider.Title}
*/
return t.next.image;
}
else
{
/*
* ex: $!provider.Title
*/
return t.image.substring(2);
}
}
else if (t.image.equals("${"))
{
/*
* ex: ${provider.Title}
*/
referenceType = FORMAL_REFERENCE;
return t.next.image;
}
else if (t.image.startsWith("$"))
{
/*
* just nip off the '$' so we have
* the root
*/
referenceType = NORMAL_REFERENCE;
return t.image.substring(1);
}
else
{
/*
* this is a 'RUNT', which can happen in certain circumstances where
* the parser is fooled into believing that an IDENTIFIER is a real
* reference. Another 'dreaded' MORE hack :).
*/
referenceType = RUNT;
return t.image;
}
}