summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--BUILD.gn3
-rw-r--r--xfa/fgas/localization/cfx_decimal.cpp471
-rw-r--r--xfa/fgas/localization/cfx_formatstring.h (renamed from xfa/fgas/localization/fgas_localeimp.h)34
-rw-r--r--xfa/fgas/localization/fgas_locale.cpp4050
-rw-r--r--xfa/fgas/localization/fgas_locale.h47
-rw-r--r--xfa/fxfa/parser/xfa_localemgr.h15
-rw-r--r--xfa/fxfa/parser/xfa_localevalue.cpp10
7 files changed, 1539 insertions, 3091 deletions
diff --git a/BUILD.gn b/BUILD.gn
index 6223548772..70cb5baecb 100644
--- a/BUILD.gn
+++ b/BUILD.gn
@@ -1248,11 +1248,12 @@ if (pdf_enable_xfa) {
"xfa/fgas/layout/fgas_rtfbreak.h",
"xfa/fgas/layout/fgas_textbreak.cpp",
"xfa/fgas/layout/fgas_textbreak.h",
+ "xfa/fgas/localization/cfx_decimal.cpp",
+ "xfa/fgas/localization/cfx_formatstring.h",
"xfa/fgas/localization/fgas_datetime.cpp",
"xfa/fgas/localization/fgas_datetime.h",
"xfa/fgas/localization/fgas_locale.cpp",
"xfa/fgas/localization/fgas_locale.h",
- "xfa/fgas/localization/fgas_localeimp.h",
"xfa/fwl/cfwl_app.cpp",
"xfa/fwl/cfwl_app.h",
"xfa/fwl/cfwl_barcode.cpp",
diff --git a/xfa/fgas/localization/cfx_decimal.cpp b/xfa/fgas/localization/cfx_decimal.cpp
new file mode 100644
index 0000000000..ba70be8230
--- /dev/null
+++ b/xfa/fgas/localization/cfx_decimal.cpp
@@ -0,0 +1,471 @@
+// Copyright 2017 PDFium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
+
+#include <algorithm>
+#include <utility>
+
+#include "xfa/fgas/localization/fgas_locale.h"
+
+#define FXMATH_DECIMAL_SCALELIMIT 0x1c
+#define FXMATH_DECIMAL_NEGMASK (0x80000000L)
+#define FXMATH_DECIMAL_FORCEBOOL(x) (!!(x))
+#define FXMATH_DECIMAL_MAKEFLAGS(NEG, SCALE) \
+ (((SCALE) << 0x10) | ((NEG) ? FXMATH_DECIMAL_NEGMASK : 0))
+#define FXMATH_DECIMAL_FLAGS2NEG(FLAGS) \
+ FXMATH_DECIMAL_FORCEBOOL((FLAGS)&FXMATH_DECIMAL_NEGMASK)
+#define FXMATH_DECIMAL_FLAGS2SCALE(FLAGS) \
+ ((uint8_t)(((FLAGS) & ~FXMATH_DECIMAL_NEGMASK) >> 0x10))
+#define FXMATH_DECIMAL_RSHIFT32BIT(x) ((x) >> 0x10 >> 0x10)
+#define FXMATH_DECIMAL_LSHIFT32BIT(x) ((x) << 0x10 << 0x10)
+
+namespace {
+
+inline uint8_t decimal_helper_div10(uint64_t& phi,
+ uint64_t& pmid,
+ uint64_t& plo) {
+ uint8_t retVal;
+ pmid += FXMATH_DECIMAL_LSHIFT32BIT(phi % 0xA);
+ phi /= 0xA;
+ plo += FXMATH_DECIMAL_LSHIFT32BIT(pmid % 0xA);
+ pmid /= 0xA;
+ retVal = plo % 0xA;
+ plo /= 0xA;
+ return retVal;
+}
+
+inline uint8_t decimal_helper_div10_any(uint64_t nums[], uint8_t numcount) {
+ uint8_t retVal = 0;
+ for (int i = numcount - 1; i > 0; i--) {
+ nums[i - 1] += FXMATH_DECIMAL_LSHIFT32BIT(nums[i] % 0xA);
+ nums[i] /= 0xA;
+ }
+ if (numcount) {
+ retVal = nums[0] % 0xA;
+ nums[0] /= 0xA;
+ }
+ return retVal;
+}
+
+inline void decimal_helper_mul10(uint64_t& phi, uint64_t& pmid, uint64_t& plo) {
+ plo *= 0xA;
+ pmid = pmid * 0xA + FXMATH_DECIMAL_RSHIFT32BIT(plo);
+ plo = (uint32_t)plo;
+ phi = phi * 0xA + FXMATH_DECIMAL_RSHIFT32BIT(pmid);
+ pmid = (uint32_t)pmid;
+}
+
+inline void decimal_helper_mul10_any(uint64_t nums[], uint8_t numcount) {
+ nums[0] *= 0xA;
+ for (int i = 1; i < numcount; i++) {
+ nums[i] = nums[i] * 0xA + FXMATH_DECIMAL_RSHIFT32BIT(nums[i - 1]);
+ nums[i - 1] = (uint32_t)nums[i - 1];
+ }
+}
+
+inline void decimal_helper_normalize(uint64_t& phi,
+ uint64_t& pmid,
+ uint64_t& plo) {
+ phi += FXMATH_DECIMAL_RSHIFT32BIT(pmid);
+ pmid = (uint32_t)pmid;
+ pmid += FXMATH_DECIMAL_RSHIFT32BIT(plo);
+ plo = (uint32_t)plo;
+ phi += FXMATH_DECIMAL_RSHIFT32BIT(pmid);
+ pmid = (uint32_t)pmid;
+}
+
+inline void decimal_helper_normalize_any(uint64_t nums[], uint8_t len) {
+ for (int i = len - 2; i > 0; i--) {
+ nums[i + 1] += FXMATH_DECIMAL_RSHIFT32BIT(nums[i]);
+ nums[i] = (uint32_t)nums[i];
+ }
+ for (int i = 0; i < len - 1; i++) {
+ nums[i + 1] += FXMATH_DECIMAL_RSHIFT32BIT(nums[i]);
+ nums[i] = (uint32_t)nums[i];
+ }
+}
+
+inline int8_t decimal_helper_raw_compare_any(uint64_t a[],
+ uint8_t al,
+ uint64_t b[],
+ uint8_t bl) {
+ int8_t retVal = 0;
+ for (int i = std::max(al - 1, bl - 1); i >= 0; i--) {
+ uint64_t l = (i >= al ? 0 : a[i]), r = (i >= bl ? 0 : b[i]);
+ retVal += (l > r ? 1 : (l < r ? -1 : 0));
+ if (retVal)
+ return retVal;
+ }
+ return retVal;
+}
+
+inline void decimal_helper_dec_any(uint64_t a[], uint8_t al) {
+ for (int i = 0; i < al; i++) {
+ if (a[i]--)
+ return;
+ }
+}
+
+inline void decimal_helper_inc_any(uint64_t a[], uint8_t al) {
+ for (int i = 0; i < al; i++) {
+ a[i]++;
+ if ((uint32_t)a[i] == a[i])
+ return;
+ a[i] = 0;
+ }
+}
+
+inline void decimal_helper_raw_mul(uint64_t a[],
+ uint8_t al,
+ uint64_t b[],
+ uint8_t bl,
+ uint64_t c[],
+ uint8_t cl) {
+ ASSERT(al + bl <= cl);
+ for (int i = 0; i < cl; i++)
+ c[i] = 0;
+
+ for (int i = 0; i < al; i++) {
+ for (int j = 0; j < bl; j++) {
+ uint64_t m = (uint64_t)a[i] * b[j];
+ c[i + j] += (uint32_t)m;
+ c[i + j + 1] += FXMATH_DECIMAL_RSHIFT32BIT(m);
+ }
+ }
+ for (int i = 0; i < cl - 1; i++) {
+ c[i + 1] += FXMATH_DECIMAL_RSHIFT32BIT(c[i]);
+ c[i] = (uint32_t)c[i];
+ }
+ for (int i = 0; i < cl; i++)
+ c[i] = (uint32_t)c[i];
+}
+
+inline void decimal_helper_raw_div(uint64_t a[],
+ uint8_t al,
+ uint64_t b[],
+ uint8_t bl,
+ uint64_t c[],
+ uint8_t cl) {
+ for (int i = 0; i < cl; i++)
+ c[i] = 0;
+
+ uint64_t left[16] = {0};
+ uint64_t right[16] = {0};
+ left[0] = 0;
+ for (int i = 0; i < al; i++)
+ right[i] = a[i];
+
+ uint64_t tmp[16];
+ while (decimal_helper_raw_compare_any(left, al, right, al) <= 0) {
+ uint64_t cur[16];
+ for (int i = 0; i < al; i++)
+ cur[i] = left[i] + right[i];
+
+ for (int i = al - 1; i >= 0; i--) {
+ if (i)
+ cur[i - 1] += FXMATH_DECIMAL_LSHIFT32BIT(cur[i] % 2);
+ cur[i] /= 2;
+ }
+
+ decimal_helper_raw_mul(cur, al, b, bl, tmp, 16);
+ switch (decimal_helper_raw_compare_any(tmp, 16, a, al)) {
+ case -1:
+ for (int i = 0; i < 16; i++)
+ left[i] = cur[i];
+
+ left[0]++;
+ decimal_helper_normalize_any(left, al);
+ break;
+ case 1:
+ for (int i = 0; i < 16; i++)
+ right[i] = cur[i];
+ decimal_helper_dec_any(right, al);
+ break;
+ case 0:
+ for (int i = 0; i < std::min(al, cl); i++)
+ c[i] = cur[i];
+ return;
+ }
+ }
+ for (int i = 0; i < std::min(al, cl); i++)
+ c[i] = left[i];
+}
+
+inline bool decimal_helper_outofrange(uint64_t a[], uint8_t al, uint8_t goal) {
+ for (int i = goal; i < al; i++) {
+ if (a[i])
+ return true;
+ }
+ return false;
+}
+
+inline void decimal_helper_shrinkintorange(uint64_t a[],
+ uint8_t al,
+ uint8_t goal,
+ uint8_t& scale) {
+ bool bRoundUp = false;
+ while (scale != 0 && (scale > FXMATH_DECIMAL_SCALELIMIT ||
+ decimal_helper_outofrange(a, al, goal))) {
+ bRoundUp = decimal_helper_div10_any(a, al) >= 5;
+ scale--;
+ }
+ if (bRoundUp) {
+ decimal_helper_normalize_any(a, goal);
+ decimal_helper_inc_any(a, goal);
+ }
+}
+
+inline void decimal_helper_truncate(uint64_t& phi,
+ uint64_t& pmid,
+ uint64_t& plo,
+ uint8_t& scale,
+ uint8_t minscale = 0) {
+ while (scale > minscale) {
+ uint64_t thi = phi, tmid = pmid, tlo = plo;
+ if (decimal_helper_div10(thi, tmid, tlo) != 0)
+ break;
+
+ phi = thi;
+ pmid = tmid;
+ plo = tlo;
+ scale--;
+ }
+}
+
+} // namespace
+
+CFX_Decimal::CFX_Decimal() : m_uHi(0), m_uLo(0), m_uMid(0), m_uFlags(0) {}
+
+CFX_Decimal::CFX_Decimal(uint64_t val)
+ : m_uHi(0),
+ m_uLo(static_cast<uint32_t>(val)),
+ m_uMid(static_cast<uint32_t>(FXMATH_DECIMAL_RSHIFT32BIT(val))),
+ m_uFlags(0) {}
+
+CFX_Decimal::CFX_Decimal(uint32_t val)
+ : m_uHi(0), m_uLo(static_cast<uint32_t>(val)), m_uMid(0), m_uFlags(0) {}
+
+CFX_Decimal::CFX_Decimal(uint32_t lo,
+ uint32_t mid,
+ uint32_t hi,
+ bool neg,
+ uint8_t scale)
+ : m_uHi(hi),
+ m_uLo(lo),
+ m_uMid(mid),
+ m_uFlags(FXMATH_DECIMAL_MAKEFLAGS(
+ neg && IsNotZero(),
+ (scale > FXMATH_DECIMAL_SCALELIMIT ? 0 : scale))) {}
+
+CFX_Decimal::CFX_Decimal(int32_t val) {
+ if (val >= 0) {
+ *this = CFX_Decimal(static_cast<uint32_t>(val));
+ } else {
+ *this = CFX_Decimal(static_cast<uint32_t>(-val));
+ SetNegate();
+ }
+}
+
+CFX_Decimal::CFX_Decimal(float val, uint8_t scale) {
+ float newval = fabs(val);
+ uint64_t phi;
+ uint64_t pmid;
+ uint64_t plo;
+ plo = static_cast<uint64_t>(newval);
+ pmid = static_cast<uint64_t>(newval / 1e32);
+ phi = static_cast<uint64_t>(newval / 1e64);
+ newval = FXSYS_fmod(newval, 1.0f);
+ for (uint8_t iter = 0; iter < scale; iter++) {
+ decimal_helper_mul10(phi, pmid, plo);
+ newval *= 10;
+ plo += static_cast<uint64_t>(newval);
+ newval = FXSYS_fmod(newval, 1.0f);
+ }
+
+ plo += FXSYS_round(newval);
+ decimal_helper_normalize(phi, pmid, plo);
+ m_uHi = static_cast<uint32_t>(phi);
+ m_uMid = static_cast<uint32_t>(pmid);
+ m_uLo = static_cast<uint32_t>(plo);
+ m_uFlags = FXMATH_DECIMAL_MAKEFLAGS(val < 0 && IsNotZero(), scale);
+}
+
+CFX_Decimal::CFX_Decimal(const CFX_WideStringC& strObj) {
+ const wchar_t* str = strObj.c_str();
+ const wchar_t* strBound = str + strObj.GetLength();
+ bool pointmet = false;
+ bool negmet = false;
+ uint8_t scale = 0;
+ m_uHi = 0;
+ m_uMid = 0;
+ m_uLo = 0;
+ while (str != strBound && *str == ' ')
+ str++;
+ if (str != strBound && *str == '-') {
+ negmet = 1;
+ str++;
+ } else if (str != strBound && *str == '+') {
+ str++;
+ }
+
+ while (str != strBound && ((*str >= '0' && *str <= '9') || *str == '.') &&
+ scale < FXMATH_DECIMAL_SCALELIMIT) {
+ if (*str == '.') {
+ if (!pointmet)
+ pointmet = 1;
+ } else {
+ m_uHi = m_uHi * 0xA + FXMATH_DECIMAL_RSHIFT32BIT((uint64_t)m_uMid * 0xA);
+ m_uMid = m_uMid * 0xA + FXMATH_DECIMAL_RSHIFT32BIT((uint64_t)m_uLo * 0xA);
+ m_uLo = m_uLo * 0xA + (*str - '0');
+ if (pointmet)
+ scale++;
+ }
+ str++;
+ }
+ m_uFlags = FXMATH_DECIMAL_MAKEFLAGS(negmet && IsNotZero(), scale);
+}
+
+CFX_Decimal::operator CFX_WideString() const {
+ CFX_WideString retString;
+ CFX_WideString tmpbuf;
+ uint64_t phi = m_uHi;
+ uint64_t pmid = m_uMid;
+ uint64_t plo = m_uLo;
+ while (phi || pmid || plo)
+ tmpbuf += decimal_helper_div10(phi, pmid, plo) + '0';
+
+ uint8_t outputlen = (uint8_t)tmpbuf.GetLength();
+ uint8_t scale = (uint8_t)FXMATH_DECIMAL_FLAGS2SCALE(m_uFlags);
+ while (scale >= outputlen) {
+ tmpbuf += '0';
+ outputlen++;
+ }
+ if (FXMATH_DECIMAL_FLAGS2NEG(m_uFlags) && IsNotZero())
+ retString += '-';
+
+ for (uint8_t idx = 0; idx < outputlen; idx++) {
+ if (idx == (outputlen - scale) && scale != 0)
+ retString += '.';
+ retString += tmpbuf[outputlen - 1 - idx];
+ }
+ return retString;
+}
+
+CFX_Decimal::operator double() const {
+ double pow = (double)(1 << 16) * (1 << 16);
+ double base = static_cast<double>(m_uHi) * pow * pow +
+ static_cast<double>(m_uMid) * pow + static_cast<double>(m_uLo);
+ int8_t scale = FXMATH_DECIMAL_FLAGS2SCALE(m_uFlags);
+ bool bNeg = FXMATH_DECIMAL_FLAGS2NEG(m_uFlags);
+ return (bNeg ? -1 : 1) * base * ::pow(10.0, -scale);
+}
+
+void CFX_Decimal::SetScale(uint8_t newscale) {
+ uint8_t oldscale = FXMATH_DECIMAL_FLAGS2SCALE(m_uFlags);
+ if (newscale > oldscale) {
+ uint64_t phi = m_uHi;
+ uint64_t pmid = m_uMid;
+ uint64_t plo = m_uLo;
+ for (uint8_t iter = 0; iter < newscale - oldscale; iter++)
+ decimal_helper_mul10(phi, pmid, plo);
+
+ m_uHi = static_cast<uint32_t>(phi);
+ m_uMid = static_cast<uint32_t>(pmid);
+ m_uLo = static_cast<uint32_t>(plo);
+ m_uFlags = FXMATH_DECIMAL_MAKEFLAGS(
+ FXMATH_DECIMAL_FLAGS2NEG(m_uFlags) && IsNotZero(), newscale);
+ } else if (newscale < oldscale) {
+ uint64_t phi;
+ uint64_t pmid;
+ uint64_t plo;
+ phi = 0;
+ pmid = 0;
+ plo = 5;
+ for (uint8_t iter = 0; iter < oldscale - newscale - 1; iter++)
+ decimal_helper_mul10(phi, pmid, plo);
+
+ phi += m_uHi;
+ pmid += m_uMid;
+ plo += m_uLo;
+ decimal_helper_normalize(phi, pmid, plo);
+ for (uint8_t iter = 0; iter < oldscale - newscale; iter++)
+ decimal_helper_div10(phi, pmid, plo);
+
+ m_uHi = static_cast<uint32_t>(phi);
+ m_uMid = static_cast<uint32_t>(pmid);
+ m_uLo = static_cast<uint32_t>(plo);
+ m_uFlags = FXMATH_DECIMAL_MAKEFLAGS(
+ FXMATH_DECIMAL_FLAGS2NEG(m_uFlags) && IsNotZero(), newscale);
+ }
+}
+
+uint8_t CFX_Decimal::GetScale() {
+ return FXMATH_DECIMAL_FLAGS2SCALE(m_uFlags);
+}
+
+void CFX_Decimal::SetNegate() {
+ if (IsNotZero())
+ m_uFlags ^= FXMATH_DECIMAL_NEGMASK;
+}
+
+void CFX_Decimal::Swap(CFX_Decimal& val) {
+ std::swap(m_uHi, val.m_uHi);
+ std::swap(m_uMid, val.m_uMid);
+ std::swap(m_uLo, val.m_uLo);
+ std::swap(m_uFlags, val.m_uFlags);
+}
+
+CFX_Decimal CFX_Decimal::operator*(const CFX_Decimal& val) const {
+ uint64_t a[3] = {m_uLo, m_uMid, m_uHi},
+ b[3] = {val.m_uLo, val.m_uMid, val.m_uHi};
+ uint64_t c[6];
+ decimal_helper_raw_mul(a, 3, b, 3, c, 6);
+ bool neg = FXMATH_DECIMAL_FLAGS2NEG(m_uFlags) ^
+ FXMATH_DECIMAL_FLAGS2NEG(val.m_uFlags);
+ uint8_t scale = FXMATH_DECIMAL_FLAGS2SCALE(m_uFlags) +
+ FXMATH_DECIMAL_FLAGS2SCALE(val.m_uFlags);
+ decimal_helper_shrinkintorange(c, 6, 3, scale);
+ return CFX_Decimal(static_cast<uint32_t>(c[0]), static_cast<uint32_t>(c[1]),
+ static_cast<uint32_t>(c[2]), neg, scale);
+}
+
+CFX_Decimal CFX_Decimal::operator/(const CFX_Decimal& val) const {
+ if (!val.IsNotZero())
+ return CFX_Decimal();
+
+ bool neg = FXMATH_DECIMAL_FLAGS2NEG(m_uFlags) ^
+ FXMATH_DECIMAL_FLAGS2NEG(val.m_uFlags);
+ uint64_t a[7] = {m_uLo, m_uMid, m_uHi},
+ b[3] = {val.m_uLo, val.m_uMid, val.m_uHi}, c[7] = {0};
+ uint8_t scale = 0;
+ if (FXMATH_DECIMAL_FLAGS2SCALE(m_uFlags) <
+ FXMATH_DECIMAL_FLAGS2SCALE(val.m_uFlags)) {
+ for (int i = FXMATH_DECIMAL_FLAGS2SCALE(val.m_uFlags) -
+ FXMATH_DECIMAL_FLAGS2SCALE(m_uFlags);
+ i > 0; i--) {
+ decimal_helper_mul10_any(a, 7);
+ }
+ } else {
+ scale = FXMATH_DECIMAL_FLAGS2SCALE(m_uFlags) -
+ FXMATH_DECIMAL_FLAGS2SCALE(val.m_uFlags);
+ }
+
+ uint8_t minscale = scale;
+ if (!IsNotZero())
+ return CFX_Decimal(0, 0, 0, 0, minscale);
+
+ while (!a[6]) {
+ decimal_helper_mul10_any(a, 7);
+ scale++;
+ }
+
+ decimal_helper_div10_any(a, 7);
+ scale--;
+ decimal_helper_raw_div(a, 6, b, 3, c, 7);
+ decimal_helper_shrinkintorange(c, 6, 3, scale);
+ decimal_helper_truncate(c[2], c[1], c[0], scale, minscale);
+ return CFX_Decimal(static_cast<uint32_t>(c[0]), static_cast<uint32_t>(c[1]),
+ static_cast<uint32_t>(c[2]), neg, scale);
+}
diff --git a/xfa/fgas/localization/fgas_localeimp.h b/xfa/fgas/localization/cfx_formatstring.h
index 684dfee20b..19764da85c 100644
--- a/xfa/fgas/localization/fgas_localeimp.h
+++ b/xfa/fgas/localization/cfx_formatstring.h
@@ -1,36 +1,31 @@
-// Copyright 2014 PDFium Authors. All rights reserved.
+// Copyright 2017 PDFium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
-#ifndef XFA_FGAS_LOCALIZATION_FGAS_LOCALEIMP_H_
-#define XFA_FGAS_LOCALIZATION_FGAS_LOCALEIMP_H_
+#ifndef XFA_FGAS_LOCALIZATION_CFX_FORMATSTRING_H_
+#define XFA_FGAS_LOCALIZATION_CFX_FORMATSTRING_H_
#include <vector>
#include "xfa/fgas/localization/fgas_locale.h"
-
-class CFX_LCNumeric;
+#include "xfa/fxfa/parser/xfa_localemgr.h"
class CFX_FormatString {
public:
- CFX_FormatString(IFX_LocaleMgr* pLocaleMgr, bool bUseLCID);
+ explicit CFX_FormatString(CXFA_LocaleMgr* pLocaleMgr);
~CFX_FormatString();
void SplitFormatString(const CFX_WideString& wsFormatString,
std::vector<CFX_WideString>& wsPatterns);
FX_LOCALECATEGORY GetCategory(const CFX_WideString& wsPattern);
- uint16_t GetLCID(const CFX_WideString& wsPattern);
CFX_WideString GetLocaleName(const CFX_WideString& wsPattern);
bool ParseText(const CFX_WideString& wsSrcText,
const CFX_WideString& wsPattern,
CFX_WideString& wsValue);
bool ParseNum(const CFX_WideString& wsSrcNum,
const CFX_WideString& wsPattern,
- float& fValue);
- bool ParseNum(const CFX_WideString& wsSrcNum,
- const CFX_WideString& wsPattern,
CFX_WideString& wsValue);
bool ParseDateTime(const CFX_WideString& wsSrcDateTime,
const CFX_WideString& wsPattern,
@@ -46,23 +41,14 @@ class CFX_FormatString {
bool FormatNum(const CFX_WideString& wsSrcNum,
const CFX_WideString& wsPattern,
CFX_WideString& wsOutput);
- bool FormatNum(float fNum,
- const CFX_WideString& wsPattern,
- CFX_WideString& wsOutput);
- bool FormatDateTime(const CFX_WideString& wsSrcDateTime,
- const CFX_WideString& wsPattern,
- CFX_WideString& wsOutput);
bool FormatDateTime(const CFX_WideString& wsSrcDateTime,
const CFX_WideString& wsPattern,
CFX_WideString& wsOutput,
FX_DATETIMETYPE eDateTimeType);
- bool FormatDateTime(const CFX_Unitime& dt,
- const CFX_WideString& wsPattern,
- CFX_WideString& wsOutput);
bool FormatZero(const CFX_WideString& wsPattern, CFX_WideString& wsOutput);
bool FormatNull(const CFX_WideString& wsPattern, CFX_WideString& wsOutput);
- protected:
+ private:
IFX_Locale* GetTextFormat(const CFX_WideString& wsPattern,
const CFX_WideStringC& wsCategory,
CFX_WideString& wsPurgePattern);
@@ -73,17 +59,13 @@ class CFX_FormatString {
bool FormatStrNum(const CFX_WideStringC& wsInputNum,
const CFX_WideString& wsPattern,
CFX_WideString& wsOutput);
- bool FormatLCNumeric(CFX_LCNumeric& lcNum,
- const CFX_WideString& wsPattern,
- CFX_WideString& wsOutput);
FX_DATETIMETYPE GetDateTimeFormat(const CFX_WideString& wsPattern,
IFX_Locale*& pLocale,
CFX_WideString& wsDatePattern,
CFX_WideString& wsTimePattern);
IFX_Locale* GetPatternLocale(const CFX_WideString& wsLocale);
- IFX_LocaleMgr* m_pLocaleMgr;
- bool m_bUseLCID;
+ CXFA_LocaleMgr* m_pLocaleMgr;
};
-#endif // XFA_FGAS_LOCALIZATION_FGAS_LOCALEIMP_H_
+#endif // XFA_FGAS_LOCALIZATION_CFX_FORMATSTRING_H_
diff --git a/xfa/fgas/localization/fgas_locale.cpp b/xfa/fgas/localization/fgas_locale.cpp
index b2c848fed9..db0a25549a 100644
--- a/xfa/fgas/localization/fgas_locale.cpp
+++ b/xfa/fgas/localization/fgas_locale.cpp
@@ -11,7 +11,7 @@
#include "core/fxcrt/fx_ext.h"
#include "core/fxcrt/fx_xml.h"
-#include "xfa/fgas/localization/fgas_localeimp.h"
+#include "xfa/fgas/localization/cfx_formatstring.h"
#define FX_LOCALECATEGORY_DateHash 0xbde9abde
#define FX_LOCALECATEGORY_TimeHash 0x2d71b00f
@@ -21,29 +21,31 @@
#define FX_LOCALECATEGORY_ZeroHash 0x568cb500
#define FX_LOCALECATEGORY_NullHash 0x052931bb
+namespace {
+
struct FX_LOCALESUBCATEGORYINFO {
uint32_t uHash;
const wchar_t* pName;
int32_t eSubCategory;
};
-static const FX_LOCALESUBCATEGORYINFO g_FXLocaleDateTimeSubCatData[] = {
+const FX_LOCALESUBCATEGORYINFO g_FXLocaleDateTimeSubCatData[] = {
{0x14da2125, L"default", FX_LOCALEDATETIMESUBCATEGORY_Default},
{0x9041d4b0, L"short", FX_LOCALEDATETIMESUBCATEGORY_Short},
{0xa084a381, L"medium", FX_LOCALEDATETIMESUBCATEGORY_Medium},
{0xcdce56b3, L"full", FX_LOCALEDATETIMESUBCATEGORY_Full},
{0xf6b4afb0, L"long", FX_LOCALEDATETIMESUBCATEGORY_Long},
};
-static const int32_t g_iFXLocaleDateTimeSubCatCount =
+const int32_t g_iFXLocaleDateTimeSubCatCount =
sizeof(g_FXLocaleDateTimeSubCatData) / sizeof(FX_LOCALESUBCATEGORYINFO);
-static const FX_LOCALESUBCATEGORYINFO g_FXLocaleNumSubCatData[] = {
+const FX_LOCALESUBCATEGORYINFO g_FXLocaleNumSubCatData[] = {
{0x46f95531, L"percent", FX_LOCALENUMPATTERN_Percent},
{0x4c4e8acb, L"currency", FX_LOCALENUMPATTERN_Currency},
{0x54034c2f, L"decimal", FX_LOCALENUMPATTERN_Decimal},
{0x7568e6ae, L"integer", FX_LOCALENUMPATTERN_Integer},
};
-static const int32_t g_iFXLocaleNumSubCatCount =
+const int32_t g_iFXLocaleNumSubCatCount =
sizeof(g_FXLocaleNumSubCatData) / sizeof(FX_LOCALESUBCATEGORYINFO);
struct FX_LOCALETIMEZONEINFO {
@@ -52,246 +54,44 @@ struct FX_LOCALETIMEZONEINFO {
int16_t iMinute;
};
-static const FX_LOCALETIMEZONEINFO g_FXLocaleTimeZoneData[] = {
+const FX_LOCALETIMEZONEINFO g_FXLocaleTimeZoneData[] = {
{FXBSTR_ID(0, 'C', 'D', 'T'), -5, 0}, {FXBSTR_ID(0, 'C', 'S', 'T'), -6, 0},
{FXBSTR_ID(0, 'E', 'D', 'T'), -4, 0}, {FXBSTR_ID(0, 'E', 'S', 'T'), -5, 0},
{FXBSTR_ID(0, 'M', 'D', 'T'), -6, 0}, {FXBSTR_ID(0, 'M', 'S', 'T'), -7, 0},
{FXBSTR_ID(0, 'P', 'D', 'T'), -7, 0}, {FXBSTR_ID(0, 'P', 'S', 'T'), -8, 0},
};
-static const wchar_t gs_wsTimeSymbols[] = L"hHkKMSFAzZ";
-static const wchar_t gs_wsDateSymbols[] = L"DJMEeGgYwW";
-static const wchar_t gs_wsConstChars[] = L",-:/. ";
+const wchar_t gs_wsTimeSymbols[] = L"hHkKMSFAzZ";
+const wchar_t gs_wsDateSymbols[] = L"DJMEeGgYwW";
+const wchar_t gs_wsConstChars[] = L",-:/. ";
-static int32_t FX_ParseTimeZone(const wchar_t* pStr,
- int32_t iLen,
- FX_TIMEZONE& tz) {
+int32_t ParseTimeZone(const wchar_t* pStr, int32_t iLen, FX_TIMEZONE& tz) {
tz.tzHour = 0;
tz.tzMinute = 0;
- if (iLen < 0) {
+ if (iLen < 0)
return 0;
- }
+
int32_t iStart = 1;
int32_t iEnd = iStart + 2;
- while (iStart < iLen && iStart < iEnd) {
+ while (iStart < iLen && iStart < iEnd)
tz.tzHour = tz.tzHour * 10 + pStr[iStart++] - '0';
- }
- if (iStart < iLen && pStr[iStart] == ':') {
+
+ if (iStart < iLen && pStr[iStart] == ':')
iStart++;
- }
+
iEnd = iStart + 2;
- while (iStart < iLen && iStart < iEnd) {
+ while (iStart < iLen && iStart < iEnd)
tz.tzMinute = tz.tzMinute * 10 + pStr[iStart++] - '0';
- }
- if (pStr[0] == '-') {
- tz.tzHour = -tz.tzHour;
- }
- return iStart;
-}
-
-class CFX_LCNumeric {
- public:
- CFX_LCNumeric();
- CFX_LCNumeric(int64_t integral,
- uint32_t fractional = 0,
- int32_t exponent = 0);
- explicit CFX_LCNumeric(float dbRetValue);
- explicit CFX_LCNumeric(double dbvalue);
- explicit CFX_LCNumeric(CFX_WideString& wsNumeric);
-
- float GetFloat() const;
- double GetDouble() const;
- CFX_WideString ToString() const;
- CFX_WideString ToString(int32_t nTreading, bool bTrimTailZeros) const;
-
- int64_t m_Integral;
- uint32_t m_Fractional;
- int32_t m_Exponent;
-};
-
-static bool FX_WStringToNumeric(const CFX_WideString& wsValue,
- CFX_LCNumeric& lcnum) {
- lcnum.m_Integral = 0;
- lcnum.m_Fractional = 0;
- lcnum.m_Exponent = 0;
-
- if (wsValue.IsEmpty())
- return false;
-
- const int32_t nIntegralMaxLen = 17;
- int32_t cc = 0;
- bool bNegative = false;
- bool bExpSign = false;
- const wchar_t* str = wsValue.c_str();
- int32_t len = wsValue.GetLength();
- while (cc < len && FXSYS_iswspace(str[cc]))
- cc++;
-
- if (cc >= len)
- return false;
-
- if (str[cc] == '+') {
- cc++;
- } else if (str[cc] == '-') {
- bNegative = true;
- cc++;
- }
- int32_t nIntegralLen = 0;
- while (cc < len) {
- if (str[cc] == '.')
- break;
- if (!FXSYS_isDecimalDigit(str[cc])) {
- if ((str[cc] == 'E' || str[cc] == 'e'))
- break;
- return false;
- }
- if (nIntegralLen < nIntegralMaxLen) {
- lcnum.m_Integral = lcnum.m_Integral * 10 + str[cc] - '0';
- nIntegralLen++;
- }
- cc++;
- }
-
- lcnum.m_Integral = bNegative ? -lcnum.m_Integral : lcnum.m_Integral;
- if (cc < len && str[cc] == '.') {
- int scale = 0;
- double fraction = 0.0;
- cc++;
- while (cc < len) {
- if (scale >= FXSYS_FractionalScaleCount()) {
- while (cc < len) {
- if (!FXSYS_isDecimalDigit(str[cc]))
- break;
- cc++;
- }
- }
- if (!FXSYS_isDecimalDigit(str[cc])) {
- if ((str[cc] == 'E' || str[cc] == 'e'))
- break;
- return false;
- }
- fraction += FXSYS_FractionalScale(scale, FXSYS_toDecimalDigit(str[cc]));
- scale++;
- cc++;
- }
- lcnum.m_Fractional = (uint32_t)(fraction * 4294967296.0);
- }
- if (cc < len && (str[cc] == 'E' || str[cc] == 'e')) {
- cc++;
- if (cc < len) {
- if (str[cc] == '+') {
- cc++;
- } else if (str[cc] == '-') {
- bExpSign = true;
- cc++;
- }
- }
- while (cc < len) {
- if (FXSYS_isDecimalDigit(str[cc]))
- return false;
- lcnum.m_Exponent = lcnum.m_Exponent * 10 + str[cc] - '0';
- cc++;
- }
- lcnum.m_Exponent = bExpSign ? -lcnum.m_Exponent : lcnum.m_Exponent;
- }
- return true;
-}
-
-CFX_LCNumeric::CFX_LCNumeric() {
- m_Integral = 0;
- m_Fractional = 0;
- m_Exponent = 0;
-}
-CFX_LCNumeric::CFX_LCNumeric(int64_t integral,
- uint32_t fractional,
- int32_t exponent) {
- m_Integral = integral;
- m_Fractional = fractional;
- m_Exponent = exponent;
-}
-CFX_LCNumeric::CFX_LCNumeric(float dbRetValue) {
- m_Integral = (int64_t)dbRetValue;
- m_Fractional = (uint32_t)(((dbRetValue > 0) ? (dbRetValue - m_Integral)
- : (m_Integral - dbRetValue)) *
- 4294967296);
- m_Exponent = 0;
-}
-CFX_LCNumeric::CFX_LCNumeric(double dbvalue) {
- m_Integral = (int64_t)dbvalue;
- m_Fractional = (uint32_t)(
- ((dbvalue > 0) ? (dbvalue - m_Integral) : (m_Integral - dbvalue)) *
- 4294967296);
- m_Exponent = 0;
-}
-CFX_LCNumeric::CFX_LCNumeric(CFX_WideString& wsNumeric) {
- FX_WStringToNumeric(wsNumeric, *this);
-}
-float CFX_LCNumeric::GetFloat() const {
- float dbRetValue = m_Fractional / 4294967296.0f;
- dbRetValue = m_Integral + (m_Integral >= 0 ? dbRetValue : -dbRetValue);
- if (m_Exponent != 0) {
- dbRetValue *= FXSYS_pow(10, (float)m_Exponent);
- }
- return dbRetValue;
-}
-double CFX_LCNumeric::GetDouble() const {
- double value = m_Fractional / 4294967296.0;
- value = m_Integral + (m_Integral >= 0 ? value : -value);
- if (m_Exponent != 0) {
- value *= FXSYS_pow(10, (float)m_Exponent);
- }
- return value;
-}
-
-CFX_WideString CFX_LCNumeric::ToString() const {
- return ToString(8, true);
-}
-
-CFX_WideString CFX_LCNumeric::ToString(int32_t nTreading,
- bool bTrimTailZeros) const {
- CFX_WideString wsFormat;
- wsFormat.Format(L"%%.%df", nTreading);
- CFX_WideString wsResult;
- wsResult.Format(wsFormat.c_str(), GetDouble());
- if (bTrimTailZeros && nTreading > 0) {
- wsResult.TrimRight(L"0");
- wsResult.TrimRight(L".");
- }
- return wsResult;
-}
-
-CFX_FormatString::CFX_FormatString(IFX_LocaleMgr* pLocaleMgr, bool bUseLCID)
- : m_pLocaleMgr(pLocaleMgr), m_bUseLCID(bUseLCID) {}
-
-CFX_FormatString::~CFX_FormatString() {}
+ if (pStr[0] == '-')
+ tz.tzHour = -tz.tzHour;
-void CFX_FormatString::SplitFormatString(
- const CFX_WideString& wsFormatString,
- std::vector<CFX_WideString>& wsPatterns) {
- int32_t iStrLen = wsFormatString.GetLength();
- const wchar_t* pStr = wsFormatString.c_str();
- const wchar_t* pToken = pStr;
- const wchar_t* pEnd = pStr + iStrLen;
- bool iQuote = false;
- while (true) {
- if (pStr >= pEnd) {
- wsPatterns.push_back(CFX_WideString(pToken, pStr - pToken));
- return;
- }
- if (*pStr == '\'') {
- iQuote = !iQuote;
- } else if (*pStr == L'|' && !iQuote) {
- wsPatterns.push_back(CFX_WideString(pToken, pStr - pToken));
- pToken = pStr + 1;
- }
- pStr++;
- }
+ return iStart;
}
-static CFX_WideString FX_GetLiteralText(const wchar_t* pStrPattern,
- int32_t& iPattern,
- int32_t iLenPattern) {
+CFX_WideString GetLiteralText(const wchar_t* pStrPattern,
+ int32_t& iPattern,
+ int32_t iLenPattern) {
CFX_WideString wsOutput;
if (pStrPattern[iPattern] != '\'') {
return wsOutput;
@@ -332,8 +132,9 @@ static CFX_WideString FX_GetLiteralText(const wchar_t* pStrPattern,
}
return wsOutput;
}
-static CFX_WideString FX_GetLiteralTextReverse(const wchar_t* pStrPattern,
- int32_t& iPattern) {
+
+CFX_WideString GetLiteralTextReverse(const wchar_t* pStrPattern,
+ int32_t& iPattern) {
CFX_WideString wsOutput;
if (pStrPattern[iPattern] != '\'') {
return wsOutput;
@@ -375,6 +176,971 @@ static CFX_WideString FX_GetLiteralTextReverse(const wchar_t* pStrPattern,
}
return wsOutput;
}
+
+bool GetNumericDotIndex(const CFX_WideString& wsNum,
+ const CFX_WideString& wsDotSymbol,
+ int32_t& iDotIndex) {
+ int32_t ccf = 0;
+ int32_t iLenf = wsNum.GetLength();
+ const wchar_t* pStr = wsNum.c_str();
+ int32_t iLenDot = wsDotSymbol.GetLength();
+ while (ccf < iLenf) {
+ if (pStr[ccf] == '\'') {
+ GetLiteralText(pStr, ccf, iLenf);
+ } else if (ccf + iLenDot <= iLenf &&
+ !FXSYS_wcsncmp(pStr + ccf, wsDotSymbol.c_str(), iLenDot)) {
+ iDotIndex = ccf;
+ return true;
+ }
+ ccf++;
+ }
+ iDotIndex = wsNum.Find('.');
+ if (iDotIndex < 0) {
+ iDotIndex = iLenf;
+ return false;
+ }
+ return true;
+}
+
+bool ParseLocaleDate(const CFX_WideString& wsDate,
+ const CFX_WideString& wsDatePattern,
+ IFX_Locale* pLocale,
+ CFX_Unitime& datetime,
+ int32_t& cc) {
+ int32_t year = 1900;
+ int32_t month = 1;
+ int32_t day = 1;
+ int32_t ccf = 0;
+ const wchar_t* str = wsDate.c_str();
+ int32_t len = wsDate.GetLength();
+ const wchar_t* strf = wsDatePattern.c_str();
+ int32_t lenf = wsDatePattern.GetLength();
+ CFX_WideStringC wsDateSymbols(gs_wsDateSymbols);
+ while (cc < len && ccf < lenf) {
+ if (strf[ccf] == '\'') {
+ CFX_WideString wsLiteral = GetLiteralText(strf, ccf, lenf);
+ int32_t iLiteralLen = wsLiteral.GetLength();
+ if (cc + iLiteralLen > len ||
+ FXSYS_wcsncmp(str + cc, wsLiteral.c_str(), iLiteralLen)) {
+ return false;
+ }
+ cc += iLiteralLen;
+ ccf++;
+ continue;
+ } else if (wsDateSymbols.Find(strf[ccf]) == -1) {
+ if (strf[ccf] != str[cc])
+ return false;
+ cc++;
+ ccf++;
+ continue;
+ }
+ uint32_t dwSymbolNum = 1;
+ wchar_t dwCharSymbol = strf[ccf++];
+ while (ccf < lenf && strf[ccf] == dwCharSymbol) {
+ ccf++;
+ dwSymbolNum++;
+ }
+ uint32_t dwSymbol = (dwCharSymbol << 8) | (dwSymbolNum + '0');
+ if (dwSymbol == FXBSTR_ID(0, 0, 'D', '1')) {
+ if (!FXSYS_isDecimalDigit(str[cc])) {
+ return false;
+ }
+ day = str[cc++] - '0';
+ if (cc < len && FXSYS_isDecimalDigit(str[cc])) {
+ day = day * 10 + str[cc++] - '0';
+ }
+ } else if (dwSymbol == FXBSTR_ID(0, 0, 'D', '2')) {
+ if (!FXSYS_isDecimalDigit(str[cc])) {
+ return false;
+ }
+ day = str[cc++] - '0';
+ if (cc < len) {
+ day = day * 10 + str[cc++] - '0';
+ }
+ } else if (dwSymbol == FXBSTR_ID(0, 0, 'J', '1')) {
+ int i = 0;
+ while (cc < len && i < 3 && FXSYS_isDecimalDigit(str[cc])) {
+ cc++;
+ i++;
+ }
+ } else if (dwSymbol == FXBSTR_ID(0, 0, 'J', '3')) {
+ cc += 3;
+ } else if (dwSymbol == FXBSTR_ID(0, 0, 'M', '1')) {
+ if (!FXSYS_isDecimalDigit(str[cc])) {
+ return false;
+ }
+ month = str[cc++] - '0';
+ if (cc < len && FXSYS_isDecimalDigit(str[cc])) {
+ month = month * 10 + str[cc++] - '0';
+ }
+ } else if (dwSymbol == FXBSTR_ID(0, 0, 'M', '2')) {
+ if (!FXSYS_isDecimalDigit(str[cc])) {
+ return false;
+ }
+ month = str[cc++] - '0';
+ if (cc < len) {
+ month = month * 10 + str[cc++] - '0';
+ }
+ } else if (dwSymbol == FXBSTR_ID(0, 0, 'M', '3')) {
+ CFX_WideString wsMonthNameAbbr;
+ uint16_t i = 0;
+ for (; i < 12; i++) {
+ pLocale->GetMonthName(i, wsMonthNameAbbr, true);
+ if (wsMonthNameAbbr.IsEmpty()) {
+ continue;
+ }
+ if (!FXSYS_wcsncmp(wsMonthNameAbbr.c_str(), str + cc,
+ wsMonthNameAbbr.GetLength())) {
+ break;
+ }
+ }
+ if (i < 12) {
+ cc += wsMonthNameAbbr.GetLength();
+ month = i + 1;
+ }
+ } else if (dwSymbol == FXBSTR_ID(0, 0, 'M', '4')) {
+ CFX_WideString wsMonthName;
+ uint16_t i = 0;
+ for (; i < 12; i++) {
+ pLocale->GetMonthName(i, wsMonthName, false);
+ if (wsMonthName.IsEmpty()) {
+ continue;
+ }
+ if (!FXSYS_wcsncmp(wsMonthName.c_str(), str + cc,
+ wsMonthName.GetLength())) {
+ break;
+ }
+ }
+ if (i < 12) {
+ cc += wsMonthName.GetLength();
+ month = i + 1;
+ }
+ } else if (dwSymbol == FXBSTR_ID(0, 0, 'E', '1')) {
+ cc += 1;
+ } else if (dwSymbol == FXBSTR_ID(0, 0, 'E', '3')) {
+ CFX_WideString wsDayNameAbbr;
+ uint16_t i = 0;
+ for (; i < 7; i++) {
+ pLocale->GetDayName(i, wsDayNameAbbr, true);
+ if (wsDayNameAbbr.IsEmpty()) {
+ continue;
+ }
+ if (!FXSYS_wcsncmp(wsDayNameAbbr.c_str(), str + cc,
+ wsDayNameAbbr.GetLength())) {
+ break;
+ }
+ }
+ if (i < 12) {
+ cc += wsDayNameAbbr.GetLength();
+ }
+ } else if (dwSymbol == FXBSTR_ID(0, 0, 'E', '4')) {
+ CFX_WideString wsDayName;
+ int32_t i = 0;
+ for (; i < 7; i++) {
+ pLocale->GetDayName(i, wsDayName, false);
+ if (wsDayName == L"") {
+ continue;
+ }
+ if (!FXSYS_wcsncmp(wsDayName.c_str(), str + cc,
+ wsDayName.GetLength())) {
+ break;
+ }
+ }
+ if (i < 12) {
+ cc += wsDayName.GetLength();
+ }
+ } else if (dwSymbol == FXBSTR_ID(0, 0, 'e', '1')) {
+ cc += 1;
+ } else if (dwSymbol == FXBSTR_ID(0, 0, 'G', '1')) {
+ cc += 2;
+ } else if (dwSymbol == FXBSTR_ID(0, 0, 'Y', '2')) {
+ if (cc + 2 > len) {
+ return false;
+ }
+ if (!FXSYS_isDecimalDigit(str[cc])) {
+ return false;
+ }
+ year = str[cc++] - '0';
+ if (cc >= len || !FXSYS_isDecimalDigit(str[cc])) {
+ return false;
+ }
+ year = year * 10 + str[cc++] - '0';
+ if (year <= 29) {
+ year += 2000;
+ } else {
+ year += 1900;
+ }
+ } else if (dwSymbol == FXBSTR_ID(0, 0, 'Y', '4')) {
+ int i = 0;
+ year = 0;
+ if (cc + 4 > len) {
+ return false;
+ }
+ while (i < 4) {
+ if (!FXSYS_isDecimalDigit(str[cc])) {
+ return false;
+ }
+ year = year * 10 + str[cc] - '0';
+ cc++;
+ i++;
+ }
+ } else if (dwSymbol == FXBSTR_ID(0, 0, 'w', '1')) {
+ cc += 1;
+ } else if (dwSymbol == FXBSTR_ID(0, 0, 'W', '2')) {
+ cc += 2;
+ }
+ }
+ if (cc < len) {
+ return false;
+ }
+ CFX_Unitime ut;
+ ut.Set(year, month, day);
+ datetime = datetime + ut;
+ return !!cc;
+}
+
+void ResolveZone(uint8_t& wHour,
+ uint8_t& wMinute,
+ FX_TIMEZONE tzDiff,
+ IFX_Locale* pLocale) {
+ int32_t iMinuteDiff = wHour * 60 + wMinute;
+ FX_TIMEZONE tzLocale;
+ pLocale->GetTimeZone(&tzLocale);
+ iMinuteDiff += tzLocale.tzHour * 60 +
+ (tzLocale.tzHour < 0 ? -tzLocale.tzMinute : tzLocale.tzMinute);
+ iMinuteDiff -= tzDiff.tzHour * 60 +
+ (tzDiff.tzHour < 0 ? -tzDiff.tzMinute : tzDiff.tzMinute);
+ while (iMinuteDiff > 1440) {
+ iMinuteDiff -= 1440;
+ }
+ while (iMinuteDiff < 0) {
+ iMinuteDiff += 1440;
+ }
+ wHour = iMinuteDiff / 60;
+ wMinute = iMinuteDiff % 60;
+}
+
+bool ParseLocaleTime(const CFX_WideString& wsTime,
+ const CFX_WideString& wsTimePattern,
+ IFX_Locale* pLocale,
+ CFX_Unitime& datetime,
+ int32_t& cc) {
+ uint8_t hour = 0;
+ uint8_t minute = 0;
+ uint8_t second = 0;
+ uint16_t millisecond = 0;
+ int32_t ccf = 0;
+ const wchar_t* str = wsTime.c_str();
+ int len = wsTime.GetLength();
+ const wchar_t* strf = wsTimePattern.c_str();
+ int lenf = wsTimePattern.GetLength();
+ bool bHasA = false;
+ bool bPM = false;
+ CFX_WideStringC wsTimeSymbols(gs_wsTimeSymbols);
+ while (cc < len && ccf < lenf) {
+ if (strf[ccf] == '\'') {
+ CFX_WideString wsLiteral = GetLiteralText(strf, ccf, lenf);
+ int32_t iLiteralLen = wsLiteral.GetLength();
+ if (cc + iLiteralLen > len ||
+ FXSYS_wcsncmp(str + cc, wsLiteral.c_str(), iLiteralLen)) {
+ return false;
+ }
+ cc += iLiteralLen;
+ ccf++;
+ continue;
+ } else if (wsTimeSymbols.Find(strf[ccf]) == -1) {
+ if (strf[ccf] != str[cc])
+ return false;
+ cc++;
+ ccf++;
+ continue;
+ }
+ uint32_t dwSymbolNum = 1;
+ wchar_t dwCharSymbol = strf[ccf++];
+ while (ccf < lenf && strf[ccf] == dwCharSymbol) {
+ ccf++;
+ dwSymbolNum++;
+ }
+ uint32_t dwSymbol = (dwCharSymbol << 8) | (dwSymbolNum + '0');
+ if (dwSymbol == FXBSTR_ID(0, 0, 'k', '1') ||
+ dwSymbol == FXBSTR_ID(0, 0, 'H', '1') ||
+ dwSymbol == FXBSTR_ID(0, 0, 'h', '1') ||
+ dwSymbol == FXBSTR_ID(0, 0, 'K', '1')) {
+ if (!FXSYS_isDecimalDigit(str[cc])) {
+ return false;
+ }
+ hour = str[cc++] - '0';
+ if (cc < len && FXSYS_isDecimalDigit(str[cc])) {
+ hour = hour * 10 + str[cc++] - '0';
+ }
+ if (dwSymbol == FXBSTR_ID(0, 0, 'K', '1') && hour == 24) {
+ hour = 0;
+ }
+ } else if (dwSymbol == FXBSTR_ID(0, 0, 'k', '2') ||
+ dwSymbol == FXBSTR_ID(0, 0, 'H', '2') ||
+ dwSymbol == FXBSTR_ID(0, 0, 'h', '2') ||
+ dwSymbol == FXBSTR_ID(0, 0, 'K', '2')) {
+ if (!FXSYS_isDecimalDigit(str[cc])) {
+ return false;
+ }
+ hour = str[cc++] - '0';
+ if (cc >= len) {
+ return false;
+ }
+ if (!FXSYS_isDecimalDigit(str[cc])) {
+ return false;
+ }
+ hour = hour * 10 + str[cc++] - '0';
+ if (dwSymbol == FXBSTR_ID(0, 0, 'K', '2') && hour == 24) {
+ hour = 0;
+ }
+ } else if (dwSymbol == FXBSTR_ID(0, 0, 'M', '1')) {
+ if (!FXSYS_isDecimalDigit(str[cc])) {
+ return false;
+ }
+ minute = str[cc++] - '0';
+ if (cc < len && FXSYS_isDecimalDigit(str[cc])) {
+ minute = minute * 10 + str[cc++] - '0';
+ }
+ } else if (dwSymbol == FXBSTR_ID(0, 0, 'M', '2')) {
+ if (!FXSYS_isDecimalDigit(str[cc])) {
+ return false;
+ }
+ minute = str[cc++] - '0';
+ if (cc >= len) {
+ return false;
+ }
+ if (!FXSYS_isDecimalDigit(str[cc])) {
+ return false;
+ }
+ minute = minute * 10 + str[cc++] - '0';
+ } else if (dwSymbol == FXBSTR_ID(0, 0, 'S', '1')) {
+ if (!FXSYS_isDecimalDigit(str[cc])) {
+ return false;
+ }
+ second = str[cc++] - '0';
+ if (cc < len && FXSYS_isDecimalDigit(str[cc])) {
+ second = second * 10 + str[cc++] - '0';
+ }
+ } else if (dwSymbol == FXBSTR_ID(0, 0, 'S', '2')) {
+ if (!FXSYS_isDecimalDigit(str[cc])) {
+ return false;
+ }
+ second = str[cc++] - '0';
+ if (cc >= len) {
+ return false;
+ }
+ if (!FXSYS_isDecimalDigit(str[cc])) {
+ return false;
+ }
+ second = second * 10 + str[cc++] - '0';
+ } else if (dwSymbol == FXBSTR_ID(0, 0, 'F', '3')) {
+ if (cc + 3 >= len) {
+ return false;
+ }
+ int i = 0;
+ while (i < 3) {
+ if (!FXSYS_isDecimalDigit(str[cc])) {
+ return false;
+ }
+ millisecond = millisecond * 10 + str[cc++] - '0';
+ i++;
+ }
+ } else if (dwSymbol == FXBSTR_ID(0, 0, 'A', '1')) {
+ CFX_WideString wsAM;
+ pLocale->GetMeridiemName(wsAM, true);
+ CFX_WideString wsPM;
+ pLocale->GetMeridiemName(wsPM, false);
+ if ((cc + wsAM.GetLength() <= len) &&
+ (CFX_WideStringC(str + cc, wsAM.GetLength()) == wsAM)) {
+ cc += wsAM.GetLength();
+ bHasA = true;
+ } else if ((cc + wsPM.GetLength() <= len) &&
+ (CFX_WideStringC(str + cc, wsPM.GetLength()) == wsPM)) {
+ cc += wsPM.GetLength();
+ bHasA = true;
+ bPM = true;
+ }
+ } else if (dwSymbol == FXBSTR_ID(0, 0, 'Z', '1')) {
+ if (cc + 3 > len) {
+ continue;
+ }
+ uint32_t dwHash = str[cc++];
+ dwHash = (dwHash << 8) | str[cc++];
+ dwHash = (dwHash << 8) | str[cc++];
+ if (dwHash == FXBSTR_ID(0, 'G', 'M', 'T')) {
+ FX_TIMEZONE tzDiff;
+ tzDiff.tzHour = 0;
+ tzDiff.tzMinute = 0;
+ if (cc < len && (str[cc] == '-' || str[cc] == '+')) {
+ cc += ParseTimeZone(str + cc, len - cc, tzDiff);
+ }
+ ResolveZone(hour, minute, tzDiff, pLocale);
+ } else {
+ const FX_LOCALETIMEZONEINFO* pEnd =
+ g_FXLocaleTimeZoneData + FX_ArraySize(g_FXLocaleTimeZoneData);
+ const FX_LOCALETIMEZONEINFO* pTimeZoneInfo =
+ std::lower_bound(g_FXLocaleTimeZoneData, pEnd, dwHash,
+ [](const FX_LOCALETIMEZONEINFO& info,
+ uint32_t hash) { return info.uHash < hash; });
+ if (pTimeZoneInfo < pEnd && dwHash == pTimeZoneInfo->uHash) {
+ hour += pTimeZoneInfo->iHour;
+ minute += pTimeZoneInfo->iHour > 0 ? pTimeZoneInfo->iMinute
+ : -pTimeZoneInfo->iMinute;
+ }
+ }
+ } else if (dwSymbol == FXBSTR_ID(0, 0, 'z', '1')) {
+ if (str[cc] != 'Z') {
+ FX_TIMEZONE tzDiff;
+ cc += ParseTimeZone(str + cc, len - cc, tzDiff);
+ ResolveZone(hour, minute, tzDiff, pLocale);
+ } else {
+ cc++;
+ }
+ }
+ }
+ if (bHasA) {
+ if (bPM) {
+ hour += 12;
+ if (hour == 24) {
+ hour = 12;
+ }
+ } else {
+ if (hour == 12) {
+ hour = 0;
+ }
+ }
+ }
+ CFX_Unitime ut;
+ ut.Set(0, 0, 0, hour, minute, second, millisecond);
+ datetime = datetime + ut;
+ return !!cc;
+}
+
+int32_t GetNumTrailingLimit(const CFX_WideString& wsFormat,
+ int iDotPos,
+ bool& bTrimTailZeros) {
+ if (iDotPos < 0)
+ return 0;
+
+ int32_t iCount = wsFormat.GetLength();
+ int32_t iTreading = 0;
+ for (iDotPos++; iDotPos < iCount; iDotPos++) {
+ wchar_t wc = wsFormat[iDotPos];
+ if (wc == L'z' || wc == L'9' || wc == 'Z') {
+ iTreading++;
+ bTrimTailZeros = (wc == L'9' ? false : true);
+ }
+ }
+ return iTreading;
+}
+
+uint16_t GetSolarMonthDays(uint16_t year, uint16_t month) {
+ if (month % 2)
+ return 31;
+ if (month == 2)
+ return FX_IsLeapYear(year) ? 29 : 28;
+ return 30;
+}
+
+uint16_t GetWeekDay(uint16_t year, uint16_t month, uint16_t day) {
+ uint16_t g_month_day[] = {0, 3, 3, 6, 1, 4, 6, 2, 5, 0, 3, 5};
+ uint16_t nDays =
+ (year - 1) % 7 + (year - 1) / 4 - (year - 1) / 100 + (year - 1) / 400;
+ nDays += g_month_day[month - 1] + day;
+ if (FX_IsLeapYear(year) && month > 2)
+ nDays++;
+ return nDays % 7;
+}
+
+uint16_t GetWeekOfMonth(uint16_t year, uint16_t month, uint16_t day) {
+ uint16_t week_day = GetWeekDay(year, month, 1);
+ uint16_t week_index = 0;
+ week_index += day / 7;
+ day = day % 7;
+ if (week_day + day > 7)
+ week_index++;
+ return week_index;
+}
+
+uint16_t GetWeekOfYear(uint16_t year, uint16_t month, uint16_t day) {
+ uint16_t nDays = 0;
+ for (uint16_t i = 1; i < month; i++)
+ nDays += GetSolarMonthDays(year, i);
+
+ nDays += day;
+ uint16_t week_day = GetWeekDay(year, 1, 1);
+ uint16_t week_index = 1;
+ week_index += nDays / 7;
+ nDays = nDays % 7;
+ if (week_day + nDays > 7)
+ week_index++;
+ return week_index;
+}
+
+bool DateFormat(const CFX_WideString& wsDatePattern,
+ IFX_Locale* pLocale,
+ const CFX_Unitime& datetime,
+ CFX_WideString& wsResult) {
+ bool bRet = true;
+ int32_t year = datetime.GetYear();
+ uint8_t month = datetime.GetMonth();
+ uint8_t day = datetime.GetDay();
+ int32_t ccf = 0;
+ const wchar_t* strf = wsDatePattern.c_str();
+ int32_t lenf = wsDatePattern.GetLength();
+ CFX_WideStringC wsDateSymbols(gs_wsDateSymbols);
+ while (ccf < lenf) {
+ if (strf[ccf] == '\'') {
+ wsResult += GetLiteralText(strf, ccf, lenf);
+ ccf++;
+ continue;
+ } else if (wsDateSymbols.Find(strf[ccf]) == -1) {
+ wsResult += strf[ccf++];
+ continue;
+ }
+ uint32_t dwSymbolNum = 1;
+ wchar_t dwCharSymbol = strf[ccf++];
+ while (ccf < lenf && strf[ccf] == dwCharSymbol) {
+ ccf++;
+ dwSymbolNum++;
+ }
+ uint32_t dwSymbol = (dwCharSymbol << 8) | (dwSymbolNum + '0');
+ if (dwSymbol == FXBSTR_ID(0, 0, 'D', '1')) {
+ CFX_WideString wsDay;
+ wsDay.Format(L"%d", day);
+ wsResult += wsDay;
+ } else if (dwSymbol == FXBSTR_ID(0, 0, 'D', '2')) {
+ CFX_WideString wsDay;
+ wsDay.Format(L"%02d", day);
+ wsResult += wsDay;
+ } else if (dwSymbol == FXBSTR_ID(0, 0, 'J', '1')) {
+ uint16_t nDays = 0;
+ for (int i = 1; i < month; i++) {
+ nDays += GetSolarMonthDays(year, i);
+ }
+ nDays += day;
+ CFX_WideString wsDays;
+ wsDays.Format(L"%d", nDays);
+ wsResult += wsDays;
+ } else if (dwSymbol == FXBSTR_ID(0, 0, 'J', '3')) {
+ uint16_t nDays = 0;
+ for (int i = 1; i < month; i++) {
+ nDays += GetSolarMonthDays(year, i);
+ }
+ nDays += day;
+ CFX_WideString wsDays;
+ wsDays.Format(L"%03d", nDays);
+ wsResult += wsDays;
+ } else if (dwSymbol == FXBSTR_ID(0, 0, 'M', '1')) {
+ CFX_WideString wsMonth;
+ wsMonth.Format(L"%d", month);
+ wsResult += wsMonth;
+ } else if (dwSymbol == FXBSTR_ID(0, 0, 'M', '2')) {
+ CFX_WideString wsMonth;
+ wsMonth.Format(L"%02d", month);
+ wsResult += wsMonth;
+ } else if (dwSymbol == FXBSTR_ID(0, 0, 'M', '3')) {
+ CFX_WideString wsTemp;
+ pLocale->GetMonthName(month - 1, wsTemp, true);
+ wsResult += wsTemp;
+ } else if (dwSymbol == FXBSTR_ID(0, 0, 'M', '4')) {
+ CFX_WideString wsTemp;
+ pLocale->GetMonthName(month - 1, wsTemp, false);
+ wsResult += wsTemp;
+ } else if (dwSymbol == FXBSTR_ID(0, 0, 'E', '1')) {
+ uint16_t wWeekDay = GetWeekDay(year, month, day);
+ CFX_WideString wsWeekDay;
+ wsWeekDay.Format(L"%d", wWeekDay + 1);
+ wsResult += wsWeekDay;
+ } else if (dwSymbol == FXBSTR_ID(0, 0, 'E', '3')) {
+ uint16_t wWeekDay = GetWeekDay(year, month, day);
+ CFX_WideString wsTemp;
+ pLocale->GetDayName(wWeekDay, wsTemp, true);
+ wsResult += wsTemp;
+ } else if (dwSymbol == FXBSTR_ID(0, 0, 'E', '4')) {
+ uint16_t wWeekDay = GetWeekDay(year, month, day);
+ if (pLocale) {
+ CFX_WideString wsTemp;
+ pLocale->GetDayName(wWeekDay, wsTemp, false);
+ wsResult += wsTemp;
+ }
+ } else if (dwSymbol == FXBSTR_ID(0, 0, 'e', '1')) {
+ uint16_t wWeekDay = GetWeekDay(year, month, day);
+ CFX_WideString wsWeekDay;
+ wsWeekDay.Format(L"%d", wWeekDay ? wWeekDay : 7);
+ wsResult += wsWeekDay;
+ } else if (dwSymbol == FXBSTR_ID(0, 0, 'G', '1')) {
+ CFX_WideString wsTemp;
+ pLocale->GetEraName(wsTemp, year < 0);
+ wsResult += wsTemp;
+ } else if (dwSymbol == FXBSTR_ID(0, 0, 'Y', '2')) {
+ CFX_WideString wsYear;
+ wsYear.Format(L"%02d", year % 100);
+ wsResult += wsYear;
+ } else if (dwSymbol == FXBSTR_ID(0, 0, 'Y', '4')) {
+ CFX_WideString wsYear;
+ wsYear.Format(L"%d", year);
+ wsResult += wsYear;
+ } else if (dwSymbol == FXBSTR_ID(0, 0, 'w', '1')) {
+ uint16_t week_index = GetWeekOfMonth(year, month, day);
+ CFX_WideString wsWeekInMonth;
+ wsWeekInMonth.Format(L"%d", week_index);
+ wsResult += wsWeekInMonth;
+ } else if (dwSymbol == FXBSTR_ID(0, 0, 'W', '2')) {
+ uint16_t week_index = GetWeekOfYear(year, month, day);
+ CFX_WideString wsWeekInYear;
+ wsWeekInYear.Format(L"%02d", week_index);
+ wsResult += wsWeekInYear;
+ }
+ }
+ return bRet;
+}
+
+bool TimeFormat(const CFX_WideString& wsTimePattern,
+ IFX_Locale* pLocale,
+ const CFX_Unitime& datetime,
+ CFX_WideString& wsResult) {
+ bool bGMT = false;
+ bool bRet = true;
+ uint8_t hour = datetime.GetHour();
+ uint8_t minute = datetime.GetMinute();
+ uint8_t second = datetime.GetSecond();
+ uint16_t millisecond = datetime.GetMillisecond();
+ int32_t ccf = 0;
+ const wchar_t* strf = wsTimePattern.c_str();
+ int32_t lenf = wsTimePattern.GetLength();
+ uint16_t wHour = hour;
+ bool bPM = false;
+ if (wsTimePattern.Find('A') != -1) {
+ if (wHour >= 12) {
+ bPM = true;
+ }
+ }
+ CFX_WideStringC wsTimeSymbols(gs_wsTimeSymbols);
+ while (ccf < lenf) {
+ if (strf[ccf] == '\'') {
+ wsResult += GetLiteralText(strf, ccf, lenf);
+ ccf++;
+ continue;
+ } else if (wsTimeSymbols.Find(strf[ccf]) == -1) {
+ wsResult += strf[ccf++];
+ continue;
+ }
+ uint32_t dwSymbolNum = 1;
+ wchar_t dwCharSymbol = strf[ccf++];
+ while (ccf < lenf && strf[ccf] == dwCharSymbol) {
+ ccf++;
+ dwSymbolNum++;
+ }
+ uint32_t dwSymbol = (dwCharSymbol << 8) | (dwSymbolNum + '0');
+ if (dwSymbol == FXBSTR_ID(0, 0, 'h', '1')) {
+ if (wHour > 12) {
+ wHour -= 12;
+ }
+ CFX_WideString wsHour;
+ wsHour.Format(L"%d", wHour == 0 ? 12 : wHour);
+ wsResult += wsHour;
+ } else if (dwSymbol == FXBSTR_ID(0, 0, 'h', '2')) {
+ if (wHour > 12) {
+ wHour -= 12;
+ }
+ CFX_WideString wsHour;
+ wsHour.Format(L"%02d", wHour == 0 ? 12 : wHour);
+ wsResult += wsHour;
+ } else if (dwSymbol == FXBSTR_ID(0, 0, 'K', '1')) {
+ CFX_WideString wsHour;
+ wsHour.Format(L"%d", wHour == 0 ? 24 : wHour);
+ wsResult += wsHour;
+ } else if (dwSymbol == FXBSTR_ID(0, 0, 'K', '2')) {
+ CFX_WideString wsHour;
+ wsHour.Format(L"%02d", wHour == 0 ? 24 : wHour);
+ wsResult += wsHour;
+ } else if (dwSymbol == FXBSTR_ID(0, 0, 'k', '1')) {
+ if (wHour > 12) {
+ wHour -= 12;
+ }
+ CFX_WideString wsHour;
+ wsHour.Format(L"%d", wHour);
+ wsResult += wsHour;
+ } else if (dwSymbol == FXBSTR_ID(0, 0, 'H', '1')) {
+ CFX_WideString wsHour;
+ wsHour.Format(L"%d", wHour);
+ wsResult += wsHour;
+ } else if (dwSymbol == FXBSTR_ID(0, 0, 'k', '2')) {
+ if (wHour > 12) {
+ wHour -= 12;
+ }
+ CFX_WideString wsHour;
+ wsHour.Format(L"%02d", wHour);
+ wsResult += wsHour;
+ } else if (dwSymbol == FXBSTR_ID(0, 0, 'H', '2')) {
+ CFX_WideString wsHour;
+ wsHour.Format(L"%02d", wHour);
+ wsResult += wsHour;
+ } else if (dwSymbol == FXBSTR_ID(0, 0, 'M', '1')) {
+ CFX_WideString wsMinute;
+ wsMinute.Format(L"%d", minute);
+ wsResult += wsMinute;
+ } else if (dwSymbol == FXBSTR_ID(0, 0, 'M', '2')) {
+ CFX_WideString wsMinute;
+ wsMinute.Format(L"%02d", minute);
+ wsResult += wsMinute;
+ } else if (dwSymbol == FXBSTR_ID(0, 0, 'S', '1')) {
+ CFX_WideString wsSecond;
+ wsSecond.Format(L"%d", second);
+ wsResult += wsSecond;
+ } else if (dwSymbol == FXBSTR_ID(0, 0, 'S', '2')) {
+ CFX_WideString wsSecond;
+ wsSecond.Format(L"%02d", second);
+ wsResult += wsSecond;
+ } else if (dwSymbol == FXBSTR_ID(0, 0, 'F', '3')) {
+ CFX_WideString wsMilliseconds;
+ wsMilliseconds.Format(L"%03d", millisecond);
+ wsResult += wsMilliseconds;
+ } else if (dwSymbol == FXBSTR_ID(0, 0, 'A', '1')) {
+ CFX_WideString wsMeridiem;
+ pLocale->GetMeridiemName(wsMeridiem, !bPM);
+ wsResult += wsMeridiem;
+ } else if (dwSymbol == FXBSTR_ID(0, 0, 'Z', '1')) {
+ wsResult += L"GMT";
+ FX_TIMEZONE tz;
+ pLocale->GetTimeZone(&tz);
+ if (!bGMT && (tz.tzHour != 0 || tz.tzMinute != 0)) {
+ if (tz.tzHour < 0) {
+ wsResult += L"-";
+ } else {
+ wsResult += L"+";
+ }
+ CFX_WideString wsTimezone;
+ wsTimezone.Format(L"%02d:%02d", FXSYS_abs(tz.tzHour), tz.tzMinute);
+ wsResult += wsTimezone;
+ }
+ } else if (dwSymbol == FXBSTR_ID(0, 0, 'z', '1')) {
+ FX_TIMEZONE tz;
+ pLocale->GetTimeZone(&tz);
+ if (!bGMT && tz.tzHour != 0 && tz.tzMinute != 0) {
+ if (tz.tzHour < 0) {
+ wsResult += L"-";
+ } else {
+ wsResult += L"+";
+ }
+ CFX_WideString wsTimezone;
+ wsTimezone.Format(L"%02d:%02d", FXSYS_abs(tz.tzHour), tz.tzMinute);
+ wsResult += wsTimezone;
+ }
+ }
+ }
+ return bRet;
+}
+
+bool FormatDateTimeInternal(const CFX_Unitime& dt,
+ const CFX_WideString& wsDatePattern,
+ const CFX_WideString& wsTimePattern,
+ bool bDateFirst,
+ IFX_Locale* pLocale,
+ CFX_WideString& wsOutput) {
+ bool bRet = true;
+ CFX_WideString wsDateOut, wsTimeOut;
+ if (!wsDatePattern.IsEmpty())
+ bRet &= DateFormat(wsDatePattern, pLocale, dt, wsDateOut);
+ if (!wsTimePattern.IsEmpty())
+ bRet &= TimeFormat(wsTimePattern, pLocale, dt, wsTimeOut);
+
+ wsOutput = bDateFirst ? wsDateOut + wsTimeOut : wsTimeOut + wsDateOut;
+ return bRet;
+}
+
+} // namespace
+
+bool FX_DateFromCanonical(const CFX_WideString& wsDate, CFX_Unitime& datetime) {
+ int32_t year = 1900;
+ int32_t month = 1;
+ int32_t day = 1;
+ uint16_t wYear = 0;
+ int cc_start = 0, cc = 0;
+ const wchar_t* str = wsDate.c_str();
+ int len = wsDate.GetLength();
+ if (len > 10) {
+ return false;
+ }
+ while (cc < len && cc < 4) {
+ if (!FXSYS_isDecimalDigit(str[cc])) {
+ return false;
+ }
+ wYear = wYear * 10 + str[cc++] - '0';
+ }
+ year = wYear;
+ if (cc < 4 || wYear < 1900) {
+ return false;
+ }
+ if (cc < len) {
+ if (str[cc] == '-') {
+ cc++;
+ }
+ cc_start = cc;
+ uint8_t tmpM = 0;
+ while (cc < len && cc < cc_start + 2) {
+ if (!FXSYS_isDecimalDigit(str[cc])) {
+ return false;
+ }
+ tmpM = tmpM * 10 + str[cc++] - '0';
+ }
+ month = tmpM;
+ if (cc == cc_start + 1 || tmpM > 12 || tmpM < 1) {
+ return false;
+ }
+ if (cc < len) {
+ if (str[cc] == '-') {
+ cc++;
+ }
+ uint8_t tmpD = 0;
+ cc_start = cc;
+ while (cc < len && cc < cc_start + 2) {
+ if (!FXSYS_isDecimalDigit(str[cc])) {
+ return false;
+ }
+ tmpD = tmpD * 10 + str[cc++] - '0';
+ }
+ day = tmpD;
+ if (tmpD < 1) {
+ return false;
+ }
+ if ((tmpM == 1 || tmpM == 3 || tmpM == 5 || tmpM == 7 || tmpM == 8 ||
+ tmpM == 10 || tmpM == 12) &&
+ tmpD > 31) {
+ return false;
+ }
+ if ((tmpM == 4 || tmpM == 6 || tmpM == 9 || tmpM == 11) && tmpD > 30) {
+ return false;
+ }
+ bool iLeapYear;
+ if ((wYear % 4 == 0 && wYear % 100 != 0) || wYear % 400 == 0) {
+ iLeapYear = true;
+ } else {
+ iLeapYear = false;
+ }
+ if ((iLeapYear && tmpM == 2 && tmpD > 29) ||
+ (!iLeapYear && tmpM == 2 && tmpD > 28)) {
+ return false;
+ }
+ }
+ }
+ CFX_Unitime ut;
+ ut.Set(year, month, day);
+ datetime = datetime + ut;
+ return true;
+}
+
+bool FX_TimeFromCanonical(const CFX_WideStringC& wsTime,
+ CFX_Unitime& datetime,
+ IFX_Locale* pLocale) {
+ if (wsTime.GetLength() == 0) {
+ return false;
+ }
+ uint8_t hour = 0;
+ uint8_t minute = 0;
+ uint8_t second = 0;
+ uint16_t millisecond = 0;
+ int cc_start = 0, cc = cc_start;
+ const wchar_t* str = wsTime.c_str();
+ int len = wsTime.GetLength();
+ while (cc < len && cc < 2) {
+ if (!FXSYS_isDecimalDigit(str[cc])) {
+ return false;
+ }
+ hour = hour * 10 + str[cc++] - '0';
+ }
+ if (cc < 2 || hour >= 24) {
+ return false;
+ }
+ if (cc < len) {
+ if (str[cc] == ':') {
+ cc++;
+ }
+ cc_start = cc;
+ while (cc < len && cc < cc_start + 2) {
+ if (!FXSYS_isDecimalDigit(str[cc])) {
+ return false;
+ }
+ minute = minute * 10 + str[cc++] - '0';
+ }
+ if (cc == cc_start + 1 || minute >= 60) {
+ return false;
+ }
+ if (cc < len) {
+ if (str[cc] == ':') {
+ cc++;
+ }
+ cc_start = cc;
+ while (cc < len && cc < cc_start + 2) {
+ if (!FXSYS_isDecimalDigit(str[cc])) {
+ return false;
+ }
+ second = second * 10 + str[cc++] - '0';
+ }
+ if (cc == cc_start + 1 || second >= 60) {
+ return false;
+ }
+ if (cc < len) {
+ if (str[cc] == '.') {
+ cc++;
+ cc_start = cc;
+ while (cc < len && cc < cc_start + 3) {
+ if (!FXSYS_isDecimalDigit(str[cc])) {
+ return false;
+ }
+ millisecond = millisecond * 10 + str[cc++] - '0';
+ }
+ if (cc < cc_start + 3)
+ return false;
+ }
+ if (cc < len) {
+ FX_TIMEZONE tzDiff;
+ tzDiff.tzHour = 0;
+ tzDiff.tzMinute = 0;
+ if (str[cc] != 'Z') {
+ cc += ParseTimeZone(str + cc, len - cc, tzDiff);
+ }
+ ResolveZone(hour, minute, tzDiff, pLocale);
+ }
+ }
+ }
+ }
+ CFX_Unitime ut;
+ ut.Set(0, 0, 0, hour, minute, second, millisecond);
+ datetime = datetime + ut;
+ return true;
+}
+
+CFX_FormatString::CFX_FormatString(CXFA_LocaleMgr* pLocaleMgr)
+ : m_pLocaleMgr(pLocaleMgr) {}
+
+CFX_FormatString::~CFX_FormatString() {}
+
+void CFX_FormatString::SplitFormatString(
+ const CFX_WideString& wsFormatString,
+ std::vector<CFX_WideString>& wsPatterns) {
+ int32_t iStrLen = wsFormatString.GetLength();
+ const wchar_t* pStr = wsFormatString.c_str();
+ const wchar_t* pToken = pStr;
+ const wchar_t* pEnd = pStr + iStrLen;
+ bool iQuote = false;
+ while (true) {
+ if (pStr >= pEnd) {
+ wsPatterns.push_back(CFX_WideString(pToken, pStr - pToken));
+ return;
+ }
+ if (*pStr == '\'') {
+ iQuote = !iQuote;
+ } else if (*pStr == L'|' && !iQuote) {
+ wsPatterns.push_back(CFX_WideString(pToken, pStr - pToken));
+ pToken = pStr + 1;
+ }
+ pStr++;
+ }
+}
+
FX_LOCALECATEGORY CFX_FormatString::GetCategory(
const CFX_WideString& wsPattern) {
FX_LOCALECATEGORY eCategory = FX_LOCALECATEGORY_Unknown;
@@ -385,7 +1151,7 @@ FX_LOCALECATEGORY CFX_FormatString::GetCategory(
CFX_WideStringC wsConstChars(gs_wsConstChars);
while (ccf < iLenf) {
if (pStr[ccf] == '\'') {
- FX_GetLiteralText(pStr, ccf, iLenf);
+ GetLiteralText(pStr, ccf, iLenf);
} else if (!bBraceOpen && wsConstChars.Find(pStr[ccf]) == -1) {
CFX_WideString wsCategory(pStr[ccf]);
ccf++;
@@ -432,16 +1198,7 @@ FX_LOCALECATEGORY CFX_FormatString::GetCategory(
}
return eCategory;
}
-static uint16_t FX_WStringToLCID(const wchar_t* pstrLCID) {
- if (!pstrLCID) {
- return 0;
- }
- wchar_t* pEnd;
- return (uint16_t)wcstol((wchar_t*)pstrLCID, &pEnd, 16);
-}
-uint16_t CFX_FormatString::GetLCID(const CFX_WideString& wsPattern) {
- return FX_WStringToLCID(GetLocaleName(wsPattern).c_str());
-}
+
CFX_WideString CFX_FormatString::GetLocaleName(
const CFX_WideString& wsPattern) {
int32_t ccf = 0;
@@ -449,7 +1206,7 @@ CFX_WideString CFX_FormatString::GetLocaleName(
const wchar_t* pStr = wsPattern.c_str();
while (ccf < iLenf) {
if (pStr[ccf] == '\'') {
- FX_GetLiteralText(pStr, ccf, iLenf);
+ GetLiteralText(pStr, ccf, iLenf);
} else if (pStr[ccf] == '(') {
ccf++;
CFX_WideString wsLCID;
@@ -462,6 +1219,7 @@ CFX_WideString CFX_FormatString::GetLocaleName(
}
return CFX_WideString();
}
+
IFX_Locale* CFX_FormatString::GetTextFormat(const CFX_WideString& wsPattern,
const CFX_WideStringC& wsCategory,
CFX_WideString& wsPurgePattern) {
@@ -474,7 +1232,7 @@ IFX_Locale* CFX_FormatString::GetTextFormat(const CFX_WideString& wsPattern,
while (ccf < iLenf) {
if (pStr[ccf] == '\'') {
int32_t iCurChar = ccf;
- FX_GetLiteralText(pStr, ccf, iLenf);
+ GetLiteralText(pStr, ccf, iLenf);
wsPurgePattern += CFX_WideStringC(pStr + iCurChar, ccf - iCurChar + 1);
} else if (!bBrackOpen && wsConstChars.Find(pStr[ccf]) == -1) {
CFX_WideString wsSearchCategory(pStr[ccf]);
@@ -532,7 +1290,7 @@ IFX_Locale* CFX_FormatString::GetNumericFormat(const CFX_WideString& wsPattern,
while (ccf < iLenf) {
if (pStr[ccf] == '\'') {
int32_t iCurChar = ccf;
- FX_GetLiteralText(pStr, ccf, iLenf);
+ GetLiteralText(pStr, ccf, iLenf);
wsPurgePattern += CFX_WideStringC(pStr + iCurChar, ccf - iCurChar + 1);
} else if (!bBrackOpen && wsConstChars.Find(pStr[ccf]) == -1) {
CFX_WideString wsCategory(pStr[ccf]);
@@ -620,30 +1378,7 @@ IFX_Locale* CFX_FormatString::GetNumericFormat(const CFX_WideString& wsPattern,
}
return pLocale;
}
-static bool FX_GetNumericDotIndex(const CFX_WideString& wsNum,
- const CFX_WideString& wsDotSymbol,
- int32_t& iDotIndex) {
- int32_t ccf = 0;
- int32_t iLenf = wsNum.GetLength();
- const wchar_t* pStr = wsNum.c_str();
- int32_t iLenDot = wsDotSymbol.GetLength();
- while (ccf < iLenf) {
- if (pStr[ccf] == '\'') {
- FX_GetLiteralText(pStr, ccf, iLenf);
- } else if (ccf + iLenDot <= iLenf &&
- !FXSYS_wcsncmp(pStr + ccf, wsDotSymbol.c_str(), iLenDot)) {
- iDotIndex = ccf;
- return true;
- }
- ccf++;
- }
- iDotIndex = wsNum.Find('.');
- if (iDotIndex < 0) {
- iDotIndex = iLenf;
- return false;
- }
- return true;
-}
+
bool CFX_FormatString::ParseText(const CFX_WideString& wsSrcText,
const CFX_WideString& wsPattern,
CFX_WideString& wsValue) {
@@ -665,7 +1400,7 @@ bool CFX_FormatString::ParseText(const CFX_WideString& wsSrcText,
switch (pStrPattern[iPattern]) {
case '\'': {
CFX_WideString wsLiteral =
- FX_GetLiteralText(pStrPattern, iPattern, iLenPattern);
+ GetLiteralText(pStrPattern, iPattern, iLenPattern);
int32_t iLiteralLen = wsLiteral.GetLength();
if (iText + iLiteralLen > iLenText ||
FXSYS_wcsncmp(pStrText + iText, wsLiteral.c_str(), iLiteralLen)) {
@@ -716,713 +1451,6 @@ bool CFX_FormatString::ParseText(const CFX_WideString& wsSrcText,
}
return iPattern == iLenPattern && iText == iLenText;
}
-bool CFX_FormatString::ParseNum(const CFX_WideString& wsSrcNum,
- const CFX_WideString& wsPattern,
- float& fValue) {
- fValue = 0.0f;
- if (wsSrcNum.IsEmpty() || wsPattern.IsEmpty()) {
- return false;
- }
- int32_t dot_index_f = -1;
- uint32_t dwFormatStyle = 0;
- CFX_WideString wsNumFormat;
- IFX_Locale* pLocale =
- GetNumericFormat(wsPattern, dot_index_f, dwFormatStyle, wsNumFormat);
- if (!pLocale || wsNumFormat.IsEmpty()) {
- return false;
- }
- int32_t iExponent = 0;
- CFX_WideString wsDotSymbol;
- pLocale->GetNumbericSymbol(FX_LOCALENUMSYMBOL_Decimal, wsDotSymbol);
- CFX_WideString wsGroupSymbol;
- pLocale->GetNumbericSymbol(FX_LOCALENUMSYMBOL_Grouping, wsGroupSymbol);
- int32_t iGroupLen = wsGroupSymbol.GetLength();
- CFX_WideString wsMinus;
- pLocale->GetNumbericSymbol(FX_LOCALENUMSYMBOL_Minus, wsMinus);
- int32_t iMinusLen = wsMinus.GetLength();
- int cc = 0, ccf = 0;
- const wchar_t* str = wsSrcNum.c_str();
- int len = wsSrcNum.GetLength();
- const wchar_t* strf = wsNumFormat.c_str();
- int lenf = wsNumFormat.GetLength();
- double dbRetValue = 0;
- double coeff = 1;
- bool bHavePercentSymbol = false;
- bool bNeg = false;
- bool bReverseParse = false;
- int32_t dot_index = 0;
- if (!FX_GetNumericDotIndex(wsSrcNum, wsDotSymbol, dot_index) &&
- (dwFormatStyle & FX_NUMSTYLE_DotVorv)) {
- bReverseParse = true;
- }
- bReverseParse = false;
- if (bReverseParse) {
- ccf = lenf - 1;
- cc = len - 1;
- while (ccf > dot_index_f && cc >= 0) {
- switch (strf[ccf]) {
- case '\'': {
- CFX_WideString wsLiteral = FX_GetLiteralTextReverse(strf, ccf);
- int32_t iLiteralLen = wsLiteral.GetLength();
- cc -= iLiteralLen - 1;
- if (cc < 0 ||
- FXSYS_wcsncmp(str + cc, wsLiteral.c_str(), iLiteralLen)) {
- return false;
- }
- cc--;
- ccf--;
- break;
- }
- case '9':
- if (!FXSYS_isDecimalDigit(str[cc])) {
- return false;
- }
- dbRetValue = dbRetValue * coeff + (str[cc] - '0') * 0.1;
- coeff *= 0.1;
- cc--;
- ccf--;
- break;
- case 'z':
- if (cc >= 0) {
- dbRetValue = dbRetValue * coeff + (str[cc] - '0') * 0.1;
- coeff *= 0.1;
- cc--;
- }
- ccf--;
- break;
- case 'Z':
- if (str[cc] != ' ') {
- dbRetValue = dbRetValue * coeff + (str[cc] - '0') * 0.1;
- coeff *= 0.1;
- }
- cc--;
- ccf--;
- break;
- case 'S':
- if (str[cc] == '+' || str[cc] == ' ') {
- cc--;
- } else {
- cc -= iMinusLen - 1;
- if (cc < 0 || FXSYS_wcsncmp(str + cc, wsMinus.c_str(), iMinusLen)) {
- return false;
- }
- cc--;
- bNeg = true;
- }
- ccf--;
- break;
- case 's':
- if (str[cc] == '+') {
- cc--;
- } else {
- cc -= iMinusLen - 1;
- if (cc < 0 || FXSYS_wcsncmp(str + cc, wsMinus.c_str(), iMinusLen)) {
- return false;
- }
- cc--;
- bNeg = true;
- }
- ccf--;
- break;
- case 'E': {
- if (cc >= dot_index) {
- return false;
- }
- bool bExpSign = false;
- while (cc >= 0) {
- if (str[cc] == 'E' || str[cc] == 'e') {
- break;
- }
- if (FXSYS_isDecimalDigit(str[cc])) {
- iExponent = iExponent + (str[cc] - '0') * 10;
- cc--;
- continue;
- } else if (str[cc] == '+') {
- cc--;
- continue;
- } else if (cc - iMinusLen + 1 > 0 &&
- !FXSYS_wcsncmp(str + (cc - iMinusLen + 1),
- wsMinus.c_str(), iMinusLen)) {
- bExpSign = true;
- cc -= iMinusLen;
- } else {
- return false;
- }
- }
- cc--;
- iExponent = bExpSign ? -iExponent : iExponent;
- ccf--;
- } break;
- case '$': {
- CFX_WideString wsSymbol;
- pLocale->GetNumbericSymbol(FX_LOCALENUMSYMBOL_CurrencySymbol,
- wsSymbol);
- int32_t iSymbolLen = wsSymbol.GetLength();
- cc -= iSymbolLen - 1;
- if (cc < 0 || FXSYS_wcsncmp(str + cc, wsSymbol.c_str(), iSymbolLen)) {
- return false;
- }
- cc--;
- ccf--;
- } break;
- case 'r':
- if (ccf - 1 >= 0 && strf[ccf - 1] == 'c') {
- if (str[cc] == 'R' && cc - 1 >= 0 && str[cc - 1] == 'C') {
- bNeg = true;
- cc -= 2;
- }
- ccf -= 2;
- } else {
- ccf--;
- }
- break;
- case 'R':
- if (ccf - 1 >= 0 && strf[ccf - 1] == 'C') {
- if (str[cc] == ' ') {
- cc++;
- } else if (str[cc] == 'R' && cc - 1 >= 0 && str[cc - 1] == 'C') {
- bNeg = true;
- cc -= 2;
- }
- ccf -= 2;
- } else {
- ccf--;
- }
- break;
- case 'b':
- if (ccf - 1 >= 0 && strf[ccf - 1] == 'd') {
- if (str[cc] == 'B' && cc - 1 >= 0 && str[cc - 1] == 'D') {
- bNeg = true;
- cc -= 2;
- }
- ccf -= 2;
- } else {
- ccf--;
- }
- break;
- case 'B':
- if (ccf - 1 >= 0 && strf[ccf - 1] == 'D') {
- if (str[cc] == ' ') {
- cc++;
- } else if (str[cc] == 'B' && cc - 1 >= 0 && str[cc - 1] == 'D') {
- bNeg = true;
- cc -= 2;
- }
- ccf -= 2;
- } else {
- ccf--;
- }
- break;
- case '.':
- case 'V':
- case 'v':
- return false;
- case '%': {
- CFX_WideString wsSymbol;
- pLocale->GetNumbericSymbol(FX_LOCALENUMSYMBOL_Percent, wsSymbol);
- int32_t iSysmbolLen = wsSymbol.GetLength();
- cc -= iSysmbolLen - 1;
- if (cc < 0 ||
- FXSYS_wcsncmp(str + cc, wsSymbol.c_str(), iSysmbolLen)) {
- return false;
- }
- cc--;
- ccf--;
- bHavePercentSymbol = true;
- } break;
- case '8':
- while (ccf < lenf && strf[ccf] == '8') {
- ccf++;
- }
- while (cc < len && FXSYS_isDecimalDigit(str[cc])) {
- dbRetValue = (str[cc] - '0') * coeff + dbRetValue;
- coeff *= 0.1;
- cc++;
- }
- break;
- case ',': {
- if (cc >= 0) {
- cc -= iGroupLen - 1;
- if (cc >= 0 &&
- FXSYS_wcsncmp(str + cc, wsGroupSymbol.c_str(), iGroupLen) ==
- 0) {
- cc--;
- } else {
- cc += iGroupLen - 1;
- }
- }
- ccf--;
- } break;
- case '(':
- if (str[cc] == L'(') {
- bNeg = true;
- } else if (str[cc] != L' ') {
- return false;
- }
- cc--;
- ccf--;
- break;
- case ')':
- if (str[cc] == L')') {
- bNeg = true;
- } else if (str[cc] != L' ') {
- return false;
- }
- cc--;
- ccf--;
- break;
- default:
- if (strf[ccf] != str[cc]) {
- return false;
- }
- cc--;
- ccf--;
- }
- }
- dot_index = cc + 1;
- }
- ccf = dot_index_f - 1;
- cc = dot_index - 1;
- coeff = 1;
- while (ccf >= 0 && cc >= 0) {
- switch (strf[ccf]) {
- case '\'': {
- CFX_WideString wsLiteral = FX_GetLiteralTextReverse(strf, ccf);
- int32_t iLiteralLen = wsLiteral.GetLength();
- cc -= iLiteralLen - 1;
- if (cc < 0 || FXSYS_wcsncmp(str + cc, wsLiteral.c_str(), iLiteralLen)) {
- return false;
- }
- cc--;
- ccf--;
- break;
- }
- case '9':
- if (!FXSYS_isDecimalDigit(str[cc])) {
- return false;
- }
- dbRetValue = dbRetValue + (str[cc] - '0') * coeff;
- coeff *= 10;
- cc--;
- ccf--;
- break;
- case 'z':
- if (FXSYS_isDecimalDigit(str[cc])) {
- dbRetValue = dbRetValue + (str[cc] - '0') * coeff;
- coeff *= 10;
- cc--;
- }
- ccf--;
- break;
- case 'Z':
- if (str[cc] != ' ') {
- if (FXSYS_isDecimalDigit(str[cc])) {
- dbRetValue = dbRetValue + (str[cc] - '0') * coeff;
- coeff *= 10;
- cc--;
- }
- } else {
- cc--;
- }
- ccf--;
- break;
- case 'S':
- if (str[cc] == '+' || str[cc] == ' ') {
- cc--;
- } else {
- cc -= iMinusLen - 1;
- if (cc < 0 || FXSYS_wcsncmp(str + cc, wsMinus.c_str(), iMinusLen)) {
- return false;
- }
- cc--;
- bNeg = true;
- }
- ccf--;
- break;
- case 's':
- if (str[cc] == '+') {
- cc--;
- } else {
- cc -= iMinusLen - 1;
- if (cc < 0 || FXSYS_wcsncmp(str + cc, wsMinus.c_str(), iMinusLen)) {
- return false;
- }
- cc--;
- bNeg = true;
- }
- ccf--;
- break;
- case 'E': {
- if (cc >= dot_index) {
- return false;
- }
- bool bExpSign = false;
- while (cc >= 0) {
- if (str[cc] == 'E' || str[cc] == 'e') {
- break;
- }
- if (FXSYS_isDecimalDigit(str[cc])) {
- iExponent = iExponent + (str[cc] - '0') * 10;
- cc--;
- continue;
- } else if (str[cc] == '+') {
- cc--;
- continue;
- } else if (cc - iMinusLen + 1 > 0 &&
- !FXSYS_wcsncmp(str + (cc - iMinusLen + 1), wsMinus.c_str(),
- iMinusLen)) {
- bExpSign = true;
- cc -= iMinusLen;
- } else {
- return false;
- }
- }
- cc--;
- iExponent = bExpSign ? -iExponent : iExponent;
- ccf--;
- } break;
- case '$': {
- CFX_WideString wsSymbol;
- pLocale->GetNumbericSymbol(FX_LOCALENUMSYMBOL_CurrencySymbol, wsSymbol);
- int32_t iSymbolLen = wsSymbol.GetLength();
- cc -= iSymbolLen - 1;
- if (cc < 0 || FXSYS_wcsncmp(str + cc, wsSymbol.c_str(), iSymbolLen)) {
- return false;
- }
- cc--;
- ccf--;
- } break;
- case 'r':
- if (ccf - 1 >= 0 && strf[ccf - 1] == 'c') {
- if (str[cc] == 'R' && cc - 1 >= 0 && str[cc - 1] == 'C') {
- bNeg = true;
- cc -= 2;
- }
- ccf -= 2;
- } else {
- ccf--;
- }
- break;
- case 'R':
- if (ccf - 1 >= 0 && strf[ccf - 1] == 'C') {
- if (str[cc] == ' ') {
- cc++;
- } else if (str[cc] == 'R' && cc - 1 >= 0 && str[cc - 1] == 'C') {
- bNeg = true;
- cc -= 2;
- }
- ccf -= 2;
- } else {
- ccf--;
- }
- break;
- case 'b':
- if (ccf - 1 >= 0 && strf[ccf - 1] == 'd') {
- if (str[cc] == 'B' && cc - 1 >= 0 && str[cc - 1] == 'D') {
- bNeg = true;
- cc -= 2;
- }
- ccf -= 2;
- } else {
- ccf--;
- }
- break;
- case 'B':
- if (ccf - 1 >= 0 && strf[ccf - 1] == 'D') {
- if (str[cc] == ' ') {
- cc++;
- } else if (str[cc] == 'B' && cc - 1 >= 0 && str[cc - 1] == 'D') {
- bNeg = true;
- cc -= 2;
- }
- ccf -= 2;
- } else {
- ccf--;
- }
- break;
- case '.':
- case 'V':
- case 'v':
- return false;
- case '%': {
- CFX_WideString wsSymbol;
- pLocale->GetNumbericSymbol(FX_LOCALENUMSYMBOL_Percent, wsSymbol);
- int32_t iSysmbolLen = wsSymbol.GetLength();
- cc -= iSysmbolLen - 1;
- if (cc < 0 || FXSYS_wcsncmp(str + cc, wsSymbol.c_str(), iSysmbolLen)) {
- return false;
- }
- cc--;
- ccf--;
- bHavePercentSymbol = true;
- } break;
- case '8':
- return false;
- case ',': {
- if (cc >= 0) {
- cc -= iGroupLen - 1;
- if (cc >= 0 &&
- FXSYS_wcsncmp(str + cc, wsGroupSymbol.c_str(), iGroupLen) == 0) {
- cc--;
- } else {
- cc += iGroupLen - 1;
- }
- }
- ccf--;
- } break;
- case '(':
- if (str[cc] == L'(') {
- bNeg = true;
- } else if (str[cc] != L' ') {
- return false;
- }
- cc--;
- ccf--;
- break;
- case ')':
- if (str[cc] == L')') {
- bNeg = true;
- } else if (str[cc] != L' ') {
- return false;
- }
- cc--;
- ccf--;
- break;
- default:
- if (strf[ccf] != str[cc]) {
- return false;
- }
- cc--;
- ccf--;
- }
- }
- if (cc >= 0) {
- return false;
- }
- if (!bReverseParse) {
- ccf = dot_index_f + 1;
- cc = (dot_index == len) ? len : dot_index + 1;
- coeff = 0.1;
- while (cc < len && ccf < lenf) {
- switch (strf[ccf]) {
- case '\'': {
- CFX_WideString wsLiteral = FX_GetLiteralText(strf, ccf, lenf);
- int32_t iLiteralLen = wsLiteral.GetLength();
- if (cc + iLiteralLen > len ||
- FXSYS_wcsncmp(str + cc, wsLiteral.c_str(), iLiteralLen)) {
- return false;
- }
- cc += iLiteralLen;
- ccf++;
- break;
- }
- case '9':
- if (!FXSYS_isDecimalDigit(str[cc])) {
- return false;
- }
- {
- dbRetValue = dbRetValue + (str[cc] - '0') * coeff;
- coeff *= 0.1;
- }
- cc++;
- ccf++;
- break;
- case 'z':
- if (FXSYS_isDecimalDigit(str[cc])) {
- dbRetValue = dbRetValue + (str[cc] - '0') * coeff;
- coeff *= 0.1;
- cc++;
- }
- ccf++;
- break;
- case 'Z':
- if (str[cc] != ' ') {
- if (FXSYS_isDecimalDigit(str[cc])) {
- dbRetValue = dbRetValue + (str[cc] - '0') * coeff;
- coeff *= 0.1;
- cc++;
- }
- } else {
- cc++;
- }
- ccf++;
- break;
- case 'S':
- if (str[cc] == '+' || str[cc] == ' ') {
- cc++;
- } else {
- if (cc + iMinusLen > len ||
- FXSYS_wcsncmp(str + cc, wsMinus.c_str(), iMinusLen)) {
- return false;
- }
- bNeg = true;
- cc += iMinusLen;
- }
- ccf++;
- break;
- case 's':
- if (str[cc] == '+') {
- cc++;
- } else {
- if (cc + iMinusLen > len ||
- FXSYS_wcsncmp(str + cc, wsMinus.c_str(), iMinusLen)) {
- return false;
- }
- bNeg = true;
- cc += iMinusLen;
- }
- ccf++;
- break;
- case 'E': {
- if (cc >= len || (str[cc] != 'E' && str[cc] != 'e')) {
- return false;
- }
- bool bExpSign = false;
- cc++;
- if (cc < len) {
- if (str[cc] == '+') {
- cc++;
- } else if (str[cc] == '-') {
- bExpSign = true;
- cc++;
- }
- }
- while (cc < len) {
- if (!FXSYS_isDecimalDigit(str[cc])) {
- break;
- }
- iExponent = iExponent * 10 + str[cc] - '0';
- cc++;
- }
- iExponent = bExpSign ? -iExponent : iExponent;
- ccf++;
- } break;
- case '$': {
- CFX_WideString wsSymbol;
- pLocale->GetNumbericSymbol(FX_LOCALENUMSYMBOL_CurrencySymbol,
- wsSymbol);
- int32_t iSymbolLen = wsSymbol.GetLength();
- if (cc + iSymbolLen > len ||
- FXSYS_wcsncmp(str + cc, wsSymbol.c_str(), iSymbolLen)) {
- return false;
- }
- cc += iSymbolLen;
- ccf++;
- } break;
- case 'c':
- if (ccf + 1 < lenf && strf[ccf + 1] == 'r') {
- if (str[cc] == 'C' && cc + 1 < len && str[cc + 1] == 'R') {
- bNeg = true;
- cc += 2;
- }
- ccf += 2;
- }
- break;
- case 'C':
- if (ccf + 1 < lenf && strf[ccf + 1] == 'R') {
- if (str[cc] == ' ') {
- cc++;
- } else if (str[cc] == 'C' && cc + 1 < len && str[cc + 1] == 'R') {
- bNeg = true;
- cc += 2;
- }
- ccf += 2;
- }
- break;
- case 'd':
- if (ccf + 1 < lenf && strf[ccf + 1] == 'b') {
- if (str[cc] == 'D' && cc + 1 < len && str[cc + 1] == 'B') {
- bNeg = true;
- cc += 2;
- }
- ccf += 2;
- }
- break;
- case 'D':
- if (ccf + 1 < lenf && strf[ccf + 1] == 'B') {
- if (str[cc] == ' ') {
- cc++;
- } else if (str[cc] == 'D' && cc + 1 < len && str[cc + 1] == 'B') {
- bNeg = true;
- cc += 2;
- }
- ccf += 2;
- }
- break;
- case '.':
- case 'V':
- case 'v':
- return false;
- case '%': {
- CFX_WideString wsSymbol;
- pLocale->GetNumbericSymbol(FX_LOCALENUMSYMBOL_Percent, wsSymbol);
- int32_t iSysmbolLen = wsSymbol.GetLength();
- if (cc + iSysmbolLen <= len &&
- !FXSYS_wcsncmp(str + cc, wsSymbol.c_str(), iSysmbolLen)) {
- cc += iSysmbolLen;
- }
- ccf++;
- bHavePercentSymbol = true;
- } break;
- case '8': {
- while (ccf < lenf && strf[ccf] == '8') {
- ccf++;
- }
- while (cc < len && FXSYS_isDecimalDigit(str[cc])) {
- dbRetValue = (str[cc] - '0') * coeff + dbRetValue;
- coeff *= 0.1;
- cc++;
- }
- } break;
- case ',': {
- if (cc + iGroupLen <= len &&
- FXSYS_wcsncmp(str + cc, wsGroupSymbol.c_str(), iGroupLen) == 0) {
- cc += iGroupLen;
- }
- ccf++;
- } break;
- case '(':
- if (str[cc] == L'(') {
- bNeg = true;
- } else if (str[cc] != L' ') {
- return false;
- }
- cc++;
- ccf++;
- break;
- case ')':
- if (str[cc] == L')') {
- bNeg = true;
- } else if (str[cc] != L' ') {
- return false;
- }
- cc++;
- ccf++;
- break;
- default:
- if (strf[ccf] != str[cc]) {
- return false;
- }
- cc++;
- ccf++;
- }
- }
- if (cc != len) {
- return false;
- }
- }
- if (iExponent) {
- dbRetValue *= FXSYS_pow(10, (float)iExponent);
- }
- if (bHavePercentSymbol) {
- dbRetValue /= 100.0;
- }
- if (bNeg) {
- dbRetValue = -dbRetValue;
- }
- fValue = (float)dbRetValue;
- return true;
-}
bool CFX_FormatString::ParseNum(const CFX_WideString& wsSrcNum,
const CFX_WideString& wsPattern,
@@ -1457,7 +1485,7 @@ bool CFX_FormatString::ParseNum(const CFX_WideString& wsSrcNum,
bool bNeg = false;
bool bReverseParse = false;
int32_t dot_index = 0;
- if (!FX_GetNumericDotIndex(wsSrcNum, wsDotSymbol, dot_index) &&
+ if (!GetNumericDotIndex(wsSrcNum, wsDotSymbol, dot_index) &&
(dwFormatStyle & FX_NUMSTYLE_DotVorv)) {
bReverseParse = true;
}
@@ -1467,7 +1495,7 @@ bool CFX_FormatString::ParseNum(const CFX_WideString& wsSrcNum,
while (ccf >= 0 && cc >= 0) {
switch (strf[ccf]) {
case '\'': {
- CFX_WideString wsLiteral = FX_GetLiteralTextReverse(strf, ccf);
+ CFX_WideString wsLiteral = GetLiteralTextReverse(strf, ccf);
int32_t iLiteralLen = wsLiteral.GetLength();
cc -= iLiteralLen - 1;
if (cc < 0 || FXSYS_wcsncmp(str + cc, wsLiteral.c_str(), iLiteralLen)) {
@@ -1691,7 +1719,7 @@ bool CFX_FormatString::ParseNum(const CFX_WideString& wsSrcNum,
while (cc < len && ccf < lenf) {
switch (strf[ccf]) {
case '\'': {
- CFX_WideString wsLiteral = FX_GetLiteralText(strf, ccf, lenf);
+ CFX_WideString wsLiteral = GetLiteralText(strf, ccf, lenf);
int32_t iLiteralLen = wsLiteral.GetLength();
if (cc + iLiteralLen > len ||
FXSYS_wcsncmp(str + cc, wsLiteral.c_str(), iLiteralLen)) {
@@ -1893,7 +1921,8 @@ bool CFX_FormatString::ParseNum(const CFX_WideString& wsSrcNum,
if (iExponent || bHavePercentSymbol) {
CFX_Decimal decimal = CFX_Decimal(wsValue.AsStringC());
if (iExponent) {
- decimal = decimal * CFX_Decimal(FXSYS_pow(10, (float)iExponent));
+ decimal = decimal *
+ CFX_Decimal(FXSYS_pow(10, static_cast<float>(iExponent)), 3);
}
if (bHavePercentSymbol) {
decimal = decimal / CFX_Decimal(100);
@@ -1905,6 +1934,7 @@ bool CFX_FormatString::ParseNum(const CFX_WideString& wsSrcNum,
}
return true;
}
+
FX_DATETIMETYPE CFX_FormatString::GetDateTimeFormat(
const CFX_WideString& wsPattern,
IFX_Locale*& pLocale,
@@ -1922,7 +1952,7 @@ FX_DATETIMETYPE CFX_FormatString::GetDateTimeFormat(
while (ccf < iLenf) {
if (pStr[ccf] == '\'') {
int32_t iCurChar = ccf;
- FX_GetLiteralText(pStr, ccf, iLenf);
+ GetLiteralText(pStr, ccf, iLenf);
wsTempPattern += CFX_WideStringC(pStr + iCurChar, ccf - iCurChar + 1);
} else if (!bBraceOpen && iFindCategory != 3 &&
wsConstChars.Find(pStr[ccf]) == -1) {
@@ -2043,419 +2073,6 @@ FX_DATETIMETYPE CFX_FormatString::GetDateTimeFormat(
}
return (FX_DATETIMETYPE)iFindCategory;
}
-static bool FX_ParseLocaleDate(const CFX_WideString& wsDate,
- const CFX_WideString& wsDatePattern,
- IFX_Locale* pLocale,
- CFX_Unitime& datetime,
- int32_t& cc) {
- int32_t year = 1900;
- int32_t month = 1;
- int32_t day = 1;
- int32_t ccf = 0;
- const wchar_t* str = wsDate.c_str();
- int32_t len = wsDate.GetLength();
- const wchar_t* strf = wsDatePattern.c_str();
- int32_t lenf = wsDatePattern.GetLength();
- CFX_WideStringC wsDateSymbols(gs_wsDateSymbols);
- while (cc < len && ccf < lenf) {
- if (strf[ccf] == '\'') {
- CFX_WideString wsLiteral = FX_GetLiteralText(strf, ccf, lenf);
- int32_t iLiteralLen = wsLiteral.GetLength();
- if (cc + iLiteralLen > len ||
- FXSYS_wcsncmp(str + cc, wsLiteral.c_str(), iLiteralLen)) {
- return false;
- }
- cc += iLiteralLen;
- ccf++;
- continue;
- } else if (wsDateSymbols.Find(strf[ccf]) == -1) {
- if (strf[ccf] != str[cc])
- return false;
- cc++;
- ccf++;
- continue;
- }
- uint32_t dwSymbolNum = 1;
- wchar_t dwCharSymbol = strf[ccf++];
- while (ccf < lenf && strf[ccf] == dwCharSymbol) {
- ccf++;
- dwSymbolNum++;
- }
- uint32_t dwSymbol = (dwCharSymbol << 8) | (dwSymbolNum + '0');
- if (dwSymbol == FXBSTR_ID(0, 0, 'D', '1')) {
- if (!FXSYS_isDecimalDigit(str[cc])) {
- return false;
- }
- day = str[cc++] - '0';
- if (cc < len && FXSYS_isDecimalDigit(str[cc])) {
- day = day * 10 + str[cc++] - '0';
- }
- } else if (dwSymbol == FXBSTR_ID(0, 0, 'D', '2')) {
- if (!FXSYS_isDecimalDigit(str[cc])) {
- return false;
- }
- day = str[cc++] - '0';
- if (cc < len) {
- day = day * 10 + str[cc++] - '0';
- }
- } else if (dwSymbol == FXBSTR_ID(0, 0, 'J', '1')) {
- int i = 0;
- while (cc < len && i < 3 && FXSYS_isDecimalDigit(str[cc])) {
- cc++;
- i++;
- }
- } else if (dwSymbol == FXBSTR_ID(0, 0, 'J', '3')) {
- cc += 3;
- } else if (dwSymbol == FXBSTR_ID(0, 0, 'M', '1')) {
- if (!FXSYS_isDecimalDigit(str[cc])) {
- return false;
- }
- month = str[cc++] - '0';
- if (cc < len && FXSYS_isDecimalDigit(str[cc])) {
- month = month * 10 + str[cc++] - '0';
- }
- } else if (dwSymbol == FXBSTR_ID(0, 0, 'M', '2')) {
- if (!FXSYS_isDecimalDigit(str[cc])) {
- return false;
- }
- month = str[cc++] - '0';
- if (cc < len) {
- month = month * 10 + str[cc++] - '0';
- }
- } else if (dwSymbol == FXBSTR_ID(0, 0, 'M', '3')) {
- CFX_WideString wsMonthNameAbbr;
- uint16_t i = 0;
- for (; i < 12; i++) {
- pLocale->GetMonthName(i, wsMonthNameAbbr, true);
- if (wsMonthNameAbbr.IsEmpty()) {
- continue;
- }
- if (!FXSYS_wcsncmp(wsMonthNameAbbr.c_str(), str + cc,
- wsMonthNameAbbr.GetLength())) {
- break;
- }
- }
- if (i < 12) {
- cc += wsMonthNameAbbr.GetLength();
- month = i + 1;
- }
- } else if (dwSymbol == FXBSTR_ID(0, 0, 'M', '4')) {
- CFX_WideString wsMonthName;
- uint16_t i = 0;
- for (; i < 12; i++) {
- pLocale->GetMonthName(i, wsMonthName, false);
- if (wsMonthName.IsEmpty()) {
- continue;
- }
- if (!FXSYS_wcsncmp(wsMonthName.c_str(), str + cc,
- wsMonthName.GetLength())) {
- break;
- }
- }
- if (i < 12) {
- cc += wsMonthName.GetLength();
- month = i + 1;
- }
- } else if (dwSymbol == FXBSTR_ID(0, 0, 'E', '1')) {
- cc += 1;
- } else if (dwSymbol == FXBSTR_ID(0, 0, 'E', '3')) {
- CFX_WideString wsDayNameAbbr;
- uint16_t i = 0;
- for (; i < 7; i++) {
- pLocale->GetDayName(i, wsDayNameAbbr, true);
- if (wsDayNameAbbr.IsEmpty()) {
- continue;
- }
- if (!FXSYS_wcsncmp(wsDayNameAbbr.c_str(), str + cc,
- wsDayNameAbbr.GetLength())) {
- break;
- }
- }
- if (i < 12) {
- cc += wsDayNameAbbr.GetLength();
- }
- } else if (dwSymbol == FXBSTR_ID(0, 0, 'E', '4')) {
- CFX_WideString wsDayName;
- int32_t i = 0;
- for (; i < 7; i++) {
- pLocale->GetDayName(i, wsDayName, false);
- if (wsDayName == L"") {
- continue;
- }
- if (!FXSYS_wcsncmp(wsDayName.c_str(), str + cc,
- wsDayName.GetLength())) {
- break;
- }
- }
- if (i < 12) {
- cc += wsDayName.GetLength();
- }
- } else if (dwSymbol == FXBSTR_ID(0, 0, 'e', '1')) {
- cc += 1;
- } else if (dwSymbol == FXBSTR_ID(0, 0, 'G', '1')) {
- cc += 2;
- } else if (dwSymbol == FXBSTR_ID(0, 0, 'Y', '2')) {
- if (cc + 2 > len) {
- return false;
- }
- if (!FXSYS_isDecimalDigit(str[cc])) {
- return false;
- }
- year = str[cc++] - '0';
- if (cc >= len || !FXSYS_isDecimalDigit(str[cc])) {
- return false;
- }
- year = year * 10 + str[cc++] - '0';
- if (year <= 29) {
- year += 2000;
- } else {
- year += 1900;
- }
- } else if (dwSymbol == FXBSTR_ID(0, 0, 'Y', '4')) {
- int i = 0;
- year = 0;
- if (cc + 4 > len) {
- return false;
- }
- while (i < 4) {
- if (!FXSYS_isDecimalDigit(str[cc])) {
- return false;
- }
- year = year * 10 + str[cc] - '0';
- cc++;
- i++;
- }
- } else if (dwSymbol == FXBSTR_ID(0, 0, 'w', '1')) {
- cc += 1;
- } else if (dwSymbol == FXBSTR_ID(0, 0, 'W', '2')) {
- cc += 2;
- }
- }
- if (cc < len) {
- return false;
- }
- CFX_Unitime ut;
- ut.Set(year, month, day);
- datetime = datetime + ut;
- return !!cc;
-}
-
-static void FX_ResolveZone(uint8_t& wHour,
- uint8_t& wMinute,
- FX_TIMEZONE tzDiff,
- IFX_Locale* pLocale) {
- int32_t iMinuteDiff = wHour * 60 + wMinute;
- FX_TIMEZONE tzLocale;
- pLocale->GetTimeZone(&tzLocale);
- iMinuteDiff += tzLocale.tzHour * 60 +
- (tzLocale.tzHour < 0 ? -tzLocale.tzMinute : tzLocale.tzMinute);
- iMinuteDiff -= tzDiff.tzHour * 60 +
- (tzDiff.tzHour < 0 ? -tzDiff.tzMinute : tzDiff.tzMinute);
- while (iMinuteDiff > 1440) {
- iMinuteDiff -= 1440;
- }
- while (iMinuteDiff < 0) {
- iMinuteDiff += 1440;
- }
- wHour = iMinuteDiff / 60;
- wMinute = iMinuteDiff % 60;
-}
-static bool FX_ParseLocaleTime(const CFX_WideString& wsTime,
- const CFX_WideString& wsTimePattern,
- IFX_Locale* pLocale,
- CFX_Unitime& datetime,
- int32_t& cc) {
- uint8_t hour = 0;
- uint8_t minute = 0;
- uint8_t second = 0;
- uint16_t millisecond = 0;
- int32_t ccf = 0;
- const wchar_t* str = wsTime.c_str();
- int len = wsTime.GetLength();
- const wchar_t* strf = wsTimePattern.c_str();
- int lenf = wsTimePattern.GetLength();
- bool bHasA = false;
- bool bPM = false;
- CFX_WideStringC wsTimeSymbols(gs_wsTimeSymbols);
- while (cc < len && ccf < lenf) {
- if (strf[ccf] == '\'') {
- CFX_WideString wsLiteral = FX_GetLiteralText(strf, ccf, lenf);
- int32_t iLiteralLen = wsLiteral.GetLength();
- if (cc + iLiteralLen > len ||
- FXSYS_wcsncmp(str + cc, wsLiteral.c_str(), iLiteralLen)) {
- return false;
- }
- cc += iLiteralLen;
- ccf++;
- continue;
- } else if (wsTimeSymbols.Find(strf[ccf]) == -1) {
- if (strf[ccf] != str[cc])
- return false;
- cc++;
- ccf++;
- continue;
- }
- uint32_t dwSymbolNum = 1;
- wchar_t dwCharSymbol = strf[ccf++];
- while (ccf < lenf && strf[ccf] == dwCharSymbol) {
- ccf++;
- dwSymbolNum++;
- }
- uint32_t dwSymbol = (dwCharSymbol << 8) | (dwSymbolNum + '0');
- if (dwSymbol == FXBSTR_ID(0, 0, 'k', '1') ||
- dwSymbol == FXBSTR_ID(0, 0, 'H', '1') ||
- dwSymbol == FXBSTR_ID(0, 0, 'h', '1') ||
- dwSymbol == FXBSTR_ID(0, 0, 'K', '1')) {
- if (!FXSYS_isDecimalDigit(str[cc])) {
- return false;
- }
- hour = str[cc++] - '0';
- if (cc < len && FXSYS_isDecimalDigit(str[cc])) {
- hour = hour * 10 + str[cc++] - '0';
- }
- if (dwSymbol == FXBSTR_ID(0, 0, 'K', '1') && hour == 24) {
- hour = 0;
- }
- } else if (dwSymbol == FXBSTR_ID(0, 0, 'k', '2') ||
- dwSymbol == FXBSTR_ID(0, 0, 'H', '2') ||
- dwSymbol == FXBSTR_ID(0, 0, 'h', '2') ||
- dwSymbol == FXBSTR_ID(0, 0, 'K', '2')) {
- if (!FXSYS_isDecimalDigit(str[cc])) {
- return false;
- }
- hour = str[cc++] - '0';
- if (cc >= len) {
- return false;
- }
- if (!FXSYS_isDecimalDigit(str[cc])) {
- return false;
- }
- hour = hour * 10 + str[cc++] - '0';
- if (dwSymbol == FXBSTR_ID(0, 0, 'K', '2') && hour == 24) {
- hour = 0;
- }
- } else if (dwSymbol == FXBSTR_ID(0, 0, 'M', '1')) {
- if (!FXSYS_isDecimalDigit(str[cc])) {
- return false;
- }
- minute = str[cc++] - '0';
- if (cc < len && FXSYS_isDecimalDigit(str[cc])) {
- minute = minute * 10 + str[cc++] - '0';
- }
- } else if (dwSymbol == FXBSTR_ID(0, 0, 'M', '2')) {
- if (!FXSYS_isDecimalDigit(str[cc])) {
- return false;
- }
- minute = str[cc++] - '0';
- if (cc >= len) {
- return false;
- }
- if (!FXSYS_isDecimalDigit(str[cc])) {
- return false;
- }
- minute = minute * 10 + str[cc++] - '0';
- } else if (dwSymbol == FXBSTR_ID(0, 0, 'S', '1')) {
- if (!FXSYS_isDecimalDigit(str[cc])) {
- return false;
- }
- second = str[cc++] - '0';
- if (cc < len && FXSYS_isDecimalDigit(str[cc])) {
- second = second * 10 + str[cc++] - '0';
- }
- } else if (dwSymbol == FXBSTR_ID(0, 0, 'S', '2')) {
- if (!FXSYS_isDecimalDigit(str[cc])) {
- return false;
- }
- second = str[cc++] - '0';
- if (cc >= len) {
- return false;
- }
- if (!FXSYS_isDecimalDigit(str[cc])) {
- return false;
- }
- second = second * 10 + str[cc++] - '0';
- } else if (dwSymbol == FXBSTR_ID(0, 0, 'F', '3')) {
- if (cc + 3 >= len) {
- return false;
- }
- int i = 0;
- while (i < 3) {
- if (!FXSYS_isDecimalDigit(str[cc])) {
- return false;
- }
- millisecond = millisecond * 10 + str[cc++] - '0';
- i++;
- }
- } else if (dwSymbol == FXBSTR_ID(0, 0, 'A', '1')) {
- CFX_WideString wsAM;
- pLocale->GetMeridiemName(wsAM, true);
- CFX_WideString wsPM;
- pLocale->GetMeridiemName(wsPM, false);
- if ((cc + wsAM.GetLength() <= len) &&
- (CFX_WideStringC(str + cc, wsAM.GetLength()) == wsAM)) {
- cc += wsAM.GetLength();
- bHasA = true;
- } else if ((cc + wsPM.GetLength() <= len) &&
- (CFX_WideStringC(str + cc, wsPM.GetLength()) == wsPM)) {
- cc += wsPM.GetLength();
- bHasA = true;
- bPM = true;
- }
- } else if (dwSymbol == FXBSTR_ID(0, 0, 'Z', '1')) {
- if (cc + 3 > len) {
- continue;
- }
- uint32_t dwHash = str[cc++];
- dwHash = (dwHash << 8) | str[cc++];
- dwHash = (dwHash << 8) | str[cc++];
- if (dwHash == FXBSTR_ID(0, 'G', 'M', 'T')) {
- FX_TIMEZONE tzDiff;
- tzDiff.tzHour = 0;
- tzDiff.tzMinute = 0;
- if (cc < len && (str[cc] == '-' || str[cc] == '+')) {
- cc += FX_ParseTimeZone(str + cc, len - cc, tzDiff);
- }
- FX_ResolveZone(hour, minute, tzDiff, pLocale);
- } else {
- const FX_LOCALETIMEZONEINFO* pEnd =
- g_FXLocaleTimeZoneData + FX_ArraySize(g_FXLocaleTimeZoneData);
- const FX_LOCALETIMEZONEINFO* pTimeZoneInfo =
- std::lower_bound(g_FXLocaleTimeZoneData, pEnd, dwHash,
- [](const FX_LOCALETIMEZONEINFO& info,
- uint32_t hash) { return info.uHash < hash; });
- if (pTimeZoneInfo < pEnd && dwHash == pTimeZoneInfo->uHash) {
- hour += pTimeZoneInfo->iHour;
- minute += pTimeZoneInfo->iHour > 0 ? pTimeZoneInfo->iMinute
- : -pTimeZoneInfo->iMinute;
- }
- }
- } else if (dwSymbol == FXBSTR_ID(0, 0, 'z', '1')) {
- if (str[cc] != 'Z') {
- FX_TIMEZONE tzDiff;
- cc += FX_ParseTimeZone(str + cc, len - cc, tzDiff);
- FX_ResolveZone(hour, minute, tzDiff, pLocale);
- } else {
- cc++;
- }
- }
- }
- if (bHasA) {
- if (bPM) {
- hour += 12;
- if (hour == 24) {
- hour = 12;
- }
- } else {
- if (hour == 12) {
- hour = 0;
- }
- }
- }
- CFX_Unitime ut;
- ut.Set(0, 0, 0, hour, minute, second, millisecond);
- datetime = datetime + ut;
- return !!cc;
-}
bool CFX_FormatString::ParseDateTime(const CFX_WideString& wsSrcDateTime,
const CFX_WideString& wsPattern,
@@ -2480,24 +2097,24 @@ bool CFX_FormatString::ParseDateTime(const CFX_WideString& wsSrcDateTime,
}
if (eCategory == FX_DATETIMETYPE_TimeDate) {
int32_t iStart = 0;
- if (!FX_ParseLocaleTime(wsSrcDateTime, wsTimePattern, pLocale, dtValue,
- iStart)) {
+ if (!ParseLocaleTime(wsSrcDateTime, wsTimePattern, pLocale, dtValue,
+ iStart)) {
return false;
}
- if (!FX_ParseLocaleDate(wsSrcDateTime, wsDatePattern, pLocale, dtValue,
- iStart)) {
+ if (!ParseLocaleDate(wsSrcDateTime, wsDatePattern, pLocale, dtValue,
+ iStart)) {
return false;
}
} else {
int32_t iStart = 0;
if ((eCategory & FX_DATETIMETYPE_Date) &&
- !FX_ParseLocaleDate(wsSrcDateTime, wsDatePattern, pLocale, dtValue,
- iStart)) {
+ !ParseLocaleDate(wsSrcDateTime, wsDatePattern, pLocale, dtValue,
+ iStart)) {
return false;
}
if ((eCategory & FX_DATETIMETYPE_Time) &&
- !FX_ParseLocaleTime(wsSrcDateTime, wsTimePattern, pLocale, dtValue,
- iStart)) {
+ !ParseLocaleTime(wsSrcDateTime, wsTimePattern, pLocale, dtValue,
+ iStart)) {
return false;
}
}
@@ -2515,7 +2132,7 @@ bool CFX_FormatString::ParseZero(const CFX_WideString& wsSrcText,
while (iPattern < iLenPattern && iText < iLenText) {
if (pStrPattern[iPattern] == '\'') {
CFX_WideString wsLiteral =
- FX_GetLiteralText(pStrPattern, iPattern, iLenPattern);
+ GetLiteralText(pStrPattern, iPattern, iLenPattern);
int32_t iLiteralLen = wsLiteral.GetLength();
if (iText + iLiteralLen > iLenText ||
FXSYS_wcsncmp(pStrText + iText, wsLiteral.c_str(), iLiteralLen)) {
@@ -2545,7 +2162,7 @@ bool CFX_FormatString::ParseNull(const CFX_WideString& wsSrcText,
while (iPattern < iLenPattern && iText < iLenText) {
if (pStrPattern[iPattern] == '\'') {
CFX_WideString wsLiteral =
- FX_GetLiteralText(pStrPattern, iPattern, iLenPattern);
+ GetLiteralText(pStrPattern, iPattern, iLenPattern);
int32_t iLiteralLen = wsLiteral.GetLength();
if (iText + iLiteralLen > iLenText ||
FXSYS_wcsncmp(pStrText + iText, wsLiteral.c_str(), iLiteralLen)) {
@@ -2582,7 +2199,7 @@ bool CFX_FormatString::FormatText(const CFX_WideString& wsSrcText,
while (iPattern < iLenPattern) {
switch (pStrPattern[iPattern]) {
case '\'': {
- wsOutput += FX_GetLiteralText(pStrPattern, iPattern, iLenPattern);
+ wsOutput += GetLiteralText(pStrPattern, iPattern, iLenPattern);
iPattern++;
break;
}
@@ -2623,23 +2240,7 @@ bool CFX_FormatString::FormatText(const CFX_WideString& wsSrcText,
}
return iText == iLenText;
}
-static int32_t FX_GetNumTrailingLimit(const CFX_WideString& wsFormat,
- int iDotPos,
- bool& bTrimTailZeros) {
- if (iDotPos < 0) {
- return 0;
- }
- int32_t iCount = wsFormat.GetLength();
- int32_t iTreading = 0;
- for (iDotPos++; iDotPos < iCount; iDotPos++) {
- wchar_t wc = wsFormat[iDotPos];
- if (wc == L'z' || wc == L'9' || wc == 'Z') {
- iTreading++;
- bTrimTailZeros = (wc == L'9' ? false : true);
- }
- }
- return iTreading;
-}
+
bool CFX_FormatString::FormatStrNum(const CFX_WideStringC& wsInputNum,
const CFX_WideString& wsPattern,
CFX_WideString& wsOutput) {
@@ -2673,7 +2274,7 @@ bool CFX_FormatString::FormatStrNum(const CFX_WideStringC& wsInputNum,
while (ccf < dot_index_f) {
switch (strf[ccf]) {
case '\'':
- FX_GetLiteralText(strf, ccf, dot_index_f);
+ GetLiteralText(strf, ccf, dot_index_f);
break;
case '9':
case 'z':
@@ -2707,7 +2308,7 @@ bool CFX_FormatString::FormatStrNum(const CFX_WideStringC& wsInputNum,
}
bool bTrimTailZeros = false;
int32_t iTreading =
- FX_GetNumTrailingLimit(wsNumFormat, dot_index_f, bTrimTailZeros);
+ GetNumTrailingLimit(wsNumFormat, dot_index_f, bTrimTailZeros);
int32_t scale = decimal.GetScale();
if (iTreading < scale) {
decimal.SetScale(iTreading);
@@ -2880,7 +2481,7 @@ bool CFX_FormatString::FormatStrNum(const CFX_WideStringC& wsInputNum,
ccf--;
break;
case '\'':
- wsOutput = FX_GetLiteralTextReverse(strf, ccf) + wsOutput;
+ wsOutput = GetLiteralTextReverse(strf, ccf) + wsOutput;
ccf--;
break;
default:
@@ -2936,7 +2537,7 @@ bool CFX_FormatString::FormatStrNum(const CFX_WideStringC& wsInputNum,
while (ccf < lenf) {
switch (strf[ccf]) {
case '\'':
- wsOutput += FX_GetLiteralText(strf, ccf, lenf);
+ wsOutput += GetLiteralText(strf, ccf, lenf);
ccf++;
break;
case '9':
@@ -3076,414 +2677,7 @@ bool CFX_FormatString::FormatStrNum(const CFX_WideStringC& wsInputNum,
}
return true;
}
-bool CFX_FormatString::FormatLCNumeric(CFX_LCNumeric& lcNum,
- const CFX_WideString& wsPattern,
- CFX_WideString& wsOutput) {
- int32_t dot_index_f = -1;
- uint32_t dwNumStyle = 0;
- CFX_WideString wsNumFormat;
- IFX_Locale* pLocale =
- GetNumericFormat(wsPattern, dot_index_f, dwNumStyle, wsNumFormat);
- if (!pLocale || wsNumFormat.IsEmpty()) {
- return false;
- }
- int32_t cc = 0, ccf = 0;
- const wchar_t* strf = wsNumFormat.c_str();
- int lenf = wsNumFormat.GetLength();
- double dbOrgRaw = lcNum.GetDouble();
- double dbRetValue = dbOrgRaw;
- if (dwNumStyle & FX_NUMSTYLE_Percent) {
- dbRetValue *= 100;
- }
- int32_t exponent = 0;
- if (dwNumStyle & FX_NUMSTYLE_Exponent) {
- int fixed_count = 0;
- while (ccf < dot_index_f) {
- switch (strf[ccf]) {
- case '\'':
- FX_GetLiteralText(strf, ccf, dot_index_f);
- break;
- case '9':
- case 'z':
- case 'Z':
- fixed_count++;
- break;
- }
- ccf++;
- }
- int threshold = 1;
- while (fixed_count > 1) {
- threshold *= 10;
- fixed_count--;
- }
- if (dbRetValue != 0) {
- if (dbRetValue < threshold) {
- dbRetValue *= 10;
- exponent = -1;
- while (dbRetValue < threshold) {
- dbRetValue *= 10;
- exponent -= 1;
- }
- } else if (dbRetValue > threshold) {
- threshold *= 10;
- while (dbRetValue > threshold) {
- dbRetValue /= 10;
- exponent += 1;
- }
- }
- }
- }
- if (dwNumStyle & (FX_NUMSTYLE_Percent | FX_NUMSTYLE_Exponent)) {
- lcNum = CFX_LCNumeric(dbRetValue);
- }
- bool bTrimTailZeros = false;
- int32_t iTreading =
- FX_GetNumTrailingLimit(wsNumFormat, dot_index_f, bTrimTailZeros);
- CFX_WideString wsNumeric = lcNum.ToString(iTreading, bTrimTailZeros);
- if (wsNumeric.IsEmpty()) {
- return false;
- }
- CFX_WideString wsGroupSymbol;
- pLocale->GetNumbericSymbol(FX_LOCALENUMSYMBOL_Grouping, wsGroupSymbol);
- bool bNeg = false;
- if (wsNumeric[0] == '-') {
- bNeg = true;
- wsNumeric.Delete(0, 1);
- }
- bool bAddNeg = false;
- const wchar_t* str = wsNumeric.c_str();
- int len = wsNumeric.GetLength();
- int dot_index = wsNumeric.Find('.');
- if (dot_index == -1) {
- dot_index = len;
- }
- ccf = dot_index_f - 1;
- cc = dot_index - 1;
- while (ccf >= 0) {
- switch (strf[ccf]) {
- case '9':
- if (cc >= 0) {
- wsOutput = str[cc] + wsOutput;
- cc--;
- } else {
- wsOutput = L'0' + wsOutput;
- }
- ccf--;
- break;
- case 'z':
- if (cc >= 0) {
- if (lcNum.m_Integral != 0) {
- wsOutput = str[cc] + wsOutput;
- }
- cc--;
- }
- ccf--;
- break;
- case 'Z':
- if (cc >= 0) {
- if (lcNum.m_Integral == 0) {
- wsOutput = L' ' + wsOutput;
- } else {
- wsOutput = str[cc] + wsOutput;
- }
- cc--;
- } else {
- wsOutput = L' ' + wsOutput;
- }
- ccf--;
- break;
- case 'S':
- if (bNeg) {
- CFX_WideString wsMinusSymbol;
- pLocale->GetNumbericSymbol(FX_LOCALENUMSYMBOL_Minus, wsMinusSymbol);
- wsOutput = wsMinusSymbol + wsOutput;
- bAddNeg = true;
- } else {
- wsOutput = L' ' + wsOutput;
- }
- ccf--;
- break;
- case 's':
- if (bNeg) {
- CFX_WideString wsMinusSymbol;
- pLocale->GetNumbericSymbol(FX_LOCALENUMSYMBOL_Minus, wsMinusSymbol);
- wsOutput = wsMinusSymbol + wsOutput;
- bAddNeg = true;
- }
- ccf--;
- break;
- case 'E': {
- CFX_WideString wsExp;
- wsExp.Format(L"E%+d", exponent);
- wsOutput = wsExp + wsOutput;
- }
- ccf--;
- break;
- case '$': {
- CFX_WideString wsSymbol;
- pLocale->GetNumbericSymbol(FX_LOCALENUMSYMBOL_CurrencySymbol, wsSymbol);
- wsOutput = wsSymbol + wsOutput;
- }
- ccf--;
- break;
- case 'r':
- if (ccf - 1 >= 0 && strf[ccf - 1] == 'c') {
- if (bNeg) {
- wsOutput = L"CR" + wsOutput;
- }
- ccf -= 2;
- bAddNeg = true;
- }
- break;
- case 'R':
- if (ccf - 1 >= 0 && strf[ccf - 1] == 'C') {
- if (bNeg) {
- wsOutput = L"CR" + wsOutput;
- } else {
- wsOutput = L" " + wsOutput;
- }
- ccf -= 2;
- bAddNeg = true;
- }
- break;
- case 'b':
- if (ccf - 1 >= 0 && strf[ccf - 1] == 'd') {
- if (bNeg) {
- wsOutput = L"db" + wsOutput;
- }
- ccf -= 2;
- bAddNeg = true;
- }
- break;
- case 'B':
- if (ccf - 1 >= 0 && strf[ccf - 1] == 'D') {
- if (bNeg) {
- wsOutput = L"DB" + wsOutput;
- } else {
- wsOutput = L" " + wsOutput;
- }
- ccf -= 2;
- bAddNeg = true;
- }
- break;
- case '%': {
- CFX_WideString wsSymbol;
- pLocale->GetNumbericSymbol(FX_LOCALENUMSYMBOL_Percent, wsSymbol);
- wsOutput = wsSymbol + wsOutput;
- }
- ccf--;
- break;
- case ',':
- if (cc >= 0) {
- wsOutput = wsGroupSymbol + wsOutput;
- }
- ccf--;
- break;
- case '(':
- if (bNeg) {
- wsOutput = L"(" + wsOutput;
- } else {
- wsOutput = L" " + wsOutput;
- }
- bAddNeg = true;
- ccf--;
- break;
- case ')':
- if (bNeg) {
- wsOutput = L")" + wsOutput;
- } else {
- wsOutput = L" " + wsOutput;
- }
- ccf--;
- break;
- case '\'':
- wsOutput = FX_GetLiteralTextReverse(strf, ccf) + wsOutput;
- ccf--;
- break;
- default:
- wsOutput = strf[ccf] + wsOutput;
- ccf--;
- }
- }
- if (cc >= 0) {
- int nPos = dot_index % 3;
- wsOutput.clear();
- for (int32_t i = 0; i < dot_index; i++) {
- if (i % 3 == nPos && i != 0) {
- wsOutput += wsGroupSymbol;
- }
- wsOutput += wsNumeric[i];
- }
- if (dot_index < len) {
- CFX_WideString wsSymbol;
- pLocale->GetNumbericSymbol(FX_LOCALENUMSYMBOL_Decimal, wsSymbol);
- wsOutput += wsSymbol;
- wsOutput += wsNumeric.Right(len - dot_index - 1);
- }
- if (bNeg) {
- CFX_WideString wsMinusymbol;
- pLocale->GetNumbericSymbol(FX_LOCALENUMSYMBOL_Minus, wsMinusymbol);
- wsOutput = wsMinusymbol + wsOutput;
- }
- return false;
- }
- if (dot_index_f == wsNumFormat.GetLength()) {
- if (!bAddNeg && bNeg) {
- CFX_WideString wsMinusymbol;
- pLocale->GetNumbericSymbol(FX_LOCALENUMSYMBOL_Minus, wsMinusymbol);
- wsOutput = wsMinusymbol + wsOutput;
- }
- return true;
- }
- CFX_WideString wsDotSymbol;
- pLocale->GetNumbericSymbol(FX_LOCALENUMSYMBOL_Decimal, wsDotSymbol);
- if (strf[dot_index_f] == 'V') {
- wsOutput += wsDotSymbol;
- } else if (strf[dot_index_f] == '.') {
- if (dot_index < len) {
- wsOutput += wsDotSymbol;
- } else {
- if (strf[dot_index_f + 1] == '9' || strf[dot_index_f + 1] == 'Z') {
- wsOutput += wsDotSymbol;
- }
- }
- }
- ccf = dot_index_f + 1;
- cc = dot_index + 1;
- while (ccf < lenf) {
- switch (strf[ccf]) {
- case '\'':
- wsOutput += FX_GetLiteralText(strf, ccf, lenf);
- ccf++;
- break;
- case '9':
- if (cc < len) {
- wsOutput += str[cc];
- cc++;
- } else {
- wsOutput += L'0';
- }
- ccf++;
- break;
- case 'z':
- if (cc < len) {
- wsOutput += str[cc];
- cc++;
- }
- ccf++;
- break;
- case 'Z':
- if (cc < len) {
- wsOutput += str[cc];
- cc++;
- } else {
- wsOutput += L'0';
- }
- ccf++;
- break;
- case 'E': {
- CFX_WideString wsExp;
- wsExp.Format(L"E%+d", exponent);
- wsOutput += wsExp;
- }
- ccf++;
- break;
- case '$': {
- CFX_WideString wsSymbol;
- pLocale->GetNumbericSymbol(FX_LOCALENUMSYMBOL_CurrencySymbol, wsSymbol);
- wsOutput += wsSymbol;
- }
- ccf++;
- break;
- case 'c':
- if (ccf + 1 < lenf && strf[ccf + 1] == 'r') {
- if (bNeg) {
- wsOutput += L"CR";
- }
- ccf += 2;
- bAddNeg = true;
- }
- break;
- case 'C':
- if (ccf + 1 < lenf && strf[ccf + 1] == 'R') {
- if (bNeg) {
- wsOutput += L"CR";
- } else {
- wsOutput += L" ";
- }
- ccf += 2;
- bAddNeg = true;
- }
- break;
- case 'd':
- if (ccf + 1 < lenf && strf[ccf + 1] == 'b') {
- if (bNeg) {
- wsOutput += L"db";
- }
- ccf += 2;
- bAddNeg = true;
- }
- break;
- case 'D':
- if (ccf + 1 < lenf && strf[ccf + 1] == 'B') {
- if (bNeg) {
- wsOutput += L"DB";
- } else {
- wsOutput += L" ";
- }
- ccf += 2;
- bAddNeg = true;
- }
- break;
- case '%': {
- CFX_WideString wsSymbol;
- pLocale->GetNumbericSymbol(FX_LOCALENUMSYMBOL_Percent, wsSymbol);
- wsOutput += wsSymbol;
- }
- ccf++;
- break;
- case '8': {
- while (ccf < lenf && strf[ccf] == '8') {
- ccf++;
- }
- while (cc < len && FXSYS_isDecimalDigit(str[cc])) {
- wsOutput += str[cc];
- cc++;
- }
- } break;
- case ',':
- wsOutput += wsGroupSymbol;
- ccf++;
- break;
- case '(':
- if (bNeg) {
- wsOutput += '(';
- } else {
- wsOutput += ' ';
- }
- bAddNeg = true;
- ccf++;
- break;
- case ')':
- if (bNeg) {
- wsOutput += ')';
- } else {
- wsOutput += ' ';
- }
- ccf++;
- break;
- default:
- ccf++;
- }
- }
- if (!bAddNeg && bNeg) {
- CFX_WideString wsMinusymbol;
- pLocale->GetNumbericSymbol(FX_LOCALENUMSYMBOL_Minus, wsMinusymbol);
- wsOutput =
- wsOutput[0] + wsMinusymbol + wsOutput.Mid(1, wsOutput.GetLength() - 1);
- }
- return true;
-}
+
bool CFX_FormatString::FormatNum(const CFX_WideString& wsSrcNum,
const CFX_WideString& wsPattern,
CFX_WideString& wsOutput) {
@@ -3492,518 +2686,7 @@ bool CFX_FormatString::FormatNum(const CFX_WideString& wsSrcNum,
}
return FormatStrNum(wsSrcNum.AsStringC(), wsPattern, wsOutput);
}
-bool CFX_FormatString::FormatNum(float fNum,
- const CFX_WideString& wsPattern,
- CFX_WideString& wsOutput) {
- if (wsPattern.IsEmpty()) {
- return false;
- }
- CFX_LCNumeric lcNum(fNum);
- return FormatLCNumeric(lcNum, wsPattern, wsOutput);
-}
-bool FX_DateFromCanonical(const CFX_WideString& wsDate, CFX_Unitime& datetime) {
- int32_t year = 1900;
- int32_t month = 1;
- int32_t day = 1;
- uint16_t wYear = 0;
- int cc_start = 0, cc = 0;
- const wchar_t* str = wsDate.c_str();
- int len = wsDate.GetLength();
- if (len > 10) {
- return false;
- }
- while (cc < len && cc < 4) {
- if (!FXSYS_isDecimalDigit(str[cc])) {
- return false;
- }
- wYear = wYear * 10 + str[cc++] - '0';
- }
- year = wYear;
- if (cc < 4 || wYear < 1900) {
- return false;
- }
- if (cc < len) {
- if (str[cc] == '-') {
- cc++;
- }
- cc_start = cc;
- uint8_t tmpM = 0;
- while (cc < len && cc < cc_start + 2) {
- if (!FXSYS_isDecimalDigit(str[cc])) {
- return false;
- }
- tmpM = tmpM * 10 + str[cc++] - '0';
- }
- month = tmpM;
- if (cc == cc_start + 1 || tmpM > 12 || tmpM < 1) {
- return false;
- }
- if (cc < len) {
- if (str[cc] == '-') {
- cc++;
- }
- uint8_t tmpD = 0;
- cc_start = cc;
- while (cc < len && cc < cc_start + 2) {
- if (!FXSYS_isDecimalDigit(str[cc])) {
- return false;
- }
- tmpD = tmpD * 10 + str[cc++] - '0';
- }
- day = tmpD;
- if (tmpD < 1) {
- return false;
- }
- if ((tmpM == 1 || tmpM == 3 || tmpM == 5 || tmpM == 7 || tmpM == 8 ||
- tmpM == 10 || tmpM == 12) &&
- tmpD > 31) {
- return false;
- }
- if ((tmpM == 4 || tmpM == 6 || tmpM == 9 || tmpM == 11) && tmpD > 30) {
- return false;
- }
- bool iLeapYear;
- if ((wYear % 4 == 0 && wYear % 100 != 0) || wYear % 400 == 0) {
- iLeapYear = true;
- } else {
- iLeapYear = false;
- }
- if ((iLeapYear && tmpM == 2 && tmpD > 29) ||
- (!iLeapYear && tmpM == 2 && tmpD > 28)) {
- return false;
- }
- }
- }
- CFX_Unitime ut;
- ut.Set(year, month, day);
- datetime = datetime + ut;
- return true;
-}
-bool FX_TimeFromCanonical(const CFX_WideStringC& wsTime,
- CFX_Unitime& datetime,
- IFX_Locale* pLocale) {
- if (wsTime.GetLength() == 0) {
- return false;
- }
- uint8_t hour = 0;
- uint8_t minute = 0;
- uint8_t second = 0;
- uint16_t millisecond = 0;
- int cc_start = 0, cc = cc_start;
- const wchar_t* str = wsTime.c_str();
- int len = wsTime.GetLength();
- while (cc < len && cc < 2) {
- if (!FXSYS_isDecimalDigit(str[cc])) {
- return false;
- }
- hour = hour * 10 + str[cc++] - '0';
- }
- if (cc < 2 || hour >= 24) {
- return false;
- }
- if (cc < len) {
- if (str[cc] == ':') {
- cc++;
- }
- cc_start = cc;
- while (cc < len && cc < cc_start + 2) {
- if (!FXSYS_isDecimalDigit(str[cc])) {
- return false;
- }
- minute = minute * 10 + str[cc++] - '0';
- }
- if (cc == cc_start + 1 || minute >= 60) {
- return false;
- }
- if (cc < len) {
- if (str[cc] == ':') {
- cc++;
- }
- cc_start = cc;
- while (cc < len && cc < cc_start + 2) {
- if (!FXSYS_isDecimalDigit(str[cc])) {
- return false;
- }
- second = second * 10 + str[cc++] - '0';
- }
- if (cc == cc_start + 1 || second >= 60) {
- return false;
- }
- if (cc < len) {
- if (str[cc] == '.') {
- cc++;
- cc_start = cc;
- while (cc < len && cc < cc_start + 3) {
- if (!FXSYS_isDecimalDigit(str[cc])) {
- return false;
- }
- millisecond = millisecond * 10 + str[cc++] - '0';
- }
- if (cc < cc_start + 3)
- return false;
- }
- if (cc < len) {
- FX_TIMEZONE tzDiff;
- tzDiff.tzHour = 0;
- tzDiff.tzMinute = 0;
- if (str[cc] != 'Z') {
- cc += FX_ParseTimeZone(str + cc, len - cc, tzDiff);
- }
- FX_ResolveZone(hour, minute, tzDiff, pLocale);
- }
- }
- }
- }
- CFX_Unitime ut;
- ut.Set(0, 0, 0, hour, minute, second, millisecond);
- datetime = datetime + ut;
- return true;
-}
-static uint16_t FX_GetSolarMonthDays(uint16_t year, uint16_t month) {
- if (month % 2) {
- return 31;
- } else if (month == 2) {
- return FX_IsLeapYear(year) ? 29 : 28;
- }
- return 30;
-}
-static uint16_t FX_GetWeekDay(uint16_t year, uint16_t month, uint16_t day) {
- uint16_t g_month_day[] = {0, 3, 3, 6, 1, 4, 6, 2, 5, 0, 3, 5};
- uint16_t nDays =
- (year - 1) % 7 + (year - 1) / 4 - (year - 1) / 100 + (year - 1) / 400;
- nDays += g_month_day[month - 1] + day;
- if (FX_IsLeapYear(year) && month > 2) {
- nDays++;
- }
- return nDays % 7;
-}
-static uint16_t FX_GetWeekOfMonth(uint16_t year, uint16_t month, uint16_t day) {
- uint16_t week_day = FX_GetWeekDay(year, month, 1);
- uint16_t week_index = 0;
- week_index += day / 7;
- day = day % 7;
- if (week_day + day > 7) {
- week_index++;
- }
- return week_index;
-}
-static uint16_t FX_GetWeekOfYear(uint16_t year, uint16_t month, uint16_t day) {
- uint16_t nDays = 0;
- for (uint16_t i = 1; i < month; i++) {
- nDays += FX_GetSolarMonthDays(year, i);
- }
- nDays += day;
- uint16_t week_day = FX_GetWeekDay(year, 1, 1);
- uint16_t week_index = 1;
- week_index += nDays / 7;
- nDays = nDays % 7;
- if (week_day + nDays > 7) {
- week_index++;
- }
- return week_index;
-}
-static bool FX_DateFormat(const CFX_WideString& wsDatePattern,
- IFX_Locale* pLocale,
- const CFX_Unitime& datetime,
- CFX_WideString& wsResult) {
- bool bRet = true;
- int32_t year = datetime.GetYear();
- uint8_t month = datetime.GetMonth();
- uint8_t day = datetime.GetDay();
- int32_t ccf = 0;
- const wchar_t* strf = wsDatePattern.c_str();
- int32_t lenf = wsDatePattern.GetLength();
- CFX_WideStringC wsDateSymbols(gs_wsDateSymbols);
- while (ccf < lenf) {
- if (strf[ccf] == '\'') {
- wsResult += FX_GetLiteralText(strf, ccf, lenf);
- ccf++;
- continue;
- } else if (wsDateSymbols.Find(strf[ccf]) == -1) {
- wsResult += strf[ccf++];
- continue;
- }
- uint32_t dwSymbolNum = 1;
- wchar_t dwCharSymbol = strf[ccf++];
- while (ccf < lenf && strf[ccf] == dwCharSymbol) {
- ccf++;
- dwSymbolNum++;
- }
- uint32_t dwSymbol = (dwCharSymbol << 8) | (dwSymbolNum + '0');
- if (dwSymbol == FXBSTR_ID(0, 0, 'D', '1')) {
- CFX_WideString wsDay;
- wsDay.Format(L"%d", day);
- wsResult += wsDay;
- } else if (dwSymbol == FXBSTR_ID(0, 0, 'D', '2')) {
- CFX_WideString wsDay;
- wsDay.Format(L"%02d", day);
- wsResult += wsDay;
- } else if (dwSymbol == FXBSTR_ID(0, 0, 'J', '1')) {
- uint16_t nDays = 0;
- for (int i = 1; i < month; i++) {
- nDays += FX_GetSolarMonthDays(year, i);
- }
- nDays += day;
- CFX_WideString wsDays;
- wsDays.Format(L"%d", nDays);
- wsResult += wsDays;
- } else if (dwSymbol == FXBSTR_ID(0, 0, 'J', '3')) {
- uint16_t nDays = 0;
- for (int i = 1; i < month; i++) {
- nDays += FX_GetSolarMonthDays(year, i);
- }
- nDays += day;
- CFX_WideString wsDays;
- wsDays.Format(L"%03d", nDays);
- wsResult += wsDays;
- } else if (dwSymbol == FXBSTR_ID(0, 0, 'M', '1')) {
- CFX_WideString wsMonth;
- wsMonth.Format(L"%d", month);
- wsResult += wsMonth;
- } else if (dwSymbol == FXBSTR_ID(0, 0, 'M', '2')) {
- CFX_WideString wsMonth;
- wsMonth.Format(L"%02d", month);
- wsResult += wsMonth;
- } else if (dwSymbol == FXBSTR_ID(0, 0, 'M', '3')) {
- CFX_WideString wsTemp;
- pLocale->GetMonthName(month - 1, wsTemp, true);
- wsResult += wsTemp;
- } else if (dwSymbol == FXBSTR_ID(0, 0, 'M', '4')) {
- CFX_WideString wsTemp;
- pLocale->GetMonthName(month - 1, wsTemp, false);
- wsResult += wsTemp;
- } else if (dwSymbol == FXBSTR_ID(0, 0, 'E', '1')) {
- uint16_t wWeekDay = FX_GetWeekDay(year, month, day);
- CFX_WideString wsWeekDay;
- wsWeekDay.Format(L"%d", wWeekDay + 1);
- wsResult += wsWeekDay;
- } else if (dwSymbol == FXBSTR_ID(0, 0, 'E', '3')) {
- uint16_t wWeekDay = FX_GetWeekDay(year, month, day);
- CFX_WideString wsTemp;
- pLocale->GetDayName(wWeekDay, wsTemp, true);
- wsResult += wsTemp;
- } else if (dwSymbol == FXBSTR_ID(0, 0, 'E', '4')) {
- uint16_t wWeekDay = FX_GetWeekDay(year, month, day);
- if (pLocale) {
- CFX_WideString wsTemp;
- pLocale->GetDayName(wWeekDay, wsTemp, false);
- wsResult += wsTemp;
- }
- } else if (dwSymbol == FXBSTR_ID(0, 0, 'e', '1')) {
- uint16_t wWeekDay = FX_GetWeekDay(year, month, day);
- CFX_WideString wsWeekDay;
- wsWeekDay.Format(L"%d", wWeekDay ? wWeekDay : 7);
- wsResult += wsWeekDay;
- } else if (dwSymbol == FXBSTR_ID(0, 0, 'G', '1')) {
- CFX_WideString wsTemp;
- pLocale->GetEraName(wsTemp, year < 0);
- wsResult += wsTemp;
- } else if (dwSymbol == FXBSTR_ID(0, 0, 'Y', '2')) {
- CFX_WideString wsYear;
- wsYear.Format(L"%02d", year % 100);
- wsResult += wsYear;
- } else if (dwSymbol == FXBSTR_ID(0, 0, 'Y', '4')) {
- CFX_WideString wsYear;
- wsYear.Format(L"%d", year);
- wsResult += wsYear;
- } else if (dwSymbol == FXBSTR_ID(0, 0, 'w', '1')) {
- uint16_t week_index = FX_GetWeekOfMonth(year, month, day);
- CFX_WideString wsWeekInMonth;
- wsWeekInMonth.Format(L"%d", week_index);
- wsResult += wsWeekInMonth;
- } else if (dwSymbol == FXBSTR_ID(0, 0, 'W', '2')) {
- uint16_t week_index = FX_GetWeekOfYear(year, month, day);
- CFX_WideString wsWeekInYear;
- wsWeekInYear.Format(L"%02d", week_index);
- wsResult += wsWeekInYear;
- }
- }
- return bRet;
-}
-static bool FX_TimeFormat(const CFX_WideString& wsTimePattern,
- IFX_Locale* pLocale,
- const CFX_Unitime& datetime,
- CFX_WideString& wsResult) {
- bool bGMT = false;
- bool bRet = true;
- uint8_t hour = datetime.GetHour();
- uint8_t minute = datetime.GetMinute();
- uint8_t second = datetime.GetSecond();
- uint16_t millisecond = datetime.GetMillisecond();
- int32_t ccf = 0;
- const wchar_t* strf = wsTimePattern.c_str();
- int32_t lenf = wsTimePattern.GetLength();
- uint16_t wHour = hour;
- bool bPM = false;
- if (wsTimePattern.Find('A') != -1) {
- if (wHour >= 12) {
- bPM = true;
- }
- }
- CFX_WideStringC wsTimeSymbols(gs_wsTimeSymbols);
- while (ccf < lenf) {
- if (strf[ccf] == '\'') {
- wsResult += FX_GetLiteralText(strf, ccf, lenf);
- ccf++;
- continue;
- } else if (wsTimeSymbols.Find(strf[ccf]) == -1) {
- wsResult += strf[ccf++];
- continue;
- }
- uint32_t dwSymbolNum = 1;
- wchar_t dwCharSymbol = strf[ccf++];
- while (ccf < lenf && strf[ccf] == dwCharSymbol) {
- ccf++;
- dwSymbolNum++;
- }
- uint32_t dwSymbol = (dwCharSymbol << 8) | (dwSymbolNum + '0');
- if (dwSymbol == FXBSTR_ID(0, 0, 'h', '1')) {
- if (wHour > 12) {
- wHour -= 12;
- }
- CFX_WideString wsHour;
- wsHour.Format(L"%d", wHour == 0 ? 12 : wHour);
- wsResult += wsHour;
- } else if (dwSymbol == FXBSTR_ID(0, 0, 'h', '2')) {
- if (wHour > 12) {
- wHour -= 12;
- }
- CFX_WideString wsHour;
- wsHour.Format(L"%02d", wHour == 0 ? 12 : wHour);
- wsResult += wsHour;
- } else if (dwSymbol == FXBSTR_ID(0, 0, 'K', '1')) {
- CFX_WideString wsHour;
- wsHour.Format(L"%d", wHour == 0 ? 24 : wHour);
- wsResult += wsHour;
- } else if (dwSymbol == FXBSTR_ID(0, 0, 'K', '2')) {
- CFX_WideString wsHour;
- wsHour.Format(L"%02d", wHour == 0 ? 24 : wHour);
- wsResult += wsHour;
- } else if (dwSymbol == FXBSTR_ID(0, 0, 'k', '1')) {
- if (wHour > 12) {
- wHour -= 12;
- }
- CFX_WideString wsHour;
- wsHour.Format(L"%d", wHour);
- wsResult += wsHour;
- } else if (dwSymbol == FXBSTR_ID(0, 0, 'H', '1')) {
- CFX_WideString wsHour;
- wsHour.Format(L"%d", wHour);
- wsResult += wsHour;
- } else if (dwSymbol == FXBSTR_ID(0, 0, 'k', '2')) {
- if (wHour > 12) {
- wHour -= 12;
- }
- CFX_WideString wsHour;
- wsHour.Format(L"%02d", wHour);
- wsResult += wsHour;
- } else if (dwSymbol == FXBSTR_ID(0, 0, 'H', '2')) {
- CFX_WideString wsHour;
- wsHour.Format(L"%02d", wHour);
- wsResult += wsHour;
- } else if (dwSymbol == FXBSTR_ID(0, 0, 'M', '1')) {
- CFX_WideString wsMinute;
- wsMinute.Format(L"%d", minute);
- wsResult += wsMinute;
- } else if (dwSymbol == FXBSTR_ID(0, 0, 'M', '2')) {
- CFX_WideString wsMinute;
- wsMinute.Format(L"%02d", minute);
- wsResult += wsMinute;
- } else if (dwSymbol == FXBSTR_ID(0, 0, 'S', '1')) {
- CFX_WideString wsSecond;
- wsSecond.Format(L"%d", second);
- wsResult += wsSecond;
- } else if (dwSymbol == FXBSTR_ID(0, 0, 'S', '2')) {
- CFX_WideString wsSecond;
- wsSecond.Format(L"%02d", second);
- wsResult += wsSecond;
- } else if (dwSymbol == FXBSTR_ID(0, 0, 'F', '3')) {
- CFX_WideString wsMilliseconds;
- wsMilliseconds.Format(L"%03d", millisecond);
- wsResult += wsMilliseconds;
- } else if (dwSymbol == FXBSTR_ID(0, 0, 'A', '1')) {
- CFX_WideString wsMeridiem;
- pLocale->GetMeridiemName(wsMeridiem, !bPM);
- wsResult += wsMeridiem;
- } else if (dwSymbol == FXBSTR_ID(0, 0, 'Z', '1')) {
- wsResult += L"GMT";
- FX_TIMEZONE tz;
- pLocale->GetTimeZone(&tz);
- if (!bGMT && (tz.tzHour != 0 || tz.tzMinute != 0)) {
- if (tz.tzHour < 0) {
- wsResult += L"-";
- } else {
- wsResult += L"+";
- }
- CFX_WideString wsTimezone;
- wsTimezone.Format(L"%02d:%02d", FXSYS_abs(tz.tzHour), tz.tzMinute);
- wsResult += wsTimezone;
- }
- } else if (dwSymbol == FXBSTR_ID(0, 0, 'z', '1')) {
- FX_TIMEZONE tz;
- pLocale->GetTimeZone(&tz);
- if (!bGMT && tz.tzHour != 0 && tz.tzMinute != 0) {
- if (tz.tzHour < 0) {
- wsResult += L"-";
- } else {
- wsResult += L"+";
- }
- CFX_WideString wsTimezone;
- wsTimezone.Format(L"%02d:%02d", FXSYS_abs(tz.tzHour), tz.tzMinute);
- wsResult += wsTimezone;
- }
- }
- }
- return bRet;
-}
-static bool FX_FormatDateTime(const CFX_Unitime& dt,
- const CFX_WideString& wsDatePattern,
- const CFX_WideString& wsTimePattern,
- bool bDateFirst,
- IFX_Locale* pLocale,
- CFX_WideString& wsOutput) {
- bool bRet = true;
- CFX_WideString wsDateOut, wsTimeOut;
- if (!wsDatePattern.IsEmpty()) {
- bRet &= FX_DateFormat(wsDatePattern, pLocale, dt, wsDateOut);
- }
- if (!wsTimePattern.IsEmpty()) {
- bRet &= FX_TimeFormat(wsTimePattern, pLocale, dt, wsTimeOut);
- }
- wsOutput = bDateFirst ? wsDateOut + wsTimeOut : wsTimeOut + wsDateOut;
- return bRet;
-}
-bool CFX_FormatString::FormatDateTime(const CFX_WideString& wsSrcDateTime,
- const CFX_WideString& wsPattern,
- CFX_WideString& wsOutput) {
- if (wsSrcDateTime.IsEmpty() || wsPattern.IsEmpty()) {
- return false;
- }
- CFX_WideString wsDatePattern, wsTimePattern;
- IFX_Locale* pLocale = nullptr;
- FX_DATETIMETYPE eCategory =
- GetDateTimeFormat(wsPattern, pLocale, wsDatePattern, wsTimePattern);
- if (!pLocale || eCategory == FX_DATETIMETYPE_Unknown) {
- return false;
- }
- CFX_Unitime dt(0);
- int32_t iT = wsSrcDateTime.Find(L"T");
- if (iT < 0) {
- if (eCategory == FX_DATETIMETYPE_Date) {
- FX_DateFromCanonical(wsSrcDateTime, dt);
- } else if (eCategory == FX_DATETIMETYPE_Time) {
- FX_TimeFromCanonical(wsSrcDateTime.AsStringC(), dt, pLocale);
- }
- } else {
- FX_DateFromCanonical(wsSrcDateTime.Left(iT), dt);
- FX_TimeFromCanonical(
- wsSrcDateTime.Right(wsSrcDateTime.GetLength() - iT - 1).AsStringC(), dt,
- pLocale);
- }
- return FX_FormatDateTime(dt, wsDatePattern, wsTimePattern,
- eCategory != FX_DATETIMETYPE_TimeDate, pLocale,
- wsOutput);
-}
+
bool CFX_FormatString::FormatDateTime(const CFX_WideString& wsSrcDateTime,
const CFX_WideString& wsPattern,
CFX_WideString& wsOutput,
@@ -4033,12 +2716,12 @@ bool CFX_FormatString::FormatDateTime(const CFX_WideString& wsSrcDateTime,
if (iT < 0) {
if (eCategory == FX_DATETIMETYPE_Date &&
FX_DateFromCanonical(wsSrcDateTime, dt)) {
- return FX_FormatDateTime(dt, wsDatePattern, wsTimePattern, true, pLocale,
- wsOutput);
+ return FormatDateTimeInternal(dt, wsDatePattern, wsTimePattern, true,
+ pLocale, wsOutput);
} else if (eCategory == FX_DATETIMETYPE_Time &&
FX_TimeFromCanonical(wsSrcDateTime.AsStringC(), dt, pLocale)) {
- return FX_FormatDateTime(dt, wsDatePattern, wsTimePattern, true, pLocale,
- wsOutput);
+ return FormatDateTimeInternal(dt, wsDatePattern, wsTimePattern, true,
+ pLocale, wsOutput);
}
} else {
CFX_WideString wsSrcDate(wsSrcDateTime.c_str(), iT);
@@ -4049,30 +2732,14 @@ bool CFX_FormatString::FormatDateTime(const CFX_WideString& wsSrcDateTime,
}
if (FX_DateFromCanonical(wsSrcDate, dt) &&
FX_TimeFromCanonical(wsSrcTime, dt, pLocale)) {
- return FX_FormatDateTime(dt, wsDatePattern, wsTimePattern,
- eCategory != FX_DATETIMETYPE_TimeDate, pLocale,
- wsOutput);
+ return FormatDateTimeInternal(dt, wsDatePattern, wsTimePattern,
+ eCategory != FX_DATETIMETYPE_TimeDate,
+ pLocale, wsOutput);
}
}
return false;
}
-bool CFX_FormatString::FormatDateTime(const CFX_Unitime& dt,
- const CFX_WideString& wsPattern,
- CFX_WideString& wsOutput) {
- if (wsPattern.IsEmpty()) {
- return false;
- }
- CFX_WideString wsDatePattern, wsTimePattern;
- IFX_Locale* pLocale = nullptr;
- FX_DATETIMETYPE eCategory =
- GetDateTimeFormat(wsPattern, pLocale, wsDatePattern, wsTimePattern);
- if (!pLocale) {
- return false;
- }
- return FX_FormatDateTime(dt, wsPattern, wsTimePattern,
- eCategory != FX_DATETIMETYPE_TimeDate, pLocale,
- wsOutput);
-}
+
bool CFX_FormatString::FormatZero(const CFX_WideString& wsPattern,
CFX_WideString& wsOutput) {
if (wsPattern.IsEmpty()) {
@@ -4085,7 +2752,7 @@ bool CFX_FormatString::FormatZero(const CFX_WideString& wsPattern,
int32_t iLenPattern = wsTextFormat.GetLength();
while (iPattern < iLenPattern) {
if (pStrPattern[iPattern] == '\'') {
- wsOutput += FX_GetLiteralText(pStrPattern, iPattern, iLenPattern);
+ wsOutput += GetLiteralText(pStrPattern, iPattern, iLenPattern);
iPattern++;
continue;
} else {
@@ -4107,7 +2774,7 @@ bool CFX_FormatString::FormatNull(const CFX_WideString& wsPattern,
int32_t iLenPattern = wsTextFormat.GetLength();
while (iPattern < iLenPattern) {
if (pStrPattern[iPattern] == '\'') {
- wsOutput += FX_GetLiteralText(pStrPattern, iPattern, iLenPattern);
+ wsOutput += GetLiteralText(pStrPattern, iPattern, iLenPattern);
iPattern++;
continue;
} else {
@@ -4117,650 +2784,7 @@ bool CFX_FormatString::FormatNull(const CFX_WideString& wsPattern,
}
return true;
}
+
IFX_Locale* CFX_FormatString::GetPatternLocale(const CFX_WideString& wsLocale) {
return m_pLocaleMgr->GetLocaleByName(wsLocale);
}
-#define FXMATH_DECIMAL_SCALELIMIT 0x1c
-#define FXMATH_DECIMAL_NEGMASK (0x80000000L)
-#define FXMATH_DECIMAL_FORCEBOOL(x) (!(!(x)))
-#define FXMATH_DECIMAL_MAKEFLAGS(NEG, SCALE) \
- (((SCALE) << 0x10) | ((NEG) ? FXMATH_DECIMAL_NEGMASK : 0))
-#define FXMATH_DECIMAL_FLAGS2NEG(FLAGS) \
- FXMATH_DECIMAL_FORCEBOOL((FLAGS)&FXMATH_DECIMAL_NEGMASK)
-#define FXMATH_DECIMAL_FLAGS2SCALE(FLAGS) \
- ((uint8_t)(((FLAGS) & ~FXMATH_DECIMAL_NEGMASK) >> 0x10))
-#define FXMATH_DECIMAL_RSHIFT32BIT(x) ((x) >> 0x10 >> 0x10)
-#define FXMATH_DECIMAL_LSHIFT32BIT(x) ((x) << 0x10 << 0x10)
-static inline uint8_t fxmath_decimal_helper_div10(uint64_t& phi,
- uint64_t& pmid,
- uint64_t& plo) {
- uint8_t retVal;
- pmid += FXMATH_DECIMAL_LSHIFT32BIT(phi % 0xA);
- phi /= 0xA;
- plo += FXMATH_DECIMAL_LSHIFT32BIT(pmid % 0xA);
- pmid /= 0xA;
- retVal = plo % 0xA;
- plo /= 0xA;
- return retVal;
-}
-static inline uint8_t fxmath_decimal_helper_div10_any(uint64_t nums[],
- uint8_t numcount) {
- uint8_t retVal = 0;
- for (int i = numcount - 1; i > 0; i--) {
- nums[i - 1] += FXMATH_DECIMAL_LSHIFT32BIT(nums[i] % 0xA);
- nums[i] /= 0xA;
- }
- if (numcount) {
- retVal = nums[0] % 0xA;
- nums[0] /= 0xA;
- }
- return retVal;
-}
-static inline void fxmath_decimal_helper_mul10(uint64_t& phi,
- uint64_t& pmid,
- uint64_t& plo) {
- plo *= 0xA;
- pmid = pmid * 0xA + FXMATH_DECIMAL_RSHIFT32BIT(plo);
- plo = (uint32_t)plo;
- phi = phi * 0xA + FXMATH_DECIMAL_RSHIFT32BIT(pmid);
- pmid = (uint32_t)pmid;
-}
-static inline void fxmath_decimal_helper_mul10_any(uint64_t nums[],
- uint8_t numcount) {
- nums[0] *= 0xA;
- for (int i = 1; i < numcount; i++) {
- nums[i] = nums[i] * 0xA + FXMATH_DECIMAL_RSHIFT32BIT(nums[i - 1]);
- nums[i - 1] = (uint32_t)nums[i - 1];
- }
-}
-static inline void fxmath_decimal_helper_normalize(uint64_t& phi,
- uint64_t& pmid,
- uint64_t& plo) {
- phi += FXMATH_DECIMAL_RSHIFT32BIT(pmid);
- pmid = (uint32_t)pmid;
- pmid += FXMATH_DECIMAL_RSHIFT32BIT(plo);
- plo = (uint32_t)plo;
- phi += FXMATH_DECIMAL_RSHIFT32BIT(pmid);
- pmid = (uint32_t)pmid;
-}
-static inline void fxmath_decimal_helper_normalize_any(uint64_t nums[],
- uint8_t len) {
- {
- for (int i = len - 2; i > 0; i--) {
- nums[i + 1] += FXMATH_DECIMAL_RSHIFT32BIT(nums[i]);
- nums[i] = (uint32_t)nums[i];
- }
- }
- {
- for (int i = 0; i < len - 1; i++) {
- nums[i + 1] += FXMATH_DECIMAL_RSHIFT32BIT(nums[i]);
- nums[i] = (uint32_t)nums[i];
- }
- }
-}
-static inline int8_t fxmath_decimal_helper_raw_compare(uint32_t hi1,
- uint32_t mid1,
- uint32_t lo1,
- uint32_t hi2,
- uint32_t mid2,
- uint32_t lo2) {
- int8_t retVal = 0;
- if (!retVal) {
- retVal += (hi1 > hi2 ? 1 : (hi1 < hi2 ? -1 : 0));
- }
- if (!retVal) {
- retVal += (mid1 > mid2 ? 1 : (mid1 < mid2 ? -1 : 0));
- }
- if (!retVal) {
- retVal += (lo1 > lo2 ? 1 : (lo1 < lo2 ? -1 : 0));
- }
- return retVal;
-}
-static inline int8_t fxmath_decimal_helper_raw_compare_any(uint64_t a[],
- uint8_t al,
- uint64_t b[],
- uint8_t bl) {
- int8_t retVal = 0;
- for (int i = std::max(al - 1, bl - 1); i >= 0; i--) {
- uint64_t l = (i >= al ? 0 : a[i]), r = (i >= bl ? 0 : b[i]);
- retVal += (l > r ? 1 : (l < r ? -1 : 0));
- if (retVal) {
- return retVal;
- }
- }
- return retVal;
-}
-static inline void fxmath_decimal_helper_dec_any(uint64_t a[], uint8_t al) {
- for (int i = 0; i < al; i++) {
- if (a[i]--) {
- return;
- }
- }
-}
-static inline void fxmath_decimal_helper_inc_any(uint64_t a[], uint8_t al) {
- for (int i = 0; i < al; i++) {
- a[i]++;
- if ((uint32_t)a[i] == a[i]) {
- return;
- }
- a[i] = 0;
- }
-}
-static inline void fxmath_decimal_helper_raw_mul(uint64_t a[],
- uint8_t al,
- uint64_t b[],
- uint8_t bl,
- uint64_t c[],
- uint8_t cl) {
- ASSERT(al + bl <= cl);
- {
- for (int i = 0; i < cl; i++) {
- c[i] = 0;
- }
- }
- {
- for (int i = 0; i < al; i++) {
- for (int j = 0; j < bl; j++) {
- uint64_t m = (uint64_t)a[i] * b[j];
- c[i + j] += (uint32_t)m;
- c[i + j + 1] += FXMATH_DECIMAL_RSHIFT32BIT(m);
- }
- }
- }
- {
- for (int i = 0; i < cl - 1; i++) {
- c[i + 1] += FXMATH_DECIMAL_RSHIFT32BIT(c[i]);
- c[i] = (uint32_t)c[i];
- }
- }
- {
- for (int i = 0; i < cl; i++) {
- c[i] = (uint32_t)c[i];
- }
- }
-}
-static inline void fxmath_decimal_helper_raw_div(uint64_t a[],
- uint8_t al,
- uint64_t b[],
- uint8_t bl,
- uint64_t c[],
- uint8_t cl) {
- int i;
- for (i = 0; i < cl; i++) {
- c[i] = 0;
- }
- uint64_t left[16] = {0}, right[16] = {0};
- left[0] = 0;
- for (i = 0; i < al; i++) {
- right[i] = a[i];
- }
- uint64_t tmp[16];
- while (fxmath_decimal_helper_raw_compare_any(left, al, right, al) <= 0) {
- uint64_t cur[16];
- for (i = 0; i < al; i++) {
- cur[i] = left[i] + right[i];
- }
- for (i = al - 1; i >= 0; i--) {
- if (i) {
- cur[i - 1] += FXMATH_DECIMAL_LSHIFT32BIT(cur[i] % 2);
- }
- cur[i] /= 2;
- }
- fxmath_decimal_helper_raw_mul(cur, al, b, bl, tmp, 16);
- switch (fxmath_decimal_helper_raw_compare_any(tmp, 16, a, al)) {
- case -1:
- for (i = 0; i < 16; i++) {
- left[i] = cur[i];
- }
- left[0]++;
- fxmath_decimal_helper_normalize_any(left, al);
- break;
- case 1:
- for (i = 0; i < 16; i++) {
- right[i] = cur[i];
- }
- fxmath_decimal_helper_dec_any(right, al);
- break;
- case 0:
- for (i = 0; i < std::min(al, cl); i++) {
- c[i] = cur[i];
- }
- return;
- }
- }
- for (i = 0; i < std::min(al, cl); i++) {
- c[i] = left[i];
- }
-}
-static inline bool fxmath_decimal_helper_outofrange(uint64_t a[],
- uint8_t al,
- uint8_t goal) {
- for (int i = goal; i < al; i++) {
- if (a[i]) {
- return true;
- }
- }
- return false;
-}
-static inline void fxmath_decimal_helper_shrinkintorange(uint64_t a[],
- uint8_t al,
- uint8_t goal,
- uint8_t& scale) {
- bool bRoundUp = false;
- while (scale != 0 && (scale > FXMATH_DECIMAL_SCALELIMIT ||
- fxmath_decimal_helper_outofrange(a, al, goal))) {
- bRoundUp = fxmath_decimal_helper_div10_any(a, al) >= 5;
- scale--;
- }
- if (bRoundUp) {
- fxmath_decimal_helper_normalize_any(a, goal);
- fxmath_decimal_helper_inc_any(a, goal);
- }
-}
-static inline void fxmath_decimal_helper_truncate(uint64_t& phi,
- uint64_t& pmid,
- uint64_t& plo,
- uint8_t& scale,
- uint8_t minscale = 0) {
- while (scale > minscale) {
- uint64_t thi = phi, tmid = pmid, tlo = plo;
- if (fxmath_decimal_helper_div10(thi, tmid, tlo) != 0) {
- break;
- }
- phi = thi, pmid = tmid, plo = tlo;
- scale--;
- }
-}
-CFX_Decimal::CFX_Decimal() {
- m_uLo = m_uMid = m_uHi = m_uFlags = 0;
-}
-CFX_Decimal::CFX_Decimal(uint64_t val) {
- m_uLo = (uint32_t)val;
- m_uMid = (uint32_t)FXMATH_DECIMAL_RSHIFT32BIT(val);
- m_uHi = 0;
- m_uFlags = 0;
-}
-CFX_Decimal::CFX_Decimal(uint32_t val) {
- m_uLo = (uint32_t)val;
- m_uMid = m_uHi = 0;
- m_uFlags = 0;
-}
-CFX_Decimal::CFX_Decimal(uint32_t lo,
- uint32_t mid,
- uint32_t hi,
- bool neg,
- uint8_t scale) {
- scale = (scale > FXMATH_DECIMAL_SCALELIMIT ? 0 : scale);
- m_uLo = lo;
- m_uMid = mid;
- m_uHi = hi;
- m_uFlags = FXMATH_DECIMAL_MAKEFLAGS(neg && IsNotZero(), scale);
-}
-CFX_Decimal::CFX_Decimal(int32_t val) {
- if (val >= 0) {
- *this = CFX_Decimal((uint32_t)val);
- } else {
- *this = CFX_Decimal((uint32_t)-val);
- SetNegate();
- }
-}
-CFX_Decimal::CFX_Decimal(int64_t val) {
- if (val >= 0) {
- *this = CFX_Decimal((uint64_t)val);
- } else {
- *this = CFX_Decimal((uint64_t)-val);
- SetNegate();
- }
-}
-CFX_Decimal::CFX_Decimal(float val, uint8_t scale) {
- float newval = fabs(val);
- uint64_t phi, pmid, plo;
- plo = (uint64_t)newval;
- pmid = (uint64_t)(newval / 1e32);
- phi = (uint64_t)(newval / 1e64);
- newval = FXSYS_fmod(newval, 1.0f);
- for (uint8_t iter = 0; iter < scale; iter++) {
- fxmath_decimal_helper_mul10(phi, pmid, plo);
- newval *= 10;
- plo += (uint64_t)newval;
- newval = FXSYS_fmod(newval, 1.0f);
- }
- plo += FXSYS_round(newval);
- fxmath_decimal_helper_normalize(phi, pmid, plo);
- m_uHi = (uint32_t)phi;
- m_uMid = (uint32_t)pmid;
- m_uLo = (uint32_t)plo;
- m_uFlags = FXMATH_DECIMAL_MAKEFLAGS(val < 0 && IsNotZero(), scale);
-}
-CFX_Decimal::CFX_Decimal(const CFX_WideStringC& strObj) {
- const wchar_t* str = strObj.c_str();
- const wchar_t* strBound = str + strObj.GetLength();
- bool pointmet = 0;
- bool negmet = 0;
- uint8_t scale = 0;
- m_uHi = m_uMid = m_uLo = 0;
- while (str != strBound && *str == ' ') {
- str++;
- }
- if (str != strBound && *str == '-') {
- negmet = 1;
- str++;
- } else if (str != strBound && *str == '+') {
- str++;
- }
- while (str != strBound && ((*str >= '0' && *str <= '9') || *str == '.') &&
- scale < FXMATH_DECIMAL_SCALELIMIT) {
- if (*str == '.') {
- if (pointmet) {
- goto cont;
- }
- pointmet = 1;
- } else {
- m_uHi = m_uHi * 0xA + FXMATH_DECIMAL_RSHIFT32BIT((uint64_t)m_uMid * 0xA);
- m_uMid = m_uMid * 0xA + FXMATH_DECIMAL_RSHIFT32BIT((uint64_t)m_uLo * 0xA);
- m_uLo = m_uLo * 0xA + (*str - '0');
- if (pointmet) {
- scale++;
- }
- }
- cont:
- str++;
- }
- m_uFlags = FXMATH_DECIMAL_MAKEFLAGS(negmet && IsNotZero(), scale);
-}
-
-CFX_Decimal::CFX_Decimal(const CFX_ByteStringC& strObj) {
- *this = CFX_Decimal(CFX_WideString::FromLocal(strObj).AsStringC());
-}
-
-CFX_Decimal::operator CFX_WideString() const {
- CFX_WideString retString;
- CFX_WideString tmpbuf;
- uint64_t phi = m_uHi, pmid = m_uMid, plo = m_uLo;
- while (phi || pmid || plo) {
- tmpbuf += fxmath_decimal_helper_div10(phi, pmid, plo) + '0';
- }
- uint8_t outputlen = (uint8_t)tmpbuf.GetLength();
- uint8_t scale = (uint8_t)FXMATH_DECIMAL_FLAGS2SCALE(m_uFlags);
- while (scale >= outputlen) {
- tmpbuf += '0';
- outputlen++;
- }
- if (FXMATH_DECIMAL_FLAGS2NEG(m_uFlags) && IsNotZero()) {
- retString += '-';
- }
- for (uint8_t idx = 0; idx < outputlen; idx++) {
- if (idx == (outputlen - scale) && scale != 0) {
- retString += '.';
- }
- retString += tmpbuf[outputlen - 1 - idx];
- }
- return retString;
-}
-CFX_Decimal::operator double() const {
- double pow = (double)(1 << 16) * (1 << 16);
- double base =
- ((double)m_uHi) * pow * pow + ((double)m_uMid) * pow + ((double)m_uLo);
- int8_t scale = FXMATH_DECIMAL_FLAGS2SCALE(m_uFlags);
- bool bNeg = FXMATH_DECIMAL_FLAGS2NEG(m_uFlags);
- return (bNeg ? -1 : 1) * base * ::pow(10.0, -scale);
-}
-void CFX_Decimal::SetScale(uint8_t newscale) {
- uint8_t oldscale = FXMATH_DECIMAL_FLAGS2SCALE(m_uFlags);
- if (newscale > oldscale) {
- uint64_t phi = m_uHi, pmid = m_uMid, plo = m_uLo;
- for (uint8_t iter = 0; iter < newscale - oldscale; iter++) {
- fxmath_decimal_helper_mul10(phi, pmid, plo);
- }
- m_uHi = (uint32_t)phi;
- m_uMid = (uint32_t)pmid;
- m_uLo = (uint32_t)plo;
- m_uFlags = FXMATH_DECIMAL_MAKEFLAGS(
- FXMATH_DECIMAL_FLAGS2NEG(m_uFlags) && IsNotZero(), newscale);
- } else if (newscale < oldscale) {
- uint64_t phi, pmid, plo;
- phi = 0, pmid = 0, plo = 5;
- {
- for (uint8_t iter = 0; iter < oldscale - newscale - 1; iter++) {
- fxmath_decimal_helper_mul10(phi, pmid, plo);
- }
- }
- phi += m_uHi;
- pmid += m_uMid;
- plo += m_uLo;
- fxmath_decimal_helper_normalize(phi, pmid, plo);
- {
- for (uint8_t iter = 0; iter < oldscale - newscale; iter++) {
- fxmath_decimal_helper_div10(phi, pmid, plo);
- }
- }
- m_uHi = (uint32_t)phi;
- m_uMid = (uint32_t)pmid;
- m_uLo = (uint32_t)plo;
- m_uFlags = FXMATH_DECIMAL_MAKEFLAGS(
- FXMATH_DECIMAL_FLAGS2NEG(m_uFlags) && IsNotZero(), newscale);
- }
-}
-uint8_t CFX_Decimal::GetScale() {
- uint8_t oldscale = FXMATH_DECIMAL_FLAGS2SCALE(m_uFlags);
- return oldscale;
-}
-void CFX_Decimal::SetAbs() {
- m_uFlags &= ~FXMATH_DECIMAL_NEGMASK;
-}
-void CFX_Decimal::SetNegate() {
- if (IsNotZero()) {
- m_uFlags ^= FXMATH_DECIMAL_NEGMASK;
- }
-}
-void CFX_Decimal::FloorOrCeil(bool bFloor) {
- uint64_t nums[3] = {m_uLo, m_uMid, m_uHi};
- bool bDataLoss = false;
- for (int i = FXMATH_DECIMAL_FLAGS2SCALE(m_uFlags); i > 0; i--) {
- bDataLoss = fxmath_decimal_helper_div10_any(nums, 3) || bDataLoss;
- }
- if (bDataLoss && (bFloor ? FXMATH_DECIMAL_FLAGS2NEG(m_uFlags)
- : !FXMATH_DECIMAL_FLAGS2NEG(m_uFlags))) {
- fxmath_decimal_helper_inc_any(nums, 3);
- }
- m_uHi = (uint32_t)nums[2];
- m_uMid = (uint32_t)nums[1];
- m_uLo = (uint32_t)nums[0];
- m_uFlags = FXMATH_DECIMAL_MAKEFLAGS(
- FXMATH_DECIMAL_FLAGS2NEG(m_uFlags) && IsNotZero(), 0);
-}
-void CFX_Decimal::SetFloor() {
- FloorOrCeil(true);
-}
-void CFX_Decimal::SetCeiling() {
- FloorOrCeil(false);
-}
-void CFX_Decimal::SetTruncate() {
- FloorOrCeil(!FXMATH_DECIMAL_FLAGS2NEG(m_uFlags));
-}
-void CFX_Decimal::Swap(CFX_Decimal& val) {
- uint32_t tmp;
- tmp = m_uHi;
- m_uHi = val.m_uHi;
- val.m_uHi = tmp;
- tmp = m_uMid;
- m_uMid = val.m_uMid;
- val.m_uMid = tmp;
- tmp = m_uLo;
- m_uLo = val.m_uLo;
- val.m_uLo = tmp;
- tmp = m_uFlags;
- m_uFlags = val.m_uFlags;
- val.m_uFlags = tmp;
-}
-int8_t CFX_Decimal::Compare(const CFX_Decimal& val) const {
- CFX_Decimal lhs = *this, rhs = val;
- int8_t retVal = 0;
- if (FXMATH_DECIMAL_FLAGS2SCALE(lhs.m_uFlags) !=
- FXMATH_DECIMAL_FLAGS2SCALE(rhs.m_uFlags)) {
- uint8_t scale = std::min(FXMATH_DECIMAL_FLAGS2SCALE(lhs.m_uFlags),
- FXMATH_DECIMAL_FLAGS2SCALE(rhs.m_uFlags));
- lhs.SetScale(scale);
- rhs.SetScale(scale);
- }
- retVal = -(FXMATH_DECIMAL_FLAGS2NEG(lhs.m_uFlags) -
- FXMATH_DECIMAL_FLAGS2NEG(rhs.m_uFlags));
- if (retVal) {
- return retVal;
- }
- retVal = fxmath_decimal_helper_raw_compare(lhs.m_uHi, lhs.m_uMid, lhs.m_uLo,
- rhs.m_uHi, rhs.m_uMid, rhs.m_uLo);
- return (FXMATH_DECIMAL_FLAGS2NEG(lhs.m_uFlags) ? -retVal : retVal);
-}
-CFX_Decimal CFX_Decimal::AddOrMinus(const CFX_Decimal& val,
- bool isAdding) const {
- CFX_Decimal lhs = *this, rhs = val;
- if (FXMATH_DECIMAL_FLAGS2SCALE(lhs.m_uFlags) !=
- FXMATH_DECIMAL_FLAGS2SCALE(rhs.m_uFlags)) {
- uint8_t scale = std::max(FXMATH_DECIMAL_FLAGS2SCALE(lhs.m_uFlags),
- FXMATH_DECIMAL_FLAGS2SCALE(rhs.m_uFlags));
- lhs.SetScale(scale);
- rhs.SetScale(scale);
- }
- if (!isAdding) {
- rhs.SetNegate();
- }
- if (FXMATH_DECIMAL_FLAGS2NEG(lhs.m_uFlags) ==
- FXMATH_DECIMAL_FLAGS2NEG(rhs.m_uFlags)) {
- uint64_t phi = lhs.m_uHi, pmid = lhs.m_uMid, plo = lhs.m_uLo;
- phi += rhs.m_uHi;
- pmid += rhs.m_uMid;
- plo += rhs.m_uLo;
- fxmath_decimal_helper_normalize(phi, pmid, plo);
- if (FXMATH_DECIMAL_RSHIFT32BIT(phi) &&
- FXMATH_DECIMAL_FLAGS2SCALE(lhs.m_uFlags) != 0) {
- fxmath_decimal_helper_div10(phi, pmid, plo);
- lhs.m_uFlags = FXMATH_DECIMAL_MAKEFLAGS(
- FXMATH_DECIMAL_FLAGS2NEG(lhs.m_uFlags),
- FXMATH_DECIMAL_FLAGS2SCALE(lhs.m_uFlags) - 1);
- }
- lhs.m_uHi = (uint32_t)phi;
- lhs.m_uMid = (uint32_t)pmid;
- lhs.m_uLo = (uint32_t)plo;
- return lhs;
- } else {
- if (fxmath_decimal_helper_raw_compare(lhs.m_uHi, lhs.m_uMid, lhs.m_uLo,
- rhs.m_uHi, rhs.m_uMid,
- rhs.m_uLo) < 0) {
- lhs.Swap(rhs);
- }
- lhs.m_uHi -= rhs.m_uHi;
- if (lhs.m_uMid < rhs.m_uMid) {
- lhs.m_uHi--;
- }
- lhs.m_uMid -= rhs.m_uMid;
- if (lhs.m_uLo < rhs.m_uLo) {
- if (!lhs.m_uMid) {
- lhs.m_uHi--;
- }
- lhs.m_uMid--;
- }
- lhs.m_uLo -= rhs.m_uLo;
- return lhs;
- }
-}
-CFX_Decimal CFX_Decimal::Multiply(const CFX_Decimal& val) const {
- uint64_t a[3] = {m_uLo, m_uMid, m_uHi},
- b[3] = {val.m_uLo, val.m_uMid, val.m_uHi};
- uint64_t c[6];
- fxmath_decimal_helper_raw_mul(a, 3, b, 3, c, 6);
- bool neg = FXMATH_DECIMAL_FLAGS2NEG(m_uFlags) ^
- FXMATH_DECIMAL_FLAGS2NEG(val.m_uFlags);
- uint8_t scale = FXMATH_DECIMAL_FLAGS2SCALE(m_uFlags) +
- FXMATH_DECIMAL_FLAGS2SCALE(val.m_uFlags);
- fxmath_decimal_helper_shrinkintorange(c, 6, 3, scale);
- return CFX_Decimal((uint32_t)c[0], (uint32_t)c[1], (uint32_t)c[2], neg,
- scale);
-}
-CFX_Decimal CFX_Decimal::Divide(const CFX_Decimal& val) const {
- if (!val.IsNotZero()) {
- return CFX_Decimal();
- }
- bool neg = FXMATH_DECIMAL_FLAGS2NEG(m_uFlags) ^
- FXMATH_DECIMAL_FLAGS2NEG(val.m_uFlags);
- uint64_t a[7] = {m_uLo, m_uMid, m_uHi},
- b[3] = {val.m_uLo, val.m_uMid, val.m_uHi}, c[7] = {0};
- uint8_t scale = 0;
- if (FXMATH_DECIMAL_FLAGS2SCALE(m_uFlags) <
- FXMATH_DECIMAL_FLAGS2SCALE(val.m_uFlags)) {
- for (int i = FXMATH_DECIMAL_FLAGS2SCALE(val.m_uFlags) -
- FXMATH_DECIMAL_FLAGS2SCALE(m_uFlags);
- i > 0; i--) {
- fxmath_decimal_helper_mul10_any(a, 7);
- }
- } else {
- scale = FXMATH_DECIMAL_FLAGS2SCALE(m_uFlags) -
- FXMATH_DECIMAL_FLAGS2SCALE(val.m_uFlags);
- }
- uint8_t minscale = scale;
- if (!IsNotZero()) {
- return CFX_Decimal(0, 0, 0, 0, minscale);
- }
- while (!a[6]) {
- fxmath_decimal_helper_mul10_any(a, 7);
- scale++;
- }
- fxmath_decimal_helper_div10_any(a, 7);
- scale--;
- fxmath_decimal_helper_raw_div(a, 6, b, 3, c, 7);
- fxmath_decimal_helper_shrinkintorange(c, 6, 3, scale);
- fxmath_decimal_helper_truncate(c[2], c[1], c[0], scale, minscale);
- return CFX_Decimal((uint32_t)c[0], (uint32_t)c[1], (uint32_t)c[2], neg,
- scale);
-}
-CFX_Decimal CFX_Decimal::Modulus(const CFX_Decimal& val) const {
- CFX_Decimal lhs = *this, rhs_abs = val;
- rhs_abs.SetAbs();
- if (!rhs_abs.IsNotZero()) {
- return *this;
- }
- while (true) {
- CFX_Decimal lhs_abs = lhs;
- lhs_abs.SetAbs();
- if (lhs_abs < rhs_abs) {
- break;
- }
- CFX_Decimal quot = lhs / rhs_abs;
- quot.SetTruncate();
- lhs = lhs - quot * rhs_abs;
- }
- return lhs;
-}
-bool CFX_Decimal::operator==(const CFX_Decimal& val) const {
- return Compare(val) == 0;
-}
-bool CFX_Decimal::operator<=(const CFX_Decimal& val) const {
- return Compare(val) <= 0;
-}
-bool CFX_Decimal::operator>=(const CFX_Decimal& val) const {
- return Compare(val) >= 0;
-}
-bool CFX_Decimal::operator!=(const CFX_Decimal& val) const {
- return Compare(val) != 0;
-}
-bool CFX_Decimal::operator<(const CFX_Decimal& val) const {
- return Compare(val) < 0;
-}
-bool CFX_Decimal::operator>(const CFX_Decimal& val) const {
- return Compare(val) > 0;
-}
-CFX_Decimal CFX_Decimal::operator+(const CFX_Decimal& val) const {
- return AddOrMinus(val, true);
-}
-CFX_Decimal CFX_Decimal::operator-(const CFX_Decimal& val) const {
- return AddOrMinus(val, false);
-}
-CFX_Decimal CFX_Decimal::operator*(const CFX_Decimal& val) const {
- return Multiply(val);
-}
-CFX_Decimal CFX_Decimal::operator/(const CFX_Decimal& val) const {
- return Divide(val);
-}
-CFX_Decimal CFX_Decimal::operator%(const CFX_Decimal& val) const {
- return Modulus(val);
-}
diff --git a/xfa/fgas/localization/fgas_locale.h b/xfa/fgas/localization/fgas_locale.h
index 42f20f1c0f..ffcbb36b8d 100644
--- a/xfa/fgas/localization/fgas_locale.h
+++ b/xfa/fgas/localization/fgas_locale.h
@@ -80,18 +80,6 @@ class IFX_Locale {
CFX_WideString& wsPattern) const = 0;
};
-class IFX_LocaleMgr {
- public:
- virtual ~IFX_LocaleMgr() {}
-
- virtual uint16_t GetDefLocaleID() const = 0;
- virtual IFX_Locale* GetDefLocale() = 0;
- virtual IFX_Locale* GetLocaleByName(const CFX_WideString& wsLocaleName) = 0;
-
- protected:
- virtual std::unique_ptr<IFX_Locale> GetLocale(uint16_t lcid) = 0;
-};
-
bool FX_DateFromCanonical(const CFX_WideString& wsDate, CFX_Unitime& datetime);
bool FX_TimeFromCanonical(const CFX_WideStringC& wsTime,
CFX_Unitime& datetime,
@@ -102,45 +90,28 @@ class CFX_Decimal {
explicit CFX_Decimal(uint32_t val);
explicit CFX_Decimal(uint64_t val);
explicit CFX_Decimal(int32_t val);
- explicit CFX_Decimal(int64_t val);
- explicit CFX_Decimal(float val, uint8_t scale = 3);
+ explicit CFX_Decimal(float val, uint8_t scale);
explicit CFX_Decimal(const CFX_WideStringC& str);
- explicit CFX_Decimal(const CFX_ByteStringC& str);
+
operator CFX_WideString() const;
operator double() const;
- bool operator==(const CFX_Decimal& val) const;
- bool operator<=(const CFX_Decimal& val) const;
- bool operator>=(const CFX_Decimal& val) const;
- bool operator!=(const CFX_Decimal& val) const;
- bool operator<(const CFX_Decimal& val) const;
- bool operator>(const CFX_Decimal& val) const;
- CFX_Decimal operator+(const CFX_Decimal& val) const;
- CFX_Decimal operator-(const CFX_Decimal& val) const;
+
CFX_Decimal operator*(const CFX_Decimal& val) const;
CFX_Decimal operator/(const CFX_Decimal& val) const;
- CFX_Decimal operator%(const CFX_Decimal& val) const;
+
void SetScale(uint8_t newScale);
uint8_t GetScale();
- void SetAbs();
void SetNegate();
- void SetFloor();
- void SetCeiling();
- void SetTruncate();
- protected:
+ private:
CFX_Decimal(uint32_t hi, uint32_t mid, uint32_t lo, bool neg, uint8_t scale);
- inline bool IsNotZero() const { return m_uHi || m_uMid || m_uLo; }
- inline int8_t Compare(const CFX_Decimal& val) const;
- inline void Swap(CFX_Decimal& val);
- inline void FloorOrCeil(bool bFloor);
- CFX_Decimal AddOrMinus(const CFX_Decimal& val, bool isAdding) const;
- CFX_Decimal Multiply(const CFX_Decimal& val) const;
- CFX_Decimal Divide(const CFX_Decimal& val) const;
- CFX_Decimal Modulus(const CFX_Decimal& val) const;
- uint32_t m_uFlags;
+ bool IsNotZero() const { return m_uHi || m_uMid || m_uLo; }
+ void Swap(CFX_Decimal& val);
+
uint32_t m_uHi;
uint32_t m_uLo;
uint32_t m_uMid;
+ uint32_t m_uFlags;
};
#endif // XFA_FGAS_LOCALIZATION_FGAS_LOCALE_H_
diff --git a/xfa/fxfa/parser/xfa_localemgr.h b/xfa/fxfa/parser/xfa_localemgr.h
index eb405dcfc7..3336d713e0 100644
--- a/xfa/fxfa/parser/xfa_localemgr.h
+++ b/xfa/fxfa/parser/xfa_localemgr.h
@@ -33,21 +33,20 @@ class IFX_Locale;
#define XFA_LANGID_nl_NL 0x0413
#define XFA_LANGID_ru_RU 0x0419
-class CXFA_LocaleMgr : public IFX_LocaleMgr {
+class CXFA_LocaleMgr {
public:
CXFA_LocaleMgr(CXFA_Node* pLocaleSet, CFX_WideString wsDeflcid);
- ~CXFA_LocaleMgr() override;
+ ~CXFA_LocaleMgr();
- // IFX_LocaleMgr
- uint16_t GetDefLocaleID() const override;
- IFX_Locale* GetDefLocale() override;
- IFX_Locale* GetLocaleByName(const CFX_WideString& wsLocaleName) override;
+ uint16_t GetDefLocaleID() const;
+ IFX_Locale* GetDefLocale();
+ IFX_Locale* GetLocaleByName(const CFX_WideString& wsLocaleName);
void SetDefLocale(IFX_Locale* pLocale);
CFX_WideStringC GetConfigLocaleName(CXFA_Node* pConfig);
- protected:
- std::unique_ptr<IFX_Locale> GetLocale(uint16_t lcid) override;
+ private:
+ std::unique_ptr<IFX_Locale> GetLocale(uint16_t lcid);
std::vector<std::unique_ptr<IFX_Locale>> m_LocaleArray;
std::vector<std::unique_ptr<IFX_Locale>> m_XMLLocaleArray;
diff --git a/xfa/fxfa/parser/xfa_localevalue.cpp b/xfa/fxfa/parser/xfa_localevalue.cpp
index 0e7b8c9c2f..1012896089 100644
--- a/xfa/fxfa/parser/xfa_localevalue.cpp
+++ b/xfa/fxfa/parser/xfa_localevalue.cpp
@@ -11,7 +11,7 @@
#include "core/fxcrt/fx_ext.h"
#include "third_party/base/ptr_util.h"
#include "third_party/base/stl_util.h"
-#include "xfa/fgas/localization/fgas_localeimp.h"
+#include "xfa/fgas/localization/cfx_formatstring.h"
#include "xfa/fxfa/parser/cxfa_document.h"
#include "xfa/fxfa/parser/xfa_localemgr.h"
#include "xfa/fxfa/parser/xfa_object.h"
@@ -91,7 +91,7 @@ bool CXFA_LocaleValue::ValidateValue(const CFX_WideString& wsValue,
if (pLocale)
m_pLocaleMgr->SetDefLocale(pLocale);
- auto pFormat = pdfium::MakeUnique<CFX_FormatString>(m_pLocaleMgr, false);
+ auto pFormat = pdfium::MakeUnique<CFX_FormatString>(m_pLocaleMgr);
std::vector<CFX_WideString> wsPatterns;
pFormat->SplitFormatString(wsPattern, wsPatterns);
@@ -464,7 +464,7 @@ bool CXFA_LocaleValue::FormatPatterns(CFX_WideString& wsResult,
const CFX_WideString& wsFormat,
IFX_Locale* pLocale,
XFA_VALUEPICTURE eValueType) const {
- auto pFormat = pdfium::MakeUnique<CFX_FormatString>(m_pLocaleMgr, false);
+ auto pFormat = pdfium::MakeUnique<CFX_FormatString>(m_pLocaleMgr);
std::vector<CFX_WideString> wsPatterns;
pFormat->SplitFormatString(wsFormat, wsPatterns);
wsResult.clear();
@@ -486,7 +486,7 @@ bool CXFA_LocaleValue::FormatSinglePattern(CFX_WideString& wsResult,
wsResult.clear();
bool bRet = false;
- auto pFormat = pdfium::MakeUnique<CFX_FormatString>(m_pLocaleMgr, false);
+ auto pFormat = pdfium::MakeUnique<CFX_FormatString>(m_pLocaleMgr);
FX_LOCALECATEGORY eCategory = pFormat->GetCategory(wsFormat);
eCategory = XFA_ValugeCategory(eCategory, m_dwType);
switch (eCategory) {
@@ -793,7 +793,7 @@ bool CXFA_LocaleValue::ParsePatternValue(const CFX_WideString& wsValue,
if (pLocale)
m_pLocaleMgr->SetDefLocale(pLocale);
- auto pFormat = pdfium::MakeUnique<CFX_FormatString>(m_pLocaleMgr, false);
+ auto pFormat = pdfium::MakeUnique<CFX_FormatString>(m_pLocaleMgr);
std::vector<CFX_WideString> wsPatterns;
pFormat->SplitFormatString(wsPattern, wsPatterns);
bool bRet = false;
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-01 01:51:09 +0000