File indexing completed on 2024-04-28 16:21:39

 /* This file is part of the KDE project
    Copyright 2007 Stefan Nikolaus <stefan.nikolaus@kdemail.net>
    Copyright 2004 Tomas Mecir <mecirt@gmail.com>
    Copyright 1998,1999 Torben Weis <weis@kde.org>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 // Local
 #include "ValueParser.h"
 
 #include "CalculationSettings.h"
 #include "Localization.h"
 #include "Style.h"
 #include "Value.h"
 
 using namespace Calligra::Sheets;
 
 ValueParser::ValueParser(const CalculationSettings* settings)
         : m_settings(settings)
 {
 }
 
 const CalculationSettings* ValueParser::settings() const
 {
     return m_settings;
 }
 
 Value ValueParser::parse(const QString& str) const
 {
     Value val;
 
     // If the text is empty, we don't have a value
     // If the user stated explicitly that they wanted text
     // (using the format or using a quote),
     // then we don't parse as a value, but as string.
     if (str.isEmpty() || str.at(0) == '\'') {
         val = Value(str);
         return val;
     }
 
     bool ok;
 
     QString strStripped = str.trimmed();
     // Try parsing as various datatypes, to find the type of the string
 
     // First as number
     val = tryParseNumber(strStripped, &ok);
 
     if (ok)
         return val;
 
 // Then as bool
 // Note - I swapped the order of these two to try parsing as a number
 // first because that will probably be the most common case
     val = tryParseBool(strStripped, &ok);
     if (ok)
         return val;
 
     // Test for money number
     Number money = m_settings->locale()->readMoney(strStripped, &ok);
     if (ok) {
         val = Value(money);
         val.setFormat(Value::fmt_Money);
         return val;
     }
 
     val = tryParseDate(strStripped, &ok);
     if (ok)
         return val;
 
     val = tryParseTime(strStripped, &ok);
     if (ok)
         return val;
 
     // Nothing particular found, then this is simply a string
     val = Value(str);
     return val;
 }
 
 Value ValueParser::tryParseBool(const QString& str, bool *ok) const
 {
     Value val;
     if (ok) *ok = false;
 
     const QString& lowerStr = str.toLower();
     const QStringList localeCodes(m_settings->locale()->country());
 
     if ((lowerStr == "true") ||
             (lowerStr == ki18n("true").toString(localeCodes).toLower())) {
         val = Value(true);
         if (ok) *ok = true;
     } else if ((lowerStr == "false") ||
                (lowerStr == ki18n("false").toString(localeCodes).toLower())) {
         val = Value(false);
         if (ok) *ok = true;
     }
     return val;
 }
 
 Value ValueParser::readNumber(const QString& _str, bool *ok) const
 {
     bool isInt = false;
     QString str = _str.trimmed();
     bool neg = str.indexOf(m_settings->locale()->negativeSign()) == 0;
     if (neg)
         str.remove(0, m_settings->locale()->negativeSign().length());
 
     /* will hold the scientific notation portion of the number.
     Example, with 2.34E+23, exponentialPart == "E+23"
     */
     QString exponentialPart;
     int EPos  = str.indexOf('E', 0, Qt::CaseInsensitive);
 
     if (EPos != -1) {
         exponentialPart = str.mid(EPos);
         str = str.left(EPos);
     }
 
     int pos;
     int fracPos;
     QString major;
     QString minor;
     if ((pos = str.indexOf(m_settings->locale()->decimalSymbol())) != -1) {
         major = str.left(pos);
         minor = str.mid(pos + m_settings->locale()->decimalSymbol().length());
         isInt = false;
     } else if (((pos = str.indexOf(' ')) != -1) &&
                ((fracPos = str.indexOf('/')) != -1)) {
         // try to parse fractions of this form:
         // [0-9]+ [0-9]+/[1-9][0-9]?
         major = str.left(pos);
         QString numerator = str.mid(pos + 1, (fracPos - pos - 1));
         QString denominator = str.mid(fracPos + 1);
         double minorVal = numerator.toDouble() / denominator.toDouble();
         if (minorVal > 1) {
             // assume major is just a plain number
             double wholePart = floor(minorVal);
             minorVal -= wholePart;
             major = QString("%1").arg(major.toInt() + (int)wholePart);
         }
         minor = QString::number(minorVal, 'f').remove(0, 2);     // chop off the "0." part
         // debugSheets <<"fraction:" << major <<"." << minor;
     } else {
         major = str;
         isInt = (EPos == -1); // only, if no exponential part was found
     }
 
     // Remove thousand separators
     int thlen = m_settings->locale()->thousandsSeparator().length();
     int lastpos = 0;
     while ((pos = major.indexOf(m_settings->locale()->thousandsSeparator())) > 0) {
         // e.g. 12,,345,,678,,922 Acceptable positions (from the end) are 5, 10, 15... i.e. (3+thlen)*N
         int fromEnd = major.length() - pos;
         if (fromEnd % (3 + thlen) != 0 // Needs to be a multiple, otherwise it's an error
                 || pos - lastpos > 3 // More than 3 digits between two separators -> error
                 || pos == 0          // Can't start with a separator
                 || (lastpos > 0 && pos - lastpos != 3)) { // Must have exactly 3 digits between two separators
             if (ok) *ok = false;
             return Value();
         }
 
         lastpos = pos;
         major.remove(pos, thlen);
     }
     if (lastpos > 0 && major.length() - lastpos != 3) { // Must have exactly 3 digits after the last separator
         if (ok) *ok = false;
         return Value();
     }
 
     // log10(2^63) ~= 18
     if (isInt && major.length() > 19) isInt = false;
 
     QString tot;
     if (neg) tot = '-';
     tot += major;
     if (!isInt) tot += '.' + minor + exponentialPart;
 
     return isInt ? Value(tot.toLongLong(ok)) : Value(tot.toDouble(ok));
 }
 
 Number ValueParser::readImaginary(const QString& str, bool* ok) const
 {
     if (str.isEmpty()) {
         if (ok) *ok = false;
         return 0.0;
     }
 
     Number imag = 0.0;
     if (str[0] == 'i' || str[0] == 'j') {
         if (str.length() == 1) {
             if (ok) *ok = true;
             imag = 1.0;
         } else
             imag = readNumber(str.mid(1), ok).asFloat();
     } else if (str[str.length()-1] == 'i' || str[str.length()-1] == 'j') {
         const QString minus(m_settings->locale()->negativeSign());
         if (str.length() == 2 && str[0] == '+') {
             if (ok) *ok = true;
             imag = 1.0;
         } else if (str.length() == minus.length() + 1 && str.left(minus.length()) == minus) {
             if (ok) *ok = true;
             imag = -1.0;
         } else
             imag = readNumber(str.left(str.length() - 1), ok).asFloat();
     } else
         *ok = false;
     return imag;
 }
 
 Value ValueParser::tryParseNumber(const QString& str, bool *ok) const
 {
     Value value;
     if (str.endsWith('%')) {   // percentage
         const Number val = readNumber(str.left(str.length() - 1).trimmed(), ok).asFloat();
         if (*ok) {
             //debugSheets <<"ValueParser::tryParseNumber '" << str <<
             //    "' successfully parsed as percentage: " << val << '%' << endl;
             value = Value(val / 100.0);
             value.setFormat(Value::fmt_Percent);
         }
     } else if (str.count('i') == 1 || str.count('j') == 1) {    // complex number
         Number real = 0.0;
         Number imag = 0.0;
         const QString minus(m_settings->locale()->negativeSign());
         // both parts, real and imaginary, present?
         int sepPos;
         if ((sepPos = str.indexOf('+', 1)) != -1) {
             // imaginary part
             imag = readImaginary(str.mid(sepPos + 1).trimmed(), ok);
             // real part
             if (*ok)
                 real = readNumber(str.left(sepPos).trimmed(), ok).asFloat();
         } else if ((sepPos = str.indexOf(minus, minus.length())) != -1) {
             // imaginary part
             imag = -readImaginary(str.mid(sepPos + 1).trimmed(), ok);
             // real part
             if (*ok)
                 real = readNumber(str.left(sepPos).trimmed(), ok).asFloat();
         } else {
             // imaginary part
             if (str.trimmed().length() > 1)   // but don't parse a stand-alone 'i'
               imag = readImaginary(str.trimmed(), ok);
             // real part
             if (*ok)
                 real = 0.0;
         }
         if (*ok)
             value = Value(complex<Number>(real, imag));
     } else // real number
         value = readNumber(str, ok);
     return value;
 }
 
 Value ValueParser::tryParseDate(const QString& str, bool *ok) const
 {
     bool valid = false;
     QDate tmpDate = m_settings->locale()->readDate(str, &valid);
     if (!valid) {
         // Try without the year
         // The tricky part is that we need to remove any separator around the year
         // For instance %Y-%m-%d becomes %m-%d and %d/%m/%Y becomes %d/%m
         // If the year is in the middle, say %m-%Y/%d, we'll remove the sep.
         // before it (%m/%d).
         QString fmt = m_settings->locale()->dateFormatShort();
         int yearPos = fmt.indexOf("%Y", 0, Qt::CaseInsensitive);
         if (yearPos > -1) {
             if (yearPos == 0) {
                 fmt.remove(0, 2);
                 while (fmt[0] != '%')
                     fmt.remove(0, 1);
             } else {
                 fmt.remove(yearPos, 2);
                 for (; yearPos > 0 && fmt[yearPos-1] != '%'; --yearPos)
                     fmt.remove(yearPos, 1);
             }
             //debugSheets <<"Cell::tryParseDate short format w/o date:" << fmt;
             tmpDate = m_settings->locale()->readDate(str, fmt, &valid);
         }
     }
     if (valid) {
         // Note: if shortdate format only specifies 2 digits year, then 3/4/1955
         // will be treated as in year 3055, while 3/4/55 as year 2055
         // (because 55 < 69, see KLocale) and thus there's no way to enter for
         // year 1995
 
         // The following fixes the problem, 3/4/1955 will always be 1955
 
         QString fmt = m_settings->locale()->dateFormatShort();
         if ((fmt.contains("%y") == 1) && (tmpDate.year() > 2999))
             tmpDate = tmpDate.addYears(-1900);
 
         // this is another HACK !
         // with two digit years, 0-69 is treated as year 2000-2069 (see KLocale)
         // however, in Excel only 0-29 is year 2000-2029, 30 or later is 1930
         // onwards
 
         // the following provides workaround for KLocale so we're compatible
         // with Excel
         // (e.g 3/4/45 is Mar 4, 1945 not Mar 4, 2045)
         if ((tmpDate.year() >= 2030) && (tmpDate.year() <= 2069)) {
             QString yearFourDigits = QString::number(tmpDate.year());
             QString yearTwoDigits = QString::number(tmpDate.year() % 100);
 
             // if year is 2045, check to see if "2045" isn't there --> actual
             // input is "45"
             if ((str.count(yearTwoDigits) >= 1) &&
                     (str.count(yearFourDigits) == 0))
                 tmpDate = tmpDate.addYears(-100);
         }
     }
     if (!valid) {
         //try to use the standard Qt date parsing, using ISO 8601 format
         tmpDate = QDate::fromString(str, Qt::ISODate);
         if (tmpDate.isValid()) {
             valid = true;
         }
     }
 
     if (ok)
         *ok = valid;
 
     return Value(tmpDate, m_settings);
 }
 
 Value ValueParser::tryParseTime(const QString& str, bool *ok) const
 {
     bool valid = false;
     QDateTime tmpTime = readTime(str, true, &valid);
     if (!valid)
         tmpTime = readTime(str, false, &valid);
 
     if (!valid) {
         const QStringList localeCodes(m_settings->locale()->country());
         const QString stringPm = ki18n("pm").toString(localeCodes);
         const QString stringAm = ki18n("am").toString(localeCodes);
         int pos = 0;
         if ((pos = str.indexOf(stringPm, 0, Qt::CaseInsensitive)) != -1) {
             // cut off 'PM'
             QString tmp = str.mid(0, str.length() - stringPm.length());
             tmp = tmp.simplified();
             // try again
             tmpTime = readTime(tmp, true, &valid);
             if (!valid)
                 tmpTime = readTime(tmp, false, &valid);
             if (valid && tmpTime.time().hour() > 11)
                 valid = false;
             else if (valid)
                 tmpTime = tmpTime.addSecs(43200); // add 12 hours
         } else if ((pos = str.indexOf(stringAm, 0, Qt::CaseInsensitive)) != -1) {
             // cut off 'AM'
             QString tmp = str.mid(0, str.length() - stringAm.length());
             tmp = tmp.simplified();
             // try again
             tmpTime = readTime(tmp, true, &valid);
             if (!valid)
                 tmpTime = readTime(tmp, false, &valid);
             if (valid && tmpTime.time().hour() > 11)
                 valid = false;
         }
     }
 
     if (ok)
         *ok = valid;
     Value value;
     if (valid) {
         value = Value(tmpTime, m_settings);
         value.setFormat(Value::fmt_Time);
     }
     return value;
 }
 
 QDateTime ValueParser::readTime(const QString& intstr, bool withSeconds, bool* ok) const
 {
     QString str = intstr.simplified().toLower();
     QString format = m_settings->locale()->timeFormat().simplified();
     if (!withSeconds) {
         int n = format.indexOf("%S");
         format = format.left(n - 1);
     }
 
     QDateTime result;
     int hour = 0;
     int minute = 0;
     int second = 0;
     int msecs = 0;
     bool g_12h = false;
     bool pm = false;
     bool negative = false;
     uint strpos = 0;
     uint formatpos = 0;
 
     const uint l  = format.length();
     const uint sl = str.length();
 
     while (l > formatpos || sl > strpos) {
         if (!(l > formatpos && sl > strpos))
             goto error;
 
         QChar c(format.at(formatpos++));
 
         if (c != '%') {
             if (c.isSpace())
                 ++strpos;
             else if (c != str.at(strpos++))
                 goto error;
             continue;
         }
 
         // remove space at the beginning
         if (sl > strpos && str.at(strpos).isSpace())
             ++strpos;
 
         c = format.at(formatpos++);
         switch (c.toLatin1()) {
         case 'p': {
             const QStringList localeCodes(m_settings->locale()->country());
             QString s(ki18n("pm").toString(localeCodes).toLower());
             int len = s.length();
             if (str.mid(strpos, len) == s) {
                 pm = true;
                 strpos += len;
             } else {
                 s = ki18n("am").toString(localeCodes).toLower();
                 len = s.length();
                 if (str.mid(strpos, len) == s) {
                     pm = false;
                     strpos += len;
                 } else
                     goto error;
             }
         }
         break;
 
         case 'k':
         case 'H':
             g_12h = false;
             if (str.at(strpos) == '-') {
                 negative = true;
                 if (sl <= ++strpos)
                     goto error;
             }
             hour = readInt(str, strpos);
             if (hour < 0)
                 goto error;
 
             break;
 
         case 'l':
         case 'I':
             g_12h = true;
             if (str.at(strpos) == '-') {
                 negative = true;
                 if (sl <= ++strpos)
                     goto error;
             }
             hour = readInt(str, strpos);
             if (hour < 1 || hour > 12)
                 goto error;
 
             break;
 
         case 'M':
             minute = readInt(str, strpos);
             if (minute < 0 || minute > 59)
                 goto error;
 
             break;
 
         case 'S':
             if (!withSeconds)
                 break;
             second = readInt(str, strpos);
             if (second < 0 || second > 59)
                 goto error;
             if (strpos < sl && str.indexOf(m_settings->locale()->decimalSymbol()) == (int)strpos) {
                 strpos += m_settings->locale()->decimalSymbol().length();
                 msecs = readInt(str, strpos);
                 if (msecs < 0 || msecs > 999)
                     goto error;
             }
 
             break;
         }
     }
 
     if (g_12h) {
         hour %= 12;
         if (pm) hour += 12;
     }
 
     if (ok)
         *ok = true;
     result = QDateTime(m_settings->referenceDate(), QTime(0, 0), Qt::UTC);
     msecs += (((hour * 60 + minute) * 60 + second) * 1000);
     result = result.addMSecs(negative ? -msecs : msecs);
     return result;
 
 error:
     if (ok)
         *ok = false;
     // return invalid date if it didn't work
     return QDateTime(m_settings->referenceDate(), QTime(-1, -1, -1), Qt::UTC);
 }
 
 /**
  * helper function to read integers, used in readTime
  * @param str
  * @param pos the position to start at. It will be updated when we parse it.
  * @return the integer read in the string, or -1 if no string
  */
 int ValueParser::readInt(const QString& str, uint& pos) const
 {
     if (!str.at(pos).isDigit())
         return -1;
     int result = 0;
     for (; (uint) str.length() > pos && str.at(pos).isDigit(); pos++) {
         result *= 10;
         result += str.at(pos).digitValue();
     }
 
     return result;
 }