dom/svg/SVGTransformListParser.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "SVGTransformListParser.h"
   8
   9 #include "mozilla/ArrayUtils.h"
  10 #include "SVGContentUtils.h"
  11 #include "SVGTransform.h"
  12 #include "nsGkAtoms.h"
  13 #include "nsAtom.h"
  14
  15 namespace mozilla {
  16
  17 //----------------------------------------------------------------------
  18 // private methods
  19
  20 bool SVGTransformListParser::Parse() {
  21   mTransforms.Clear();
  22   return ParseTransforms();
  23 }
  24
  25 bool SVGTransformListParser::ParseTransforms() {
  26   if (!SkipWsp()) {
  27     return true;
  28   }
  29
  30   if (!ParseTransform()) {
  31     return false;
  32   }
  33
  34   while (SkipWsp()) {
  35     // The SVG BNF allows multiple comma-wsp between transforms
  36     while (*mIter == ',') {
  37       ++mIter;
  38       if (!SkipWsp()) {
  39         return false;
  40       }
  41     }
  42
  43     if (!ParseTransform()) {
  44       return false;
  45     }
  46   }
  47   return true;
  48 }
  49
  50 bool SVGTransformListParser::ParseTransform() {
  51   RangedPtr<const char16_t> start(mIter);
  52   while (IsAlpha(*mIter)) {
  53     ++mIter;
  54     if (mIter == mEnd) {
  55       return false;
  56     }
  57   }
  58
  59   if (start == mIter) {
  60     // Didn't read anything
  61     return false;
  62   }
  63
  64   const nsAString& transform = Substring(start.get(), mIter.get());
  65   nsStaticAtom* keyAtom = NS_GetStaticAtom(transform);
  66
  67   if (!keyAtom || !SkipWsp()) {
  68     return false;
  69   }
  70
  71   if (keyAtom == nsGkAtoms::translate) {
  72     return ParseTranslate();
  73   }
  74   if (keyAtom == nsGkAtoms::scale) {
  75     return ParseScale();
  76   }
  77   if (keyAtom == nsGkAtoms::rotate) {
  78     return ParseRotate();
  79   }
  80   if (keyAtom == nsGkAtoms::skewX) {
  81     return ParseSkewX();
  82   }
  83   if (keyAtom == nsGkAtoms::skewY) {
  84     return ParseSkewY();
  85   }
  86   if (keyAtom == nsGkAtoms::matrix) {
  87     return ParseMatrix();
  88   }
  89   return false;
  90 }
  91
  92 bool SVGTransformListParser::ParseArguments(float* aResult, uint32_t aMaxCount,
  93                                             uint32_t* aParsedCount) {
  94   if (*mIter != '(') {
  95     return false;
  96   }
  97   ++mIter;
  98
  99   if (!SkipWsp()) {
 100     return false;
 101   }
 102
 103   if (!SVGContentUtils::ParseNumber(mIter, mEnd, aResult[0])) {
 104     return false;
 105   }
 106   *aParsedCount = 1;
 107
 108   while (SkipWsp()) {
 109     if (*mIter == ')') {
 110       ++mIter;
 111       return true;
 112     }
 113     if (*aParsedCount == aMaxCount) {
 114       return false;
 115     }
 116     SkipCommaWsp();
 117     if (!SVGContentUtils::ParseNumber(mIter, mEnd,
 118                                       aResult[(*aParsedCount)++])) {
 119       return false;
 120     }
 121   }
 122   return false;
 123 }
 124
 125 bool SVGTransformListParser::ParseTranslate() {
 126   float t[2];
 127   uint32_t count;
 128
 129   if (!ParseArguments(t, ArrayLength(t), &count)) {
 130     return false;
 131   }
 132
 133   switch (count) {
 134     case 1:
 135       t[1] = 0.f;
 136       [[fallthrough]];
 137     case 2: {
 138       SVGTransform* transform = mTransforms.AppendElement(fallible);
 139       if (!transform) {
 140         return false;
 141       }
 142       transform->SetTranslate(t[0], t[1]);
 143       return true;
 144     }
 145   }
 146
 147   return false;
 148 }
 149
 150 bool SVGTransformListParser::ParseScale() {
 151   float s[2];
 152   uint32_t count;
 153
 154   if (!ParseArguments(s, ArrayLength(s), &count)) {
 155     return false;
 156   }
 157
 158   switch (count) {
 159     case 1:
 160       s[1] = s[0];
 161       [[fallthrough]];
 162     case 2: {
 163       SVGTransform* transform = mTransforms.AppendElement(fallible);
 164       if (!transform) {
 165         return false;
 166       }
 167       transform->SetScale(s[0], s[1]);
 168       return true;
 169     }
 170   }
 171
 172   return false;
 173 }
 174
 175 bool SVGTransformListParser::ParseRotate() {
 176   float r[3];
 177   uint32_t count;
 178
 179   if (!ParseArguments(r, ArrayLength(r), &count)) {
 180     return false;
 181   }
 182
 183   switch (count) {
 184     case 1:
 185       r[1] = r[2] = 0.f;
 186       [[fallthrough]];
 187     case 3: {
 188       SVGTransform* transform = mTransforms.AppendElement(fallible);
 189       if (!transform) {
 190         return false;
 191       }
 192       transform->SetRotate(r[0], r[1], r[2]);
 193       return true;
 194     }
 195   }
 196
 197   return false;
 198 }
 199
 200 bool SVGTransformListParser::ParseSkewX() {
 201   float skew;
 202   uint32_t count;
 203
 204   if (!ParseArguments(&skew, 1, &count) || count != 1) {
 205     return false;
 206   }
 207
 208   SVGTransform* transform = mTransforms.AppendElement(fallible);
 209   if (!transform) {
 210     return false;
 211   }
 212   transform->SetSkewX(skew);
 213
 214   return true;
 215 }
 216
 217 bool SVGTransformListParser::ParseSkewY() {
 218   float skew;
 219   uint32_t count;
 220
 221   if (!ParseArguments(&skew, 1, &count) || count != 1) {
 222     return false;
 223   }
 224
 225   SVGTransform* transform = mTransforms.AppendElement(fallible);
 226   if (!transform) {
 227     return false;
 228   }
 229   transform->SetSkewY(skew);
 230
 231   return true;
 232 }
 233
 234 bool SVGTransformListParser::ParseMatrix() {
 235   float m[6];
 236   uint32_t count;
 237
 238   if (!ParseArguments(m, ArrayLength(m), &count) || count != 6) {
 239     return false;
 240   }
 241
 242   SVGTransform* transform = mTransforms.AppendElement(fallible);
 243   if (!transform) {
 244     return false;
 245   }
 246   transform->SetMatrix(gfxMatrix(m[0], m[1], m[2], m[3], m[4], m[5]));
 247
 248   return true;
 249 }
 250
 251 }  // namespace mozilla