bool
nsCoreUtils::IsWhitespaceString(const nsSubstring& aString)
{
nsSubstring::const_char_iterator iterBegin, iterEnd;
aString.BeginReading(iterBegin);
aString.EndReading(iterEnd);
while (iterBegin != iterEnd && IsWhitespace(*iterBegin))
++iterBegin;
return iterBegin == iterEnd;
}
nsresult
txExprParser::createExprInternal(const nsSubstring& aExpression,
uint32_t aSubStringPos,
txIParseContext* aContext, Expr** aExpr)
{
NS_ENSURE_ARG_POINTER(aExpr);
*aExpr = nullptr;
txExprLexer lexer;
nsresult rv = lexer.parse(aExpression);
if (NS_FAILED(rv)) {
nsASingleFragmentString::const_char_iterator start;
aExpression.BeginReading(start);
aContext->SetErrorOffset(lexer.mPosition - start + aSubStringPos);
return rv;
}
nsAutoPtr<Expr> expr;
rv = createExpr(lexer, aContext, getter_Transfers(expr));
if (NS_SUCCEEDED(rv) && lexer.peek()->mType != Token::END) {
rv = NS_ERROR_XPATH_BINARY_EXPECTED;
}
if (NS_FAILED(rv)) {
nsASingleFragmentString::const_char_iterator start;
aExpression.BeginReading(start);
aContext->SetErrorOffset(lexer.peek()->mStart - start + aSubStringPos);
return rv;
}
txXPathOptimizer optimizer;
Expr* newExpr = nullptr;
rv = optimizer.optimize(expr, &newExpr);
NS_ENSURE_SUCCESS(rv, rv);
*aExpr = newExpr ? newExpr : expr.forget();
return NS_OK;
}
/**
* Creates an Attribute Value Template using the given value
* This should move to XSLProcessor class
*/
nsresult
txExprParser::createAVT(const nsSubstring& aAttrValue,
txIParseContext* aContext,
Expr** aResult)
{
*aResult = nullptr;
nsresult rv = NS_OK;
nsAutoPtr<Expr> expr;
FunctionCall* concat = nullptr;
nsAutoString literalString;
bool inExpr = false;
nsSubstring::const_char_iterator iter, start, end, avtStart;
aAttrValue.BeginReading(iter);
aAttrValue.EndReading(end);
avtStart = iter;
while (iter != end) {
// Every iteration through this loop parses either a literal section
// or an expression
start = iter;
nsAutoPtr<Expr> newExpr;
if (!inExpr) {
// Parse literal section
literalString.Truncate();
while (iter != end) {
PRUnichar q = *iter;
if (q == '{' || q == '}') {
// Store what we've found so far and set a new |start| to
// skip the (first) brace
literalString.Append(Substring(start, iter));
start = ++iter;
// Unless another brace follows we've found the start of
// an expression (in case of '{') or an unbalanced brace
// (in case of '}')
if (iter == end || *iter != q) {
if (q == '}') {
aContext->SetErrorOffset(iter - avtStart);
return NS_ERROR_XPATH_UNBALANCED_CURLY_BRACE;
}
inExpr = true;
break;
}
// We found a second brace, let that be part of the next
// literal section being parsed and continue looping
}
++iter;
}
if (start == iter && literalString.IsEmpty()) {
// Restart the loop since we didn't create an expression
continue;
}
newExpr = new txLiteralExpr(literalString +
Substring(start, iter));
}
else {
// Parse expressions, iter is already past the initial '{' when
// we get here.
while (iter != end) {
if (*iter == '}') {
rv = createExprInternal(Substring(start, iter),
start - avtStart, aContext,
getter_Transfers(newExpr));
NS_ENSURE_SUCCESS(rv, rv);
inExpr = false;
++iter; // skip closing '}'
break;
}
else if (*iter == '\'' || *iter == '"') {
PRUnichar q = *iter;
while (++iter != end && *iter != q) {} /* do nothing */
if (iter == end) {
break;
}
}
++iter;
}
if (inExpr) {
aContext->SetErrorOffset(start - avtStart);
return NS_ERROR_XPATH_UNBALANCED_CURLY_BRACE;
}
}
// Add expression, create a concat() call if necessary
if (!expr) {
expr = newExpr;
}
else {
if (!concat) {
concat = new txCoreFunctionCall(txCoreFunctionCall::CONCAT);
NS_ENSURE_TRUE(concat, NS_ERROR_OUT_OF_MEMORY);
rv = concat->addParam(expr.forget());
expr = concat;
NS_ENSURE_SUCCESS(rv, rv);
}
rv = concat->addParam(newExpr.forget());
NS_ENSURE_SUCCESS(rv, rv);
}
}
if (inExpr) {
aContext->SetErrorOffset(iter - avtStart);
return NS_ERROR_XPATH_UNBALANCED_CURLY_BRACE;
}
if (!expr) {
expr = new txLiteralExpr(EmptyString());
}
*aResult = expr.forget();
return NS_OK;
}
