/* -*- 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; }