MeasureRead: More accurate measure length validation

Author: cbjeukendrup

src/engraving/rw/read400/measurerw.cpp

@@ -86,24 +86,18 @@ void MeasureRead::readMeasure(Measure* measure, XmlReader& e, ReadContext& ctx,
         measure->m_mstaves.push_back(s);
     }
 
-    bool irregular;
+    bool irregular = false;
     if (e.hasAttribute("len")) {
-        StringList sl = e.attribute("len").split(u'/');
-        if (sl.size() == 2) {
-            measure->m_len = Fraction(sl.at(0).toInt(), sl.at(1).toInt());
-        } else {
-            LOGD("illegal measure size <%s>", muPrintable(e.attribute("len")));
-        }
-        irregular = true;
-        if (measure->m_len.numerator() <= 0 || measure->m_len.denominator() <= 0 || measure->m_len.denominator() > 128) {
-            e.raiseError(muse::mtrc("engraving",
-                                    "MSCX error at line %1: invalid measure length: %2").arg(e.lineNumber()).arg(measure->m_len.toString()));
+        bool ok = true;
+        measure->m_len = Fraction::fromString(e.attribute("len"), &ok);
+        if (!ok || measure->m_len < Fraction(1, 128)) {
+            e.raiseError(muse::mtrc("engraving", "MSCX error at line %1: invalid measure length: %2")
+                         .arg(e.lineNumber()).arg(e.attribute("len")));
             return;
         }
+        irregular = true;
         ctx.compatTimeSigMap()->add(measure->tick().ticks(), SigEvent(measure->m_len, measure->m_timesig));
         ctx.compatTimeSigMap()->add((measure->tick() + measure->ticks()).ticks(), SigEvent(measure->m_timesig));
-    } else {
-        irregular = false;
     }
 
     while (e.readNextStartElement()) {

src/engraving/rw/read410/measureread.cpp

@@ -84,24 +84,18 @@ void MeasureRead::readMeasure(Measure* measure, XmlReader& e, ReadContext& ctx,
         measure->m_mstaves.push_back(s);
     }
 
-    bool irregular;
+    bool irregular = false;
     if (e.hasAttribute("len")) {
-        StringList sl = e.attribute("len").split(u'/');
-        if (sl.size() == 2) {
-            measure->m_len = Fraction(sl.at(0).toInt(), sl.at(1).toInt());
-        } else {
-            LOGD("illegal measure size <%s>", muPrintable(e.attribute("len")));
-        }
-        irregular = true;
-        if (measure->m_len.numerator() <= 0 || measure->m_len.denominator() <= 0 || measure->m_len.denominator() > 128) {
-            e.raiseError(muse::mtrc("engraving",
-                                    "MSCX error at line %1: invalid measure length: %2").arg(e.lineNumber()).arg(measure->m_len.toString()));
+        bool ok = true;
+        measure->m_len = Fraction::fromString(e.attribute("len"), &ok);
+        if (!ok || measure->m_len < Fraction(1, 128)) {
+            e.raiseError(muse::mtrc("engraving", "MSCX error at line %1: invalid measure length: %2")
+                         .arg(e.lineNumber()).arg(e.attribute("len")));
             return;
         }
+        irregular = true;
         ctx.compatTimeSigMap()->add(measure->tick().ticks(), SigEvent(measure->m_len, measure->m_timesig));
         ctx.compatTimeSigMap()->add((measure->tick() + measure->ticks()).ticks(), SigEvent(measure->m_timesig));
-    } else {
-        irregular = false;
     }
 
     while (e.readNextStartElement()) {

src/engraving/types/fraction.h

@@ -258,10 +258,24 @@ class Fraction
     static constexpr Fraction eps() { return Fraction(1, Constants::DIVISION * 4); }
 
     muse::String toString() const { return muse::String(u"%1/%2").arg(m_numerator, m_denominator); }
-    static Fraction fromString(const muse::String& str)
+    static Fraction fromString(const muse::String& str, bool* ok = nullptr)
     {
         const size_t i = str.indexOf(u'/');
-        return (i == muse::nidx) ? Fraction(str.toInt(), 1) : Fraction(str.left(i).toInt(), str.mid(i + 1).toInt());
+        if (i == muse::nidx) {
+            return Fraction(str.toInt(ok), 1);
+        }
+
+        int numerator = str.left(i).toInt(ok);
+        if (ok && !*ok) {
+            return Fraction();
+        }
+
+        int denominator = str.mid(i + 1).toInt(ok);
+        if (ok && !*ok) {
+            return Fraction();
+        }
+
+        return Fraction(numerator, denominator);
     }
 
     constexpr double toDouble() const { return static_cast<double>(m_numerator) / static_cast<double>(m_denominator); }