openSUSE Build Service

Overview Repositories Revisions Requests Users Attributes Meta

File 2004-temp.patch of Package kcalc (Revision a5b2511d8f5bdfd7ba9d17623260bd74)

Currently displaying revision a5b2511d8f5bdfd7ba9d17623260bd74 , Show latest

diff --git a/kcalc.cpp b/kcalc.cpp
index c55b26b42388d58b3af6193aa58b732505539c70..5cc136066e632ae2ff0988b42f395945d3e47df6 100644
--- a/kcalc.cpp
+++ b/kcalc.cpp
@@ -788,9 +788,6 @@ void KCalculator::slotBaseSelected()
         (num_button_group_->buttons().at(i))->setEnabled(false);
     }
 
-    // Only enable the decimal point in decimal
-    pbPeriod->setEnabled(current_base == NB_DECIMAL);
-
     // Only enable the x*10^y button in decimal
     pbEE->setEnabled(current_base == NB_DECIMAL);
 
diff --git a/kcalc_display.cpp b/kcalc_display.cpp
index b6e0f2321f98da5a5f1074c7b55f93bc6759d8d4..227422f218b2d0bd6c91535189c3157f82e2548a 100644
--- a/kcalc_display.cpp
+++ b/kcalc_display.cpp
@@ -483,30 +483,13 @@ bool KCalcDisplay::setAmount(const KNumber &new_amount)
     neg_sign_ = false;
     eestate_ = false;
 
