gecko-dev/dom/svg/SVGTransformListParser.cpp
Chris Peterson 406763af7f Bug 1570499 - Part 1: Replace MOZ_FALLTHROUGH macro with C++17's [[fallthrough]] attribute. r=froydnj
This changeset is a simple find and replace of `MOZ_FALLTHROUGH` and `[[fallthrough]]`.

Unfortunately, the MOZ_FALLTHROUGH_ASSERT macro (to assert on case fallthrough in debug builds) is still necessary after switching from [[clang::fallthrough]] to [[fallthrough]] because:

* MOZ_ASSERT(false) followed by [[fallthrough]] triggers a -Wunreachable-code warning in DEBUG builds
* but MOZ_ASSERT(false) without [[fallthrough]] triggers a -Wimplicit-fallthrough warning in NDEBUG builds.

Differential Revision: https://phabricator.services.mozilla.com/D56440

--HG--
extra : moz-landing-system : lando
2019-12-20 07:16:43 +00:00

252 lines
4.9 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 "SVGTransformListParser.h"
#include "mozilla/ArrayUtils.h"
#include "SVGContentUtils.h"
#include "SVGTransform.h"
#include "nsGkAtoms.h"
#include "nsAtom.h"
namespace mozilla {
//----------------------------------------------------------------------
// private methods
bool SVGTransformListParser::Parse() {
mTransforms.Clear();
return ParseTransforms();
}
bool SVGTransformListParser::ParseTransforms() {
if (!SkipWsp()) {
return true;
}
if (!ParseTransform()) {
return false;
}
while (SkipWsp()) {
// The SVG BNF allows multiple comma-wsp between transforms
while (*mIter == ',') {
++mIter;
if (!SkipWsp()) {
return false;
}
}
if (!ParseTransform()) {
return false;
}
}
return true;
}
bool SVGTransformListParser::ParseTransform() {
RangedPtr<const char16_t> start(mIter);
while (IsAlpha(*mIter)) {
++mIter;
if (mIter == mEnd) {
return false;
}
}
if (start == mIter) {
// Didn't read anything
return false;
}
const nsAString& transform = Substring(start.get(), mIter.get());
nsStaticAtom* keyAtom = NS_GetStaticAtom(transform);
if (!keyAtom || !SkipWsp()) {
return false;
}
if (keyAtom == nsGkAtoms::translate) {
return ParseTranslate();
}
if (keyAtom == nsGkAtoms::scale) {
return ParseScale();
}
if (keyAtom == nsGkAtoms::rotate) {
return ParseRotate();
}
if (keyAtom == nsGkAtoms::skewX) {
return ParseSkewX();
}
if (keyAtom == nsGkAtoms::skewY) {
return ParseSkewY();
}
if (keyAtom == nsGkAtoms::matrix) {
return ParseMatrix();
}
return false;
}
bool SVGTransformListParser::ParseArguments(float* aResult, uint32_t aMaxCount,
uint32_t* aParsedCount) {
if (*mIter != '(') {
return false;
}
++mIter;
if (!SkipWsp()) {
return false;
}
if (!SVGContentUtils::ParseNumber(mIter, mEnd, aResult[0])) {
return false;
}
*aParsedCount = 1;
while (SkipWsp()) {
if (*mIter == ')') {
++mIter;
return true;
}
if (*aParsedCount == aMaxCount) {
return false;
}
SkipCommaWsp();
if (!SVGContentUtils::ParseNumber(mIter, mEnd,
aResult[(*aParsedCount)++])) {
return false;
}
}
return false;
}
bool SVGTransformListParser::ParseTranslate() {
float t[2];
uint32_t count;
if (!ParseArguments(t, ArrayLength(t), &count)) {
return false;
}
switch (count) {
case 1:
t[1] = 0.f;
[[fallthrough]];
case 2: {
SVGTransform* transform = mTransforms.AppendElement(fallible);
if (!transform) {
return false;
}
transform->SetTranslate(t[0], t[1]);
return true;
}
}
return false;
}
bool SVGTransformListParser::ParseScale() {
float s[2];
uint32_t count;
if (!ParseArguments(s, ArrayLength(s), &count)) {
return false;
}
switch (count) {
case 1:
s[1] = s[0];
[[fallthrough]];
case 2: {
SVGTransform* transform = mTransforms.AppendElement(fallible);
if (!transform) {
return false;
}
transform->SetScale(s[0], s[1]);
return true;
}
}
return false;
}
bool SVGTransformListParser::ParseRotate() {
float r[3];
uint32_t count;
if (!ParseArguments(r, ArrayLength(r), &count)) {
return false;
}
switch (count) {
case 1:
r[1] = r[2] = 0.f;
[[fallthrough]];
case 3: {
SVGTransform* transform = mTransforms.AppendElement(fallible);
if (!transform) {
return false;
}
transform->SetRotate(r[0], r[1], r[2]);
return true;
}
}
return false;
}
bool SVGTransformListParser::ParseSkewX() {
float skew;
uint32_t count;
if (!ParseArguments(&skew, 1, &count) || count != 1) {
return false;
}
SVGTransform* transform = mTransforms.AppendElement(fallible);
if (!transform) {
return false;
}
transform->SetSkewX(skew);
return true;
}
bool SVGTransformListParser::ParseSkewY() {
float skew;
uint32_t count;
if (!ParseArguments(&skew, 1, &count) || count != 1) {
return false;
}
SVGTransform* transform = mTransforms.AppendElement(fallible);
if (!transform) {
return false;
}
transform->SetSkewY(skew);
return true;
}
bool SVGTransformListParser::ParseMatrix() {
float m[6];
uint32_t count;
if (!ParseArguments(m, ArrayLength(m), &count) || count != 6) {
return false;
}
SVGTransform* transform = mTransforms.AppendElement(fallible);
if (!transform) {
return false;
}
transform->SetMatrix(gfxMatrix(m[0], m[1], m[2], m[3], m[4], m[5]));
return true;
}
} // namespace mozilla