Source code
Revision control
Copy as Markdown
Other Tools
/* -*- 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
#include "SMILParserUtils.h"
#include "mozilla/SMILAttr.h"
#include "mozilla/SMILKeySpline.h"
#include "mozilla/SMILRepeatCount.h"
#include "mozilla/SMILTimeValueSpecParams.h"
#include "mozilla/SMILTypes.h"
#include "mozilla/SMILValue.h"
#include "mozilla/SVGContentUtils.h"
#include "mozilla/TextUtils.h"
#include "nsContentUtils.h"
#include "nsCharSeparatedTokenizer.h"
using namespace mozilla::dom;
//------------------------------------------------------------------------------
// Helper functions and Constants
namespace {
using namespace mozilla;
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 u"accesskey("_ns // SMIL2+
#define ACCESSKEY_PREFIX_CC u"accessKey("_ns // SVG/SMIL ANIM
#define REPEAT_PREFIX u"repeat("_ns
#define WALLCLOCK_PREFIX u"wallclock("_ns
inline bool SkipWhitespace(RangedPtr<const char16_t>& aIter,
const RangedPtr<const char16_t>& aEnd) {
while (aIter != aEnd) {
if (!nsContentUtils::IsHTMLWhitespace(*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 || !mozilla::IsAsciiDigit(*aIter)) {
return false;
}
RangedPtr<const char16_t> iter(aIter);
if (++iter == aEnd || !mozilla::IsAsciiDigit(*iter)) {
return false;
}
uint32_t value = 10 * mozilla::AsciiAlphanumericToNumber(*aIter) +
mozilla::AsciiAlphanumericToNumber(*iter);
if (value > 59) {
return false;
}
if (++iter != aEnd && mozilla::IsAsciiDigit(*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;
}
/**
*/
bool ParseClockValue(RangedPtr<const char16_t>& aIter,
const RangedPtr<const char16_t>& aEnd,
SMILTimeValue::Rounding aRounding,
SMILTimeValue* 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 = 0;
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;
}
[[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(SMILTime(hours) * MSEC_PER_HOUR +
minutes * MSEC_PER_MIN +
(seconds + fraction) * MSEC_PER_SEC,
aRounding);
aIter = iter;
return true;
case TIMECOUNT_VALUE:
if (*iter != '.' &&
!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((timecount + fraction) * multiplier, aRounding);
aIter = iter;
return true;
}
return false;
}
bool ParseOffsetValue(RangedPtr<const char16_t>& aIter,
const RangedPtr<const char16_t>& aEnd,
SMILTimeValue* aResult) {
RangedPtr<const char16_t> iter(aIter);
int32_t sign;
if (!SVGContentUtils::ParseOptionalSign(iter, aEnd, sign) ||
!SkipWhitespace(iter, aEnd) ||
!ParseClockValue(iter, aEnd, SMILTimeValue::Rounding::Nearest, aResult)) {
return false;
}
if (sign == -1) {
aResult->SetMillis(-aResult->GetMillis());
}
aIter = iter;
return true;
}
bool ParseOffsetValue(const nsAString& aSpec, SMILTimeValue* 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,
SMILTimeValue* aResult) {
if (aIter == aEnd) {
*aResult = SMILTimeValue::Zero();
return true;
}
return SkipWhitespace(aIter, aEnd) && ParseOffsetValue(aIter, aEnd, aResult);
}
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 && !nsContentUtils::IsHTMLWhitespace(*aIter)) {
if (isCurrentCharEscaped) {
isCurrentCharEscaped = false;
} else {
if (*aIter == '+' || *aIter == '-' || (aBreakOnDot && *aIter == '.')) {
break;
}
if (*aIter == '\\') {
isCurrentCharEscaped = true;
aIsAnyCharEscaped = true;
}
}
++aIter;
}
}
already_AddRefed<nsAtom> 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<nsAtom> 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,
SMILTimeValueSpecParams& aResult) {
SMILTimeValueSpecParams 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<nsAtom> 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 = SMILTimeValueSpecParams::SYNCBASE;
result.mSyncBegin = true;
// element-name.end
} else if (token2.EqualsLiteral("end")) {
result.mType = SMILTimeValueSpecParams::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 = SMILTimeValueSpecParams::REPEAT;
result.mRepeatIteration = repeatValue;
// element-name.event-symbol
} else {
atom = ConvertTokenToAtom(token2, requiresUnescaping);
if (atom == nullptr) {
return false;
}
result.mType = SMILTimeValueSpecParams::EVENT;
result.mEventSymbol = atom;
}
} else {
// event-symbol
result.mType = SMILTimeValueSpecParams::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
namespace mozilla {
//------------------------------------------------------------------------------
// Implementation
const nsDependentSubstring SMILParserUtils::TrimWhitespace(
const nsAString& aString) {
nsAString::const_iterator start, end;
aString.BeginReading(start);
aString.EndReading(end);
// Skip whitespace characters at the beginning
while (start != end && nsContentUtils::IsHTMLWhitespace(*start)) {
++start;
}
// Skip whitespace characters at the end.
while (end != start) {
--end;
if (!nsContentUtils::IsHTMLWhitespace(*end)) {
// Step back to the last non-whitespace character.
++end;
break;
}
}
return Substring(start, end);
}
bool SMILParserUtils::ParseKeySplines(
const nsAString& aSpec, FallibleTArray<SMILKeySpline>& aKeySplines) {
for (const auto& controlPoint :
nsCharSeparatedTokenizerTemplate<nsContentUtils::IsHTMLWhitespace>(aSpec,
';')
.ToRange()) {
nsCharSeparatedTokenizerTemplate<nsContentUtils::IsHTMLWhitespace,
nsTokenizerFlags::SeparatorOptional>
tokenizer(controlPoint, ',');
double values[4];
for (auto& value : values) {
if (!tokenizer.hasMoreTokens() ||
!SVGContentUtils::ParseNumber(tokenizer.nextToken(), value) ||
value > 1.0 || value < 0.0) {
return false;
}
}
if (tokenizer.hasMoreTokens() || tokenizer.separatorAfterCurrentToken() ||
!aKeySplines.AppendElement(
SMILKeySpline(values[0], values[1], values[2], values[3]),
fallible)) {
return false;
}
}
return !aKeySplines.IsEmpty();
}
bool SMILParserUtils::ParseSemicolonDelimitedProgressList(
const nsAString& aSpec, bool aNonDecreasing,
FallibleTArray<double>& aArray) {
nsCharSeparatedTokenizerTemplate<nsContentUtils::IsHTMLWhitespace> 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 SMILParserUtils::GenericValueParser {
public:
SMILValueParser(const SVGAnimationElement* aSrcElement,
const SMILAttr* aSMILAttr,
FallibleTArray<SMILValue>* aValuesArray,
bool* aPreventCachingOfSandwich)
: mSrcElement(aSrcElement),
mSMILAttr(aSMILAttr),
mValuesArray(aValuesArray),
mPreventCachingOfSandwich(aPreventCachingOfSandwich) {}
bool Parse(const nsAString& aValueStr) override {
SMILValue newValue;
if (NS_FAILED(mSMILAttr->ValueFromString(aValueStr, mSrcElement, newValue,
*mPreventCachingOfSandwich)))
return false;
if (!mValuesArray->AppendElement(newValue, fallible)) {
return false;
}
return true;
}
protected:
const SVGAnimationElement* mSrcElement;
const SMILAttr* mSMILAttr;
FallibleTArray<SMILValue>* mValuesArray;
bool* mPreventCachingOfSandwich;
};
bool SMILParserUtils::ParseValues(const nsAString& aSpec,
const SVGAnimationElement* aSrcElement,
const SMILAttr& aAttribute,
FallibleTArray<SMILValue>& 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 SMILParserUtils::ParseValuesGeneric(const nsAString& aSpec,
GenericValueParser& aParser) {
nsCharSeparatedTokenizerTemplate<nsContentUtils::IsHTMLWhitespace> tokenizer(
aSpec, ';');
if (!tokenizer.hasMoreTokens()) { // Empty list
return false;
}
while (tokenizer.hasMoreTokens()) {
if (!aParser.Parse(tokenizer.nextToken())) {
return false;
}
}
return true;
}
bool SMILParserUtils::ParseRepeatCount(const nsAString& aSpec,
SMILRepeatCount& aResult) {
const nsAString& spec = SMILParserUtils::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 SMILParserUtils::ParseTimeValueSpecParams(
const nsAString& aSpec, SMILTimeValueSpecParams& aResult) {
const nsAString& spec = TrimWhitespace(aSpec);
if (spec.EqualsLiteral("indefinite")) {
aResult.mType = SMILTimeValueSpecParams::INDEFINITE;
return true;
}
// offset type
if (ParseOffsetValue(spec, &aResult.mOffset)) {
aResult.mType = SMILTimeValueSpecParams::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 false; // accesskey is not supported
}
// event, syncbase, or repeat
return ParseElementBaseTimeValueSpec(spec, aResult);
}
bool SMILParserUtils::ParseClockValue(const nsAString& aSpec,
SMILTimeValue::Rounding aRounding,
SMILTimeValue* aResult) {
RangedPtr<const char16_t> iter(SVGContentUtils::GetStartRangedPtr(aSpec));
RangedPtr<const char16_t> end(SVGContentUtils::GetEndRangedPtr(aSpec));
return ::ParseClockValue(iter, end, aRounding, aResult) && iter == end;
}
int32_t SMILParserUtils::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 && nsContentUtils::IsHTMLWhitespace(*iter)) {
++iter;
}
// Check for dash
if (iter != end && *iter == '-') {
++iter;
// Check for numeric character
if (iter != end && mozilla::IsAsciiDigit(*iter)) {
absValLocation = iter - start;
}
}
return absValLocation;
}
} // namespace mozilla