-    if ((num_base_ != NB_DECIMAL) && (new_amount.type() != KNumber::TYPE_ERROR)) {
+    if (twoscomplement_ && num_base_ != NB_DECIMAL && new_amount.type() != KNumber::TYPE_ERROR) {
+        // treat number as 64-bit unsigned
         display_amount_ = new_amount.integerPart();
-
-        if (twoscomplement_) {
-            // treat number as 64-bit unsigned
-            const quint64 tmp_workaround = display_amount_.toUint64();
-            display_str = QString::number(tmp_workaround, num_base_).toUpper();
-        } else {
-            // QString::number treats non-decimal as unsigned
-            qint64 tmp_workaround = display_amount_.toInt64();
-            const bool neg = tmp_workaround < 0;
-            if (neg) {
-                tmp_workaround = qAbs(tmp_workaround);
-            }
-
-            display_str = QString::number(tmp_workaround, num_base_).toUpper();
-            if (neg) {
-                display_str.prepend(QLocale().negativeSign());
-            }
-        }
+        display_str = QString::number(display_amount_.toUint64(), num_base_).toUpper();
     } else {
-        // num_base_ == NB_DECIMAL || new_amount.type() == KNumber::TYPE_ERROR
         display_amount_ = new_amount;
-        display_str = display_amount_.toQString(KCalcSettings::precision(), fixed_precision_);
+        display_str = display_amount_.toStringInBase(num_base_, KCalcSettings::precision(), fixed_precision_);
     }
 
     setText(display_str);
@@ -674,18 +657,24 @@ QString KCalcDisplay::formatDecimalNumber(QString string)
 //------------------------------------------------------------------------------
 QString KCalcDisplay::groupDigits(const QString &displayString, int numDigits)
 {
-    QString tmpDisplayString;
-    const int stringLength = displayString.length();
+    const QString decimalPoint = locale().decimalPoint();
+    QString resultString = QString(displayString).replace(u'.', decimalPoint);
 
-    for (int i = stringLength; i > 0; i--) {
-        if (i % numDigits == 0 && i != stringLength) {
-            tmpDisplayString = tmpDisplayString + QLatin1Char(' ');
+    if (groupdigits_ && !(locale().numberOptions() & QLocale::OmitGroupSeparator)) {
+        int pos = resultString.indexOf(decimalPoint);
+        if (pos == -1) {
+            pos = resultString.length();
         }
 
-        tmpDisplayString = tmpDisplayString + displayString[stringLength - i];
+        const QString groupSeparator = locale().groupSeparator();
+        for (int i = pos - 1; i > 0; i--) {
+            if ((pos - i) % numDigits == 0) {
+                resultString.insert(i, groupSeparator);
+            }
+        }
     }
 
-    return tmpDisplayString;
+    return resultString;
 }
 
 //------------------------------------------------------------------------------
diff --git a/kcalc_parser.cpp b/kcalc_parser.cpp
index 7a9d0b34e68b12385254e3ffc6ffc1b06bce0d6f..d8645e2ef56fc67f46a5438f047b5861906081e5 100644
--- a/kcalc_parser.cpp
+++ b/kcalc_parser.cpp
@@ -15,6 +15,16 @@
 #include <QRegularExpressionMatch>
 #include <QString>
 
+const QString KCalcParser::HEX_NUMBER_PATTERN = QLatin1String("(0*)(([0-9A-Fa-f]*)[.,]?[0-9A-Fa-f]+([pP@]([+-]?[0-9]+))?)");
+const QString KCalcParser::DECIMAL_NUMBER_PATTERN = QLatin1String("(0*)(([0-9]*)[.,]?[0-9]+([eE@]([+-]?[0-9]+))?)");
+const QString KCalcParser::OCTAL_NUMBER_PATTERN = QLatin1String("(0*)(([0-7]*)[.,]?[0-7]+([eE@]([+-]?[0-9]+))?)");
+const QString KCalcParser::BINARY_NUMBER_PATTERN = QLatin1String("(0*)(([01]*)[.,]?[01]+([pP@]([+-]?[0-9]+))?)");
+
+const QRegularExpression KCalcParser::HEX_NUMBER_REGEX = QRegularExpression(KCalcParser::HEX_NUMBER_PATTERN);
+const QRegularExpression KCalcParser::DECIMAL_NUMBER_REGEX = QRegularExpression(KCalcParser::DECIMAL_NUMBER_PATTERN);
+const QRegularExpression KCalcParser::OCTAL_NUMBER_REGEX = QRegularExpression(KCalcParser::OCTAL_NUMBER_PATTERN);
+const QRegularExpression KCalcParser::BINARY_NUMBER_REGEX = QRegularExpression(KCalcParser::BINARY_NUMBER_PATTERN);
+
 //------------------------------------------------------------------------------
 // Name: KCalcParser
 // Desc: constructor
@@ -48,13 +58,13 @@ KCalcToken::TokenCode KCalcParser::stringToToken(const QString &buffer, int &ind
 
     if (s.startsWith(HEX_NUMBER_PREFIX_STR)) {
         QRegularExpressionMatch match;
-        int numIndex = buffer.indexOf(QRegularExpression(QLatin1String("0x[0-9A-F]{1,}")), index, &match);
-        if (numIndex == index) {
-            token_KNumber_ = match.captured();
-            if (match.captured().size() > 16) {
-                return KCalcToken::TokenCode::INVALID_TOKEN;
-            }
-            index += match.captured().size();
+        int numIndex = buffer.indexOf(HEX_NUMBER_REGEX, index + HEX_NUMBER_PREFIX_STR.length(), &match);
+        if (numIndex == index + HEX_NUMBER_PREFIX_STR.length()) {
+            token_KNumber_ = HEX_NUMBER_PREFIX_STR + match.captured();
+            // if (match.captured().size() > 16) {
+            //     return KCalcToken::TokenCode::INVALID_TOKEN;
+            // }
+            index = numIndex + match.captured().size();
             return KCalcToken::TokenCode::KNUMBER;
         } else {
             return KCalcToken::TokenCode::INVALID_TOKEN;
@@ -63,13 +73,13 @@ KCalcToken::TokenCode KCalcParser::stringToToken(const QString &buffer, int &ind
 
     if (s.startsWith(BINARY_NUMBER_PREFIX_STR)) {
         QRegularExpressionMatch match;
-        int numIndex = buffer.indexOf(QRegularExpression(QLatin1String("0b[0-1]{1,}")), index, &match);
-        if (numIndex == index) {
-            token_KNumber_ = match.captured();
-            if (match.captured().size() > 64) {
-                return KCalcToken::TokenCode::INVALID_TOKEN;
-            }
-            index += match.captured().size();
+        int numIndex = buffer.indexOf(BINARY_NUMBER_REGEX, index + BINARY_NUMBER_PREFIX_STR.length(), &match);
+        if (numIndex == index + BINARY_NUMBER_PREFIX_STR.length()) {
+            token_KNumber_ = BINARY_NUMBER_PREFIX_STR + match.captured();
+            // if (match.captured().size() > 64) {
+            //     return KCalcToken::TokenCode::INVALID_TOKEN;
+            // }
+            index = numIndex + match.captured().size();
             return KCalcToken::TokenCode::KNUMBER;
         } else {
             return KCalcToken::TokenCode::INVALID_TOKEN;
@@ -78,13 +88,13 @@ KCalcToken::TokenCode KCalcParser::stringToToken(const QString &buffer, int &ind
 
     if (s.startsWith(OCTAL_NUMBER_PREFIX_STR)) {
         QRegularExpressionMatch match;
-        int numIndex = buffer.indexOf(QRegularExpression(QLatin1String("0[0-7]{1,}")), index, &match);
-        if (numIndex == index) {
-            token_KNumber_ = match.captured();
-            if (match.captured().size() > 21) {
-                return KCalcToken::TokenCode::INVALID_TOKEN;
-            }
-            index += match.captured().size();
+        int numIndex = buffer.indexOf(OCTAL_NUMBER_REGEX, index + OCTAL_NUMBER_PREFIX_STR.length(), &match);
+        if (numIndex == index + OCTAL_NUMBER_PREFIX_STR.length()) {
+            token_KNumber_ = OCTAL_NUMBER_PREFIX_STR_C_STYLE + match.captured();
+            // if (match.captured().size() > 21) {
+            //     return KCalcToken::TokenCode::INVALID_TOKEN;
+            // }
+            index = numIndex + match.captured().size();
             return KCalcToken::TokenCode::KNUMBER;
         }
         // Code execution continues, since an entry could
@@ -92,31 +102,48 @@ KCalcToken::TokenCode KCalcParser::stringToToken(const QString &buffer, int &ind
         // being a number in base 10 or 16
     }
 
-    if ((A_STR <= s.first(1) && s.first(1) <= F_STR) || (ZERO_STR <= s.first(1) && s.first(1) <= NINE_STR)
-        || (s.first(1) == COMMA_STR || s.first(1) == POINT_STR)) {
+    const auto isValidChar = [](const QChar c) {
+        return ((A_STR <= c && c <= F_STR) || (ZERO_STR <= c && c <= NINE_STR) || c == COMMA_STR || c == POINT_STR);
+    };
+
+    if (isValidChar(s.at(0).toUpper())) {
         int numIndex = -1;
         QRegularExpressionMatch match;
         switch (base) {
         case 2:
-            numIndex = buffer.indexOf(QRegularExpression(QLatin1String("[0-1]{1,}")), index, &match);
+            numIndex = buffer.indexOf(BINARY_NUMBER_REGEX, index, &match);
             token_KNumber_ = BINARY_NUMBER_PREFIX_STR;
+            // if (match.captured().size() > 64) {
+            //     return KCalcToken::TokenCode::INVALID_TOKEN;
+            // }
             break;
         case 8:
-            numIndex = buffer.indexOf(QRegularExpression(QLatin1String("[0-7]{1,21}")), index, &match);
-            token_KNumber_ = OCTAL_NUMBER_PREFIX_STR;
+            numIndex = buffer.indexOf(OCTAL_NUMBER_REGEX, index, &match);
+            token_KNumber_ = OCTAL_NUMBER_PREFIX_STR_C_STYLE;
+            // if (match.captured().size() > 21) {
+            //     return KCalcToken::TokenCode::INVALID_TOKEN;
+            // }
             break;
         case 10:
-            numIndex = buffer.indexOf(QRegularExpression(QLatin1String("(\\d*)[.,]?\\d+(e([+-]?\\d+))?")), index, &match);
+            numIndex = buffer.indexOf(DECIMAL_NUMBER_REGEX, index, &match);
             token_KNumber_.clear();
             break;
         case 16:
-            numIndex = buffer.indexOf(QRegularExpression(QLatin1String("[0-9A-F]{1,16}")), index, &match);
+            numIndex = buffer.indexOf(HEX_NUMBER_REGEX, index, &match);
             token_KNumber_ = HEX_NUMBER_PREFIX_STR;
+            // if (match.captured().size() > 16) {
+            //     return KCalcToken::TokenCode::INVALID_TOKEN;
+            // }
             break;
         default:
             break;
         }
         if (numIndex == index) {
+            // if (base == 10) {
+            //     token_KNumber_ += match.captured(2);
+            // } else {
+            //     token_KNumber_ += match.captured();
+            // }
             token_KNumber_ += match.captured();
             index += match.captured().size();
             return KCalcToken::TokenCode::KNUMBER;
@@ -463,7 +490,6 @@ KCalcParser::ParsingResult KCalcParser::stringToTokenQueue(const QString &buffer
     }
 
     while (buffer_index < buffer_size) {
-        tokenCode = KCalcToken::TokenCode::INVALID_TOKEN;
         KNumber operand;
 
         tokenCode = stringToToken(buffer, buffer_index, base);
@@ -482,7 +508,7 @@ KCalcParser::ParsingResult KCalcParser::stringToTokenQueue(const QString &buffer
             qDebug() << "String KNumber converted: " << token_KNumber_;
             token_KNumber_.replace(COMMA_STR, KNumber::decimalSeparator());
             token_KNumber_.replace(POINT_STR, KNumber::decimalSeparator());
-            operand = KNumber(token_KNumber_);
+            operand = KNumber(token_KNumber_, base);
 
             tokenQueue.enqueue(KCalcToken(operand, buffer_index));
         } else {
diff --git a/kcalc_parser.h b/kcalc_parser.h
index ca1e935e85a7938ce117c9720ba3980091ca19dd..b68285785275ac9259d27865b85a4bed87ef8a6a 100644
--- a/kcalc_parser.h
+++ b/kcalc_parser.h
@@ -49,21 +49,32 @@ private:
     static const inline QString SPACE_STR = QStringLiteral(" ");
     static const inline QString THIN_SPACE_STR = QStringLiteral(" ");
 
-    static const inline QString ZERO_STR = QStringLiteral("0");
-    static const inline QString NINE_STR = QStringLiteral("9");
+    static const inline QChar ZERO_STR = u'0';
+    static const inline QChar NINE_STR = u'9';
     static const inline QString DECIMAL_POINT_STR = QLocale().decimalPoint();
-    static const inline QString COMMA_STR = QLatin1String(",");
-    static const inline QString POINT_STR = QLatin1String(".");
+    static const inline QChar COMMA_STR = u',';
+    static const inline QChar POINT_STR = u'.';
 
-    static const inline QString A_STR = QStringLiteral("A");
-    static const inline QString F_STR = QStringLiteral("F");
-    static const inline QString B_STR = QStringLiteral("b");
-    static const inline QString X_STR = QStringLiteral("x");
+    static const inline QChar A_STR = u'A';
+    static const inline QChar F_STR = u'F';
+    static const inline QChar B_STR = u'b';
+    static const inline QChar X_STR = u'x';
 
     static const inline QString BINARY_NUMBER_PREFIX_STR = QStringLiteral("0b");
-    static const inline QString OCTAL_NUMBER_PREFIX_STR = QStringLiteral("0");
+    static const inline QString OCTAL_NUMBER_PREFIX_STR = QStringLiteral("0o");
+    static const inline QString OCTAL_NUMBER_PREFIX_STR_C_STYLE = QStringLiteral("0");
     static const inline QString HEX_NUMBER_PREFIX_STR = QStringLiteral("0x");
 
+    static const QString HEX_NUMBER_PATTERN;
+    static const QString DECIMAL_NUMBER_PATTERN;
+    static const QString OCTAL_NUMBER_PATTERN;
+    static const QString BINARY_NUMBER_PATTERN;
+
+    static const QRegularExpression HEX_NUMBER_REGEX;
+    static const QRegularExpression DECIMAL_NUMBER_REGEX;
+    static const QRegularExpression OCTAL_NUMBER_REGEX;
+    static const QRegularExpression BINARY_NUMBER_REGEX;
+
     static const inline QString E_STR = QStringLiteral("e");
     static const inline QString PI_STR = QStringLiteral("π");
     static const inline QString PHI_STR = QStringLiteral("ϕ");
diff --git a/knumber/knumber.cpp b/knumber/knumber.cpp
index 075b5146c8cde86b45654d771a4ba753190e0ea6..1a681c1a48e591306c43d1a13f9159308bd18312 100644
--- a/knumber/knumber.cpp
+++ b/knumber/knumber.cpp
@@ -256,55 +256,115 @@ KNumber::KNumber()
 //------------------------------------------------------------------------------
 // Name: KNumber
 //------------------------------------------------------------------------------
-KNumber::KNumber(const QString &s)
+KNumber::KNumber(const QString &s, int base)
     : value_(nullptr)
 {
-    static const QRegularExpression special_regex(QLatin1String("^(inf|-inf|nan)$"));
-    // const QRegularExpression integer_regex(QLatin1String("^[+-]?\\d+$"));
-    static const QRegularExpression integer_regex(QLatin1String("^[+-]?\\[1-9]d+$"));
-    static const QRegularExpression binary_integer_regex(QLatin1String("^0b[0-1]{1,64}$"));
-    static const QRegularExpression octal_integer_regex(QLatin1String("^0[0-7]{1,21}$"));
-    static const QRegularExpression hex_integer_regex(QLatin1String("^0x[0-9A-F]{1,16}$"));
-    static const QRegularExpression fraction_regex(QLatin1String("^[+-]?\\d+/\\d+$"));
-    const QRegularExpression float_regex(QString(QLatin1String(R"(^([+-]?\d*)(%1\d*)?(e([+-]?\d+))?$)")).arg(QRegularExpression::escape(DecimalSeparator)));
-
-    if (special_regex.match(s).hasMatch()) {
+    static const QRegularExpression specialRegex("^([+-]?inf|nan)$"_L1, QRegularExpression::CaseInsensitiveOption);
+    if (specialRegex.match(s).hasMatch()) {
         value_ = new detail::knumber_error(s);
-    } else if (integer_regex.match(s).hasMatch()) {
-        value_ = new detail::knumber_integer(s);
-    } else if (fraction_regex.match(s).hasMatch()) {
-        value_ = new detail::knumber_fraction(s);
-        simplify();
-    } else if (hex_integer_regex.match(s).hasMatch() || octal_integer_regex.match(s).hasMatch() || binary_integer_regex.match(s).hasMatch()) {
-        value_ = new detail::knumber_integer(s.toULongLong(nullptr, 0));
-    } else if (const auto match = float_regex.match(s); match.hasMatch()) {
-        if (detail::knumber_fraction::default_fractional_input) {
-            const QString ipart = match.captured(1);
-            const QString fpart = match.captured(2);
-            const int e_val = match.captured(4).toInt();
+    } else {
+        QString str = s.trimmed().remove(GroupSeparator).replace(DecimalSeparator, "."_L1);
+
+        static const QRegularExpression binPrefRegex("^[+-]?(0x)"_L1);
+        static const QRegularExpression octPrefRegex("^[+-]?(0o)"_L1);
+        static const QRegularExpression hexPrefRegex("^[+-]?(0b)"_L1);
+
+        QRegularExpressionMatch prefMatch;
+        if (base == 2) {
+            prefMatch = binPrefRegex.match(str);
+        } else if (base == 8) {
+            prefMatch = octPrefRegex.match(str);
+        } else if (base == 16) {
+            prefMatch = hexPrefRegex.match(str);
+        }
+        if (prefMatch.hasMatch()) {
+            str.remove(prefMatch.capturedStart(1), prefMatch.capturedLength(1));
+        }
+
+        if (value_ = detail::knumber_integer::fromString(s, base); value_) {
+            return;
+        }
+
+        if (value_ = detail::knumber_fraction::fromString(s, base); value_) {
+            simplify();
+            return;
+        }
 
-            QString num = ipart + fpart.mid(1);
-            QString den = QLatin1String("1") + QString(fpart.size() - 1, QLatin1Char('0'));
+        // std::unique_ptr<detail::knumber_float> num(detail::knumber_float::fromString(str, base));
+        // if (num) {
+        //     if (detail::knumber_fraction::default_fractional_input) {
+        //         value_ = new detail::knumber_fraction(num.get());
+        //     } else {
+        //         value_ = num.release();
+        //     }
+        //     simplify();
+        // } else {
+        //     value_ = new detail::knumber_error(detail::knumber_error::ERROR_UNDEFINED);
+        // }
 
-            if (e_val < 0) {
-                den = den + QString(::abs(e_val), QLatin1Char('0'));
-            } else if (e_val > 0) {
-                num = num + QString(::abs(e_val), QLatin1Char('0'));
+        if (detail::knumber_fraction::default_fractional_input) {
+            static const QRegularExpression binNumRegex(R"(^([+-]?[01]+)(?:\.([01]+))?(?:([pPeE@])([+-]?[0-9]+))?$)"_L1);
+            static const QRegularExpression decNumRegex(R"(^([+-]?[0-9]+)(?:\.([0-9]+))?(?:([eE@])([+-]?[0-9]+))?$)"_L1);
+            static const QRegularExpression hexNumRegex(R"(^([+-]?[0-9A-Fa-f]+)(?:\.([0-9A-Fa-f]+))?(?:([pP@])([+-]?[0-9]+))?$)"_L1);
+            static const QRegularExpression genNumRegex(R"(^([+-]?[0-9A-Za-z]+)(?:\.([0-9A-Za-z]+))?(?:(@)([+-]?[0-9]+))?$)"_L1);
+
+            QRegularExpressionMatch numMatch;
+            if (base == 2) {
+                numMatch = binNumRegex.match(str);
+            } else if (base <= 10) {
+                numMatch = decNumRegex.match(str);
+            } else if (base == 16) {
+                numMatch = hexNumRegex.match(str);
+            } else {
+                numMatch = genNumRegex.match(str);
             }
 
-            value_ = new detail::knumber_fraction(QStringLiteral("%1/%2").arg(num, den));
+            if (numMatch.hasMatch()) {
+                QStringView fracStr = numMatch.capturedView(2);
+                QString numStr = numMatch.captured(1) + fracStr;
+                QString denStr = u'1' + QString(fracStr.length(), u'0');
+
+                int exp = numMatch.captured(4).toInt();
+                if (exp != 0) {
+                    const bool powOfTwoExp = numMatch.capturedView(3).at(0).toLower() == u'p';
+                    if (powOfTwoExp && base != 2) {
+                        if (exp > 0) {
+                            exp = 1 << exp;
+                            int den = 1;
+                            if (!fracStr.isEmpty()) {
+                                den = std::pow(base, fracStr.length());
+                            }
+                            // while (den < exp) {
+                            //     numStr += u"0";
+                            //     den *= base;
+                            // }
+                            const int order = std::ceil(std::log(exp) / std::log(base));
+                            if (order > 0) {
+                                den *= std::pow(base, order);
+                                numStr += QString(order, u'0');
+                            }
+                            denStr = QString::number(den / exp, base);
+                        } else {
+                            denStr.replace(0, 1, QString::number(1 >> exp, base));
+                        }
+                    } else {
+                        (exp > 0 ? numStr : denStr) += QString(std::abs(exp), u'0');
+                    }
+                }
+
+                const QString fracNumStr = "%1/%2"_L1.arg(numStr, denStr);
+                if (value_ = detail::knumber_fraction::fromString(fracNumStr, base); value_) {
+                    simplify();
+                    return;
+                }
+            }
+        }
+
+        if (value_ = detail::knumber_float::fromString(str, base); value_) {
             simplify();
             return;
         }
 
-        // we need to normalize the decimal separator to US style because that's
-        // the only type that the GMP function accept
-        QString new_s = s;
-        new_s.replace(DecimalSeparator, QLatin1String("."));
-
-        value_ = new detail::knumber_float(new_s);
-        simplify();
-    } else {
         value_ = new detail::knumber_error(detail::knumber_error::ERROR_UNDEFINED);
     }
 }
diff --git a/knumber/knumber.h b/knumber/knumber.h
index aacdd4cafb3c81e3d49adb4d87b08ffa3ce0916a..b0006d942d83c9634876ed4e8052f941efb40735 100644
--- a/knumber/knumber.h
+++ b/knumber/knumber.h
@@ -45,7 +45,7 @@ public:
 public:
     // construction/destruction
     KNumber();
-    explicit KNumber(const QString &s);
+    explicit KNumber(const QString &s, int base = 10);
 
     explicit KNumber(qint32 value);
     explicit KNumber(qint64 value);
diff --git a/knumber/knumber_float.cpp b/knumber/knumber_float.cpp
index 83d059a4ab6a7e6899c55aac98cf996554f8f388..de71beaae435761e51ea9395e6ddcbed0a5d392a 100644
--- a/knumber/knumber_float.cpp
+++ b/knumber/knumber_float.cpp
@@ -79,14 +79,6 @@ knumber_base *knumber_float::execute_mpfr_func(mpfr_srcptr op)
     return ensureIsValid(mpfr_);
 }
 
-//------------------------------------------------------------------------------
-// Name:
-//------------------------------------------------------------------------------
-knumber_float::knumber_float(const QString &s)
-{
-    mpfr_set_str(new_mpfr(), s.toLatin1().constData(), 10, rounding_mode);
-}
-
 //------------------------------------------------------------------------------
 // Name:
 //------------------------------------------------------------------------------
@@ -165,6 +157,27 @@ knumber_float::~knumber_float()
     mpfr_clear(mpfr_);
 }
 
+//------------------------------------------------------------------------------
+// Name: knumber_float
+//------------------------------------------------------------------------------
+knumber_float::knumber_float()
+{
+    mpfr_init(mpfr_);
+}
+
+//------------------------------------------------------------------------------
+// Name: fromString
+//------------------------------------------------------------------------------
+knumber_float *knumber_float::fromString(const QString &s, int base)
+{
+    std::unique_ptr<knumber_float> num(new knumber_float);
+    if (mpfr_set_str(num->mpfr_, qPrintable(s), base, rounding_mode) == 0) {
+        return num.release();
+    }
+
+    return nullptr;
+}
+
 //------------------------------------------------------------------------------
 // Name:
 //------------------------------------------------------------------------------
diff --git a/knumber/knumber_float.h b/knumber/knumber_float.h
index 6f4b9ab4c2311df20a781a19f680246886498d01..60865162fdff7640d255ae3210dd31bd725802bb 100644
--- a/knumber/knumber_float.h
+++ b/knumber/knumber_float.h
@@ -25,7 +25,6 @@ private:
     static const mpfr_prec_t precision;
 
 public:
-    explicit knumber_float(const QString &s);
     explicit knumber_float(double value);
 #ifdef HAVE_LONG_DOUBLE
     explicit knumber_float(long double value);
@@ -34,6 +33,12 @@ public:
     explicit knumber_float(mpfr_t mpfr);
     ~knumber_float() override;
 
+private:
+    knumber_float();
+
+public:
+    static knumber_float* fromString(const QString &s, int base);
+
 private:
     // conversion constructors
     explicit knumber_float(const knumber_integer *value);
diff --git a/knumber/knumber_fraction.cpp b/knumber/knumber_fraction.cpp
index eab6d98a6d10b8c6ec092648a156c7a414b8d545..7fcf1c3ebf57ab2f79524eccba23f6c89480574c 100644
--- a/knumber/knumber_fraction.cpp
+++ b/knumber/knumber_fraction.cpp
@@ -41,16 +41,6 @@ void knumber_fraction::set_split_off_integer_for_fraction_output(bool value)
     split_off_integer_for_fraction_output = value;
 }
 
-//------------------------------------------------------------------------------
-// Name:
-//------------------------------------------------------------------------------
-knumber_fraction::knumber_fraction(const QString &s)
-{
-    mpq_init(mpq_);
-    mpq_set_str(mpq_, s.toLatin1().constData(), 10);
-    mpq_canonicalize(mpq_);
-}
-
 //------------------------------------------------------------------------------
 // Name:
 //------------------------------------------------------------------------------
@@ -90,23 +80,22 @@ knumber_fraction::knumber_fraction(const knumber_fraction *value)
 }
 
 //------------------------------------------------------------------------------
-// Name:
+// Name: knumber_fraction
 //------------------------------------------------------------------------------
-knumber_fraction::knumber_fraction(const knumber_integer *value)
+knumber_fraction::knumber_fraction(const knumber_float *value)
 {
     mpq_init(mpq_);
-    mpq_set_z(mpq_, value->mpz_);
+    mpfr_get_q(mpq_, value->mpfr_);
 }
 
-#if 0
 //------------------------------------------------------------------------------
 // Name:
 //------------------------------------------------------------------------------
-knumber_fraction::knumber_fraction(const knumber_float *value) {
-	mpq_init(mpq_);
-	mpq_set_f(mpq_, value->mpf_);
+knumber_fraction::knumber_fraction(const knumber_integer *value)
+{
+    mpq_init(mpq_);
+    mpq_set_z(mpq_, value->mpz_);
 }
-#endif
 
 //------------------------------------------------------------------------------
 // Name:
@@ -124,6 +113,29 @@ knumber_fraction::~knumber_fraction()
     mpq_clear(mpq_);
 }
 
+//------------------------------------------------------------------------------
+// Name: knumber_fraction
+//------------------------------------------------------------------------------
+knumber_fraction::knumber_fraction()
+{
+    mpq_init(mpq_);
+}
+
+//------------------------------------------------------------------------------
+// Name: fromString
+//------------------------------------------------------------------------------
+knumber_fraction *knumber_fraction::fromString(const QString &s, int base)
+{
+    std::unique_ptr<knumber_fraction> num(new knumber_fraction);
+    if (mpq_set_str(num->mpq_, qPrintable(s), base) == 0) {
+        mpq_canonicalize(num->mpq_);
+
+        return num.release();
+    }
+
+    return nullptr;
+}
+
 //------------------------------------------------------------------------------
 // Name:
 //------------------------------------------------------------------------------
@@ -789,7 +801,7 @@ QString knumber_fraction::toStringInBase(int base, int precision) const
     if (knumber_fraction::default_fractional_output) {
         knumber_integer floor(this);
         if (split_off_integer_for_fraction_output && !floor.is_zero()) {
-            knumber_integer numerator(0), denominator(0);
+            knumber_integer numerator, denominator;
             mpq_get_num(numerator.mpz_, mpq_);
             mpq_get_den(denominator.mpz_, mpq_);
 
diff --git a/knumber/knumber_fraction.h b/knumber/knumber_fraction.h
index 2061655c9d54ab7b954cc72297cf7d49c0f31bf8..443e3ddbb12f60f5c8607dae22177a152e446550 100644
--- a/knumber/knumber_fraction.h
+++ b/knumber/knumber_fraction.h
@@ -30,12 +30,17 @@ public:
     static void set_split_off_integer_for_fraction_output(bool value);
 
 public:
-    explicit knumber_fraction(const QString &s);
     knumber_fraction(qint64 num, quint64 den);
     knumber_fraction(quint64 num, quint64 den);
     explicit knumber_fraction(mpq_t mpq);
     ~knumber_fraction() override;
 
+private:
+    knumber_fraction();
+
+public:
+    static knumber_fraction* fromString(const QString &s, int base);
+
 public:
     knumber_base *clone() override;
 
@@ -110,11 +115,7 @@ private:
     // conversion constructors
     explicit knumber_fraction(const knumber_integer *value);
     explicit knumber_fraction(const knumber_fraction *value);
-#if 0
-	// TODO: this is omitted because there is no good way to
-	// implement it
-	knumber_fraction(const knumber_float *value);
-#endif
+    explicit knumber_fraction(const knumber_float *value);
     explicit knumber_fraction(const knumber_error *value);
 
 private:
diff --git a/knumber/knumber_integer.cpp b/knumber/knumber_integer.cpp
index 14114c8bc5b4ab809985f10bf11c2e6ad6bfb653..dd435bf2613cabc9a7e653f42ff4641090c7fa45 100644
--- a/knumber/knumber_integer.cpp
+++ b/knumber/knumber_integer.cpp
@@ -13,15 +13,6 @@
 
 namespace detail
 {
-//------------------------------------------------------------------------------
-// Name: knumber_integer
-//------------------------------------------------------------------------------
-knumber_integer::knumber_integer(const QString &s)
-{
-    mpz_init(mpz_);
-    mpz_set_str(mpz_, s.toLatin1().constData(), 10);
-}
-
 //------------------------------------------------------------------------------
 // Name: knumber_integer
 //------------------------------------------------------------------------------
@@ -129,6 +120,27 @@ knumber_integer::~knumber_integer()
     mpz_clear(mpz_);
 }
 
+//------------------------------------------------------------------------------
+// Name: knumber_integer
+//------------------------------------------------------------------------------
+knumber_integer::knumber_integer()
+{
+    mpz_init(mpz_);
+}
+
+//------------------------------------------------------------------------------
+// Name: fromString
+//------------------------------------------------------------------------------
+knumber_integer *knumber_integer::fromString(const QString &s, int base)
+{
+    std::unique_ptr<knumber_integer> num(new knumber_integer);
+    if (mpz_set_str(num->mpz_, qPrintable(s), base) == 0) {
+        return num.release();
+    }
+
+    return nullptr;
+}
+
 //------------------------------------------------------------------------------
 // Name: add
 //------------------------------------------------------------------------------
diff --git a/knumber/knumber_integer.h b/knumber/knumber_integer.h
index 1fbdf798323b3b0bcb5b8c3bb5ac3fad84c76584..cc0a070bc88f0ca15c051e9c7ac1d6ac5dc08133 100644
--- a/knumber/knumber_integer.h
+++ b/knumber/knumber_integer.h
@@ -20,7 +20,6 @@ class knumber_integer : public knumber_base
     friend class knumber_float;
 
 public:
-    explicit knumber_integer(const QString &s);
     explicit knumber_integer(qint32 value);
     explicit knumber_integer(qint64 value);
     explicit knumber_integer(quint32 value);
@@ -28,6 +27,12 @@ public:
     explicit knumber_integer(mpz_t mpz);
     ~knumber_integer() override;
 
+private:
+    knumber_integer();
+
+public:
+    static knumber_integer* fromString(const QString &s, int base);
+
 public:
     knumber_base *clone() override;

Places

File 2004-temp.patch of Package kcalc (Revision a5b2511d8f5bdfd7ba9d17623260bd74)

Places