Mypal/dom/smil/nsSMILParserUtils.cpp

731 lines
20 KiB
C++

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "nsSMILParserUtils.h"
#include "nsSMILKeySpline.h"
#include "nsISMILAttr.h"
#include "nsSMILValue.h"
#include "nsSMILTimeValue.h"
#include "nsSMILTimeValueSpecParams.h"
#include "nsSMILTypes.h"
#include "nsSMILRepeatCount.h"
#include "nsContentUtils.h"
#include "nsCharSeparatedTokenizer.h"
#include "SVGContentUtils.h"
using namespace mozilla;
using namespace mozilla::dom;
//------------------------------------------------------------------------------
// Helper functions and Constants
namespace {
const uint32_t MSEC_PER_SEC = 1000;
const uint32_t MSEC_PER_MIN = 1000 * 60;
const uint32_t MSEC_PER_HOUR = 1000 * 60 * 60;
#define ACCESSKEY_PREFIX_LC NS_LITERAL_STRING("accesskey(") // SMIL2+
#define ACCESSKEY_PREFIX_CC NS_LITERAL_STRING("accessKey(") // SVG/SMIL ANIM
#define REPEAT_PREFIX NS_LITERAL_STRING("repeat(")
#define WALLCLOCK_PREFIX NS_LITERAL_STRING("wallclock(")
inline bool
SkipWhitespace(RangedPtr<const char16_t>& aIter,
const RangedPtr<const char16_t>& aEnd)
{
while (aIter != aEnd) {
if (!IsSVGWhitespace(*aIter)) {
return true;
}
++aIter;
}
return false;
}
inline bool
ParseColon(RangedPtr<const char16_t>& aIter,
const RangedPtr<const char16_t>& aEnd)
{
if (aIter == aEnd || *aIter != ':') {
return false;
}
++aIter;
return true;
}
/*
* Exactly two digits in the range 00 - 59 are expected.
*/
bool
ParseSecondsOrMinutes(RangedPtr<const char16_t>& aIter,
const RangedPtr<const char16_t>& aEnd,
uint32_t& aValue)
{
if (aIter == aEnd || !SVGContentUtils::IsDigit(*aIter)) {
return false;
}
RangedPtr<const char16_t> iter(aIter);
if (++iter == aEnd || !SVGContentUtils::IsDigit(*iter)) {
return false;
}
uint32_t value = 10 * SVGContentUtils::DecimalDigitValue(*aIter) +
SVGContentUtils::DecimalDigitValue(*iter);
if (value > 59) {
return false;
}
if (++iter != aEnd && SVGContentUtils::IsDigit(*iter)) {
return false;
}
aValue = value;
aIter = iter;
return true;
}
inline bool
ParseClockMetric(RangedPtr<const char16_t>& aIter,
const RangedPtr<const char16_t>& aEnd,
uint32_t& aMultiplier)
{
if (aIter == aEnd) {
aMultiplier = MSEC_PER_SEC;
return true;
}
switch (*aIter) {
case 'h':
if (++aIter == aEnd) {
aMultiplier = MSEC_PER_HOUR;
return true;
}
return false;
case 'm':
{
const nsAString& metric = Substring(aIter.get(), aEnd.get());
if (metric.EqualsLiteral("min")) {
aMultiplier = MSEC_PER_MIN;
aIter = aEnd;
return true;
}
if (metric.EqualsLiteral("ms")) {
aMultiplier = 1;
aIter = aEnd;
return true;
}
}
return false;
case 's':
if (++aIter == aEnd) {
aMultiplier = MSEC_PER_SEC;
return true;
}
}
return false;
}
/**
* See http://www.w3.org/TR/SVG/animate.html#ClockValueSyntax
*/
bool
ParseClockValue(RangedPtr<const char16_t>& aIter,
const RangedPtr<const char16_t>& aEnd,
nsSMILTimeValue* aResult)
{
if (aIter == aEnd) {
return false;
}
// TIMECOUNT_VALUE ::= Timecount ("." Fraction)? (Metric)?
// PARTIAL_CLOCK_VALUE ::= Minutes ":" Seconds ("." Fraction)?
// FULL_CLOCK_VALUE ::= Hours ":" Minutes ":" Seconds ("." Fraction)?
enum ClockType {
TIMECOUNT_VALUE,
PARTIAL_CLOCK_VALUE,
FULL_CLOCK_VALUE
};
int32_t clockType = TIMECOUNT_VALUE;
RangedPtr<const char16_t> iter(aIter);
// Determine which type of clock value we have by counting the number
// of colons in the string.
do {
switch (*iter) {
case ':':
if (clockType == FULL_CLOCK_VALUE) {
return false;
}
++clockType;
break;
case 'e':
case 'E':
case '-':
case '+':
// Exclude anything invalid (for clock values)
// that number parsing might otherwise allow.
return false;
}
++iter;
} while (iter != aEnd);
iter = aIter;
int32_t hours = 0, timecount;
double fraction = 0.0;
uint32_t minutes, seconds, multiplier;
switch (clockType) {
case FULL_CLOCK_VALUE:
if (!SVGContentUtils::ParseInteger(iter, aEnd, hours) ||
!ParseColon(iter, aEnd)) {
return false;
}
MOZ_FALLTHROUGH;
case PARTIAL_CLOCK_VALUE:
if (!ParseSecondsOrMinutes(iter, aEnd, minutes) ||
!ParseColon(iter, aEnd) ||
!ParseSecondsOrMinutes(iter, aEnd, seconds)) {
return false;
}
if (iter != aEnd &&
(*iter != '.' ||
!SVGContentUtils::ParseNumber(iter, aEnd, fraction))) {
return false;
}
aResult->SetMillis(nsSMILTime(hours) * MSEC_PER_HOUR +
minutes * MSEC_PER_MIN +
seconds * MSEC_PER_SEC +
NS_round(fraction * MSEC_PER_SEC));
aIter = iter;
return true;
case TIMECOUNT_VALUE:
if (!SVGContentUtils::ParseInteger(iter, aEnd, timecount)) {
return false;
}
if (iter != aEnd && *iter == '.' &&
!SVGContentUtils::ParseNumber(iter, aEnd, fraction)) {
return false;
}
if (!ParseClockMetric(iter, aEnd, multiplier)) {
return false;
}
aResult->SetMillis(nsSMILTime(timecount) * multiplier +
NS_round(fraction * multiplier));
aIter = iter;
return true;
}
return false;
}
bool
ParseOffsetValue(RangedPtr<const char16_t>& aIter,
const RangedPtr<const char16_t>& aEnd,
nsSMILTimeValue* aResult)
{
RangedPtr<const char16_t> iter(aIter);
int32_t sign;
if (!SVGContentUtils::ParseOptionalSign(iter, aEnd, sign) ||
!SkipWhitespace(iter, aEnd) ||
!ParseClockValue(iter, aEnd, aResult)) {
return false;
}
if (sign == -1) {
aResult->SetMillis(-aResult->GetMillis());
}
aIter = iter;
return true;
}
bool
ParseOffsetValue(const nsAString& aSpec,
nsSMILTimeValue* aResult)
{
RangedPtr<const char16_t> iter(SVGContentUtils::GetStartRangedPtr(aSpec));
const RangedPtr<const char16_t> end(SVGContentUtils::GetEndRangedPtr(aSpec));
return ParseOffsetValue(iter, end, aResult) && iter == end;
}
bool
ParseOptionalOffset(RangedPtr<const char16_t>& aIter,
const RangedPtr<const char16_t>& aEnd,
nsSMILTimeValue* aResult)
{
if (aIter == aEnd) {
aResult->SetMillis(0L);
return true;
}
return SkipWhitespace(aIter, aEnd) &&
ParseOffsetValue(aIter, aEnd, aResult);
}
bool
ParseAccessKey(const nsAString& aSpec, nsSMILTimeValueSpecParams& aResult)
{
MOZ_ASSERT(StringBeginsWith(aSpec, ACCESSKEY_PREFIX_CC) ||
StringBeginsWith(aSpec, ACCESSKEY_PREFIX_LC),
"Calling ParseAccessKey on non-accesskey-type spec");
nsSMILTimeValueSpecParams result;
result.mType = nsSMILTimeValueSpecParams::ACCESSKEY;
MOZ_ASSERT(ACCESSKEY_PREFIX_LC.Length() == ACCESSKEY_PREFIX_CC.Length(),
"Case variations for accesskey prefix differ in length");
RangedPtr<const char16_t> iter(SVGContentUtils::GetStartRangedPtr(aSpec));
RangedPtr<const char16_t> end(SVGContentUtils::GetEndRangedPtr(aSpec));
iter += ACCESSKEY_PREFIX_LC.Length();
// Expecting at least <accesskey> + ')'
if (end - iter < 2)
return false;
uint32_t c = *iter++;
// Process 32-bit codepoints
if (NS_IS_HIGH_SURROGATE(c)) {
if (end - iter < 2) // Expecting at least low-surrogate + ')'
return false;
uint32_t lo = *iter++;
if (!NS_IS_LOW_SURROGATE(lo))
return false;
c = SURROGATE_TO_UCS4(c, lo);
// XML 1.1 says that 0xFFFE and 0xFFFF are not valid characters
} else if (NS_IS_LOW_SURROGATE(c) || c == 0xFFFE || c == 0xFFFF) {
return false;
}
result.mRepeatIterationOrAccessKey = c;
if (*iter++ != ')')
return false;
if (!ParseOptionalOffset(iter, end, &result.mOffset) || iter != end) {
return false;
}
aResult = result;
return true;
}
void
MoveToNextToken(RangedPtr<const char16_t>& aIter,
const RangedPtr<const char16_t>& aEnd,
bool aBreakOnDot,
bool& aIsAnyCharEscaped)
{
aIsAnyCharEscaped = false;
bool isCurrentCharEscaped = false;
while (aIter != aEnd && !IsSVGWhitespace(*aIter)) {
if (isCurrentCharEscaped) {
isCurrentCharEscaped = false;
} else {
if (*aIter == '+' || *aIter == '-' ||
(aBreakOnDot && *aIter == '.')) {
break;
}
if (*aIter == '\\') {
isCurrentCharEscaped = true;
aIsAnyCharEscaped = true;
}
}
++aIter;
}
}
already_AddRefed<nsIAtom>
ConvertUnescapedTokenToAtom(const nsAString& aToken)
{
// Whether the token is an id-ref or event-symbol it should be a valid NCName
if (aToken.IsEmpty() || NS_FAILED(nsContentUtils::CheckQName(aToken, false)))
return nullptr;
return NS_Atomize(aToken);
}
already_AddRefed<nsIAtom>
ConvertTokenToAtom(const nsAString& aToken,
bool aUnescapeToken)
{
// Unescaping involves making a copy of the string which we'd like to avoid if possible
if (!aUnescapeToken) {
return ConvertUnescapedTokenToAtom(aToken);
}
nsAutoString token(aToken);
const char16_t* read = token.BeginReading();
const char16_t* const end = token.EndReading();
char16_t* write = token.BeginWriting();
bool escape = false;
while (read != end) {
MOZ_ASSERT(write <= read, "Writing past where we've read");
if (!escape && *read == '\\') {
escape = true;
++read;
} else {
*write++ = *read++;
escape = false;
}
}
token.Truncate(write - token.BeginReading());
return ConvertUnescapedTokenToAtom(token);
}
bool
ParseElementBaseTimeValueSpec(const nsAString& aSpec,
nsSMILTimeValueSpecParams& aResult)
{
nsSMILTimeValueSpecParams result;
//
// The spec will probably look something like one of these
//
// element-name.begin
// element-name.event-name
// event-name
// element-name.repeat(3)
// event\.name
//
// Technically `repeat(3)' is permitted but the behaviour in this case is not
// defined (for SMIL Animation) so we don't support it here.
//
RangedPtr<const char16_t> start(SVGContentUtils::GetStartRangedPtr(aSpec));
RangedPtr<const char16_t> end(SVGContentUtils::GetEndRangedPtr(aSpec));
if (start == end) {
return false;
}
RangedPtr<const char16_t> tokenEnd(start);
bool requiresUnescaping;
MoveToNextToken(tokenEnd, end, true, requiresUnescaping);
RefPtr<nsIAtom> atom =
ConvertTokenToAtom(Substring(start.get(), tokenEnd.get()),
requiresUnescaping);
if (atom == nullptr) {
return false;
}
// Parse the second token if there is one
if (tokenEnd != end && *tokenEnd == '.') {
result.mDependentElemID = atom;
++tokenEnd;
start = tokenEnd;
MoveToNextToken(tokenEnd, end, false, requiresUnescaping);
const nsAString& token2 = Substring(start.get(), tokenEnd.get());
// element-name.begin
if (token2.EqualsLiteral("begin")) {
result.mType = nsSMILTimeValueSpecParams::SYNCBASE;
result.mSyncBegin = true;
// element-name.end
} else if (token2.EqualsLiteral("end")) {
result.mType = nsSMILTimeValueSpecParams::SYNCBASE;
result.mSyncBegin = false;
// element-name.repeat(digit+)
} else if (StringBeginsWith(token2, REPEAT_PREFIX)) {
start += REPEAT_PREFIX.Length();
int32_t repeatValue;
if (start == tokenEnd || *start == '+' || *start == '-' ||
!SVGContentUtils::ParseInteger(start, tokenEnd, repeatValue)) {
return false;
}
if (start == tokenEnd || *start != ')') {
return false;
}
result.mType = nsSMILTimeValueSpecParams::REPEAT;
result.mRepeatIterationOrAccessKey = repeatValue;
// element-name.event-symbol
} else {
atom = ConvertTokenToAtom(token2, requiresUnescaping);
if (atom == nullptr) {
return false;
}
result.mType = nsSMILTimeValueSpecParams::EVENT;
result.mEventSymbol = atom;
}
} else {
// event-symbol
result.mType = nsSMILTimeValueSpecParams::EVENT;
result.mEventSymbol = atom;
}
// We've reached the end of the token, so we should now be either looking at
// a '+', '-' (possibly with whitespace before it), or the end.
if (!ParseOptionalOffset(tokenEnd, end, &result.mOffset) || tokenEnd != end) {
return false;
}
aResult = result;
return true;
}
} // namespace
//------------------------------------------------------------------------------
// Implementation
const nsDependentSubstring
nsSMILParserUtils::TrimWhitespace(const nsAString& aString)
{
nsAString::const_iterator start, end;
aString.BeginReading(start);
aString.EndReading(end);
// Skip whitespace characters at the beginning
while (start != end && IsSVGWhitespace(*start)) {
++start;
}
// Skip whitespace characters at the end.
while (end != start) {
--end;
if (!IsSVGWhitespace(*end)) {
// Step back to the last non-whitespace character.
++end;
break;
}
}
return Substring(start, end);
}
bool
nsSMILParserUtils::ParseKeySplines(const nsAString& aSpec,
FallibleTArray<nsSMILKeySpline>& aKeySplines)
{
nsCharSeparatedTokenizerTemplate<IsSVGWhitespace> controlPointTokenizer(aSpec, ';');
while (controlPointTokenizer.hasMoreTokens()) {
nsCharSeparatedTokenizerTemplate<IsSVGWhitespace>
tokenizer(controlPointTokenizer.nextToken(), ',',
nsCharSeparatedTokenizer::SEPARATOR_OPTIONAL);
double values[4];
for (int i = 0 ; i < 4; i++) {
if (!tokenizer.hasMoreTokens() ||
!SVGContentUtils::ParseNumber(tokenizer.nextToken(), values[i]) ||
values[i] > 1.0 || values[i] < 0.0) {
return false;
}
}
if (tokenizer.hasMoreTokens() ||
tokenizer.separatorAfterCurrentToken() ||
!aKeySplines.AppendElement(nsSMILKeySpline(values[0],
values[1],
values[2],
values[3]),
fallible)) {
return false;
}
}
return !aKeySplines.IsEmpty();
}
bool
nsSMILParserUtils::ParseSemicolonDelimitedProgressList(const nsAString& aSpec,
bool aNonDecreasing,
FallibleTArray<double>& aArray)
{
nsCharSeparatedTokenizerTemplate<IsSVGWhitespace> tokenizer(aSpec, ';');
double previousValue = -1.0;
while (tokenizer.hasMoreTokens()) {
double value;
if (!SVGContentUtils::ParseNumber(tokenizer.nextToken(), value)) {
return false;
}
if (value > 1.0 || value < 0.0 ||
(aNonDecreasing && value < previousValue)) {
return false;
}
if (!aArray.AppendElement(value, fallible)) {
return false;
}
previousValue = value;
}
return !aArray.IsEmpty();
}
// Helper class for ParseValues
class MOZ_STACK_CLASS SMILValueParser :
public nsSMILParserUtils::GenericValueParser
{
public:
SMILValueParser(const SVGAnimationElement* aSrcElement,
const nsISMILAttr* aSMILAttr,
FallibleTArray<nsSMILValue>* aValuesArray,
bool* aPreventCachingOfSandwich) :
mSrcElement(aSrcElement),
mSMILAttr(aSMILAttr),
mValuesArray(aValuesArray),
mPreventCachingOfSandwich(aPreventCachingOfSandwich)
{}
virtual bool Parse(const nsAString& aValueStr) override {
nsSMILValue newValue;
bool tmpPreventCachingOfSandwich = false;
if (NS_FAILED(mSMILAttr->ValueFromString(aValueStr, mSrcElement, newValue,
tmpPreventCachingOfSandwich)))
return false;
if (!mValuesArray->AppendElement(newValue, fallible)) {
return false;
}
if (tmpPreventCachingOfSandwich) {
*mPreventCachingOfSandwich = true;
}
return true;
}
protected:
const SVGAnimationElement* mSrcElement;
const nsISMILAttr* mSMILAttr;
FallibleTArray<nsSMILValue>* mValuesArray;
bool* mPreventCachingOfSandwich;
};
bool
nsSMILParserUtils::ParseValues(const nsAString& aSpec,
const SVGAnimationElement* aSrcElement,
const nsISMILAttr& aAttribute,
FallibleTArray<nsSMILValue>& aValuesArray,
bool& aPreventCachingOfSandwich)
{
// Assume all results can be cached, until we find one that can't.
aPreventCachingOfSandwich = false;
SMILValueParser valueParser(aSrcElement, &aAttribute,
&aValuesArray, &aPreventCachingOfSandwich);
return ParseValuesGeneric(aSpec, valueParser);
}
bool
nsSMILParserUtils::ParseValuesGeneric(const nsAString& aSpec,
GenericValueParser& aParser)
{
nsCharSeparatedTokenizerTemplate<IsSVGWhitespace> tokenizer(aSpec, ';');
if (!tokenizer.hasMoreTokens()) { // Empty list
return false;
}
while (tokenizer.hasMoreTokens()) {
if (!aParser.Parse(tokenizer.nextToken())) {
return false;
}
}
return true;
}
bool
nsSMILParserUtils::ParseRepeatCount(const nsAString& aSpec,
nsSMILRepeatCount& aResult)
{
const nsAString& spec =
nsSMILParserUtils::TrimWhitespace(aSpec);
if (spec.EqualsLiteral("indefinite")) {
aResult.SetIndefinite();
return true;
}
double value;
if (!SVGContentUtils::ParseNumber(spec, value) || value <= 0.0) {
return false;
}
aResult = value;
return true;
}
bool
nsSMILParserUtils::ParseTimeValueSpecParams(const nsAString& aSpec,
nsSMILTimeValueSpecParams& aResult)
{
const nsAString& spec = TrimWhitespace(aSpec);
if (spec.EqualsLiteral("indefinite")) {
aResult.mType = nsSMILTimeValueSpecParams::INDEFINITE;
return true;
}
// offset type
if (ParseOffsetValue(spec, &aResult.mOffset)) {
aResult.mType = nsSMILTimeValueSpecParams::OFFSET;
return true;
}
// wallclock type
if (StringBeginsWith(spec, WALLCLOCK_PREFIX)) {
return false; // Wallclock times not implemented
}
// accesskey type
if (StringBeginsWith(spec, ACCESSKEY_PREFIX_LC) ||
StringBeginsWith(spec, ACCESSKEY_PREFIX_CC)) {
return ParseAccessKey(spec, aResult);
}
// event, syncbase, or repeat
return ParseElementBaseTimeValueSpec(spec, aResult);
}
bool
nsSMILParserUtils::ParseClockValue(const nsAString& aSpec,
nsSMILTimeValue* aResult)
{
RangedPtr<const char16_t> iter(SVGContentUtils::GetStartRangedPtr(aSpec));
RangedPtr<const char16_t> end(SVGContentUtils::GetEndRangedPtr(aSpec));
return ::ParseClockValue(iter, end, aResult) && iter == end;
}
int32_t
nsSMILParserUtils::CheckForNegativeNumber(const nsAString& aStr)
{
int32_t absValLocation = -1;
RangedPtr<const char16_t> start(SVGContentUtils::GetStartRangedPtr(aStr));
RangedPtr<const char16_t> iter = start;
RangedPtr<const char16_t> end(SVGContentUtils::GetEndRangedPtr(aStr));
// Skip initial whitespace
while (iter != end && IsSVGWhitespace(*iter)) {
++iter;
}
// Check for dash
if (iter != end && *iter == '-') {
++iter;
// Check for numeric character
if (iter != end && SVGContentUtils::IsDigit(*iter)) {
absValLocation = iter - start;
}
}
return absValLocation;
}