blob: 0281d4dab4218a50175d2295b4b363fb16aa0018 [file] [log] [blame] [edit]
// Copyright 2014 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 "fxjs/xfa/cfxjse_formcalc_context.h"
#include <stdlib.h>
#include <algorithm>
#include <cctype>
#include <sstream>
#include <utility>
#include "core/fxcrt/cfx_datetime.h"
#include "core/fxcrt/cfx_widetextbuf.h"
#include "core/fxcrt/fx_extension.h"
#include "core/fxcrt/fx_random.h"
#include "fxjs/fxv8.h"
#include "fxjs/xfa/cfxjse_class.h"
#include "fxjs/xfa/cfxjse_context.h"
#include "fxjs/xfa/cfxjse_engine.h"
#include "fxjs/xfa/cfxjse_value.h"
#include "fxjs/xfa/cjx_object.h"
#include "third_party/base/check.h"
#include "third_party/base/optional.h"
#include "third_party/base/stl_util.h"
#include "xfa/fgas/crt/cfgas_decimal.h"
#include "xfa/fxfa/cxfa_ffnotify.h"
#include "xfa/fxfa/fm2js/cxfa_fmparser.h"
#include "xfa/fxfa/fm2js/cxfa_fmtojavascriptdepth.h"
#include "xfa/fxfa/parser/cxfa_document.h"
#include "xfa/fxfa/parser/cxfa_localevalue.h"
#include "xfa/fxfa/parser/cxfa_node.h"
#include "xfa/fxfa/parser/cxfa_thisproxy.h"
#include "xfa/fxfa/parser/cxfa_timezoneprovider.h"
#include "xfa/fxfa/parser/gced_locale_iface.h"
#include "xfa/fxfa/parser/xfa_utils.h"
using pdfium::fxjse::kClassTag;
using pdfium::fxjse::kFuncTag;
namespace {
const double kFinancialPrecision = 0.00000001;
const wchar_t kStrCode[] = L"0123456789abcdef";
struct XFA_FMHtmlReserveCode {
uint16_t m_uCode;
// Inline string data reduces size for small strings.
const char m_htmlReserve[10];
};
// Sorted by |m_htmlReserve|.
const XFA_FMHtmlReserveCode kReservesForDecode[] = {
{198, "AElig"}, {193, "Aacute"}, {194, "Acirc"}, {192, "Agrave"},
{913, "Alpha"}, {197, "Aring"}, {195, "Atilde"}, {196, "Auml"},
{914, "Beta"}, {199, "Ccedil"}, {935, "Chi"}, {8225, "Dagger"},
{916, "Delta"}, {208, "ETH"}, {201, "Eacute"}, {202, "Ecirc"},
{200, "Egrave"}, {917, "Epsilon"}, {919, "Eta"}, {203, "Euml"},
{915, "Gamma"}, {922, "Kappa"}, {923, "Lambda"}, {924, "Mu"},
{209, "Ntilde"}, {925, "Nu"}, {338, "OElig"}, {211, "Oacute"},
{212, "Ocirc"}, {210, "Ograve"}, {937, "Omega"}, {927, "Omicron"},
{216, "Oslash"}, {213, "Otilde"}, {214, "Ouml"}, {934, "Phi"},
{928, "Pi"}, {936, "Psi"}, {929, "Rho"}, {352, "Scaron"},
{931, "Sigma"}, {222, "THORN"}, {932, "Tau"}, {920, "Theta"},
{218, "Uacute"}, {219, "Ucirc"}, {217, "Ugrave"}, {933, "Upsilon"},
{220, "Uuml"}, {926, "Xi"}, {221, "Yacute"}, {376, "Yuml"},
{918, "Zeta"}, {225, "aacute"}, {226, "acirc"}, {180, "acute"},
{230, "aelig"}, {224, "agrave"}, {8501, "alefsym"}, {945, "alpha"},
{38, "amp"}, {8743, "and"}, {8736, "ang"}, {39, "apos"},
{229, "aring"}, {8776, "asymp"}, {227, "atilde"}, {228, "auml"},
{8222, "bdquo"}, {946, "beta"}, {166, "brvbar"}, {8226, "bull"},
{8745, "cap"}, {231, "ccedil"}, {184, "cedil"}, {162, "cent"},
{967, "chi"}, {710, "circ"}, {9827, "clubs"}, {8773, "cong"},
{169, "copy"}, {8629, "crarr"}, {8746, "cup"}, {164, "current"},
{8659, "dArr"}, {8224, "dagger"}, {8595, "darr"}, {176, "deg"},
{948, "delta"}, {9830, "diams"}, {247, "divide"}, {233, "eacute"},
{234, "ecirc"}, {232, "egrave"}, {8709, "empty"}, {8195, "emsp"},
{8194, "ensp"}, {949, "epsilon"}, {8801, "equiv"}, {951, "eta"},
{240, "eth"}, {235, "euml"}, {8364, "euro"}, {8707, "exist"},
{402, "fnof"}, {8704, "forall"}, {189, "frac12"}, {188, "frac14"},
{190, "frac34"}, {8260, "frasl"}, {947, "gamma"}, {8805, "ge"},
{62, "gt"}, {8660, "hArr"}, {8596, "harr"}, {9829, "hearts"},
{8230, "hellip"}, {237, "iacute"}, {238, "icirc"}, {161, "iexcl"},
{236, "igrave"}, {8465, "image"}, {8734, "infin"}, {8747, "int"},
{953, "iota"}, {191, "iquest"}, {8712, "isin"}, {239, "iuml"},
{954, "kappa"}, {8656, "lArr"}, {205, "lacute"}, {955, "lambda"},
{9001, "lang"}, {171, "laquo"}, {8592, "larr"}, {8968, "lceil"},
{206, "lcirc"}, {8220, "ldquo"}, {8804, "le"}, {8970, "lfloor"},
{204, "lgrave"}, {921, "lota"}, {8727, "lowast"}, {9674, "loz"},
{8206, "lrm"}, {8249, "lsaquo"}, {8216, "lsquo"}, {60, "lt"},
{207, "luml"}, {175, "macr"}, {8212, "mdash"}, {181, "micro"},
{183, "middot"}, {8722, "minus"}, {956, "mu"}, {8711, "nabla"},
{160, "nbsp"}, {8211, "ndash"}, {8800, "ne"}, {8715, "ni"},
{172, "not"}, {8713, "notin"}, {8836, "nsub"}, {241, "ntilde"},
{957, "nu"}, {243, "oacute"}, {244, "ocirc"}, {339, "oelig"},
{242, "ograve"}, {8254, "oline"}, {969, "omega"}, {959, "omicron"},
{8853, "oplus"}, {8744, "or"}, {170, "ordf"}, {186, "ordm"},
{248, "oslash"}, {245, "otilde"}, {8855, "otimes"}, {246, "ouml"},
{182, "para"}, {8706, "part"}, {8240, "permil"}, {8869, "perp"},
{966, "phi"}, {960, "pi"}, {982, "piv"}, {177, "plusmn"},
{8242, "prime"}, {8719, "prod"}, {8733, "prop"}, {968, "psi"},
{163, "pund"}, {34, "quot"}, {8658, "rArr"}, {8730, "radic"},
{9002, "rang"}, {187, "raquo"}, {8594, "rarr"}, {8969, "rceil"},
{8476, "real"}, {174, "reg"}, {8971, "rfloor"}, {961, "rho"},
{8207, "rlm"}, {8250, "rsaquo"}, {8217, "rsquo"}, {353, "saron"},
{8218, "sbquo"}, {8901, "sdot"}, {167, "sect"}, {173, "shy"},
{963, "sigma"}, {962, "sigmaf"}, {8764, "sim"}, {9824, "spades"},
{8834, "sub"}, {8838, "sube"}, {8721, "sum"}, {8835, "sup"},
{185, "sup1"}, {178, "sup2"}, {179, "sup3"}, {8839, "supe"},
{223, "szlig"}, {964, "tau"}, {8221, "tdquo"}, {8756, "there4"},
{952, "theta"}, {977, "thetasym"}, {8201, "thinsp"}, {254, "thorn"},
{732, "tilde"}, {215, "times"}, {8482, "trade"}, {8657, "uArr"},
{250, "uacute"}, {8593, "uarr"}, {251, "ucirc"}, {249, "ugrave"},
{168, "uml"}, {978, "upsih"}, {965, "upsilon"}, {252, "uuml"},
{8472, "weierp"}, {958, "xi"}, {253, "yacute"}, {165, "yen"},
{255, "yuml"}, {950, "zeta"}, {8205, "zwj"}, {8204, "zwnj"},
};
// Sorted by |m_uCode|.
const XFA_FMHtmlReserveCode kReservesForEncode[] = {
{34, "quot"}, {38, "amp"}, {39, "apos"}, {60, "lt"},
{62, "gt"}, {160, "nbsp"}, {161, "iexcl"}, {162, "cent"},
{163, "pund"}, {164, "current"}, {165, "yen"}, {166, "brvbar"},
{167, "sect"}, {168, "uml"}, {169, "copy"}, {170, "ordf"},
{171, "laquo"}, {172, "not"}, {173, "shy"}, {174, "reg"},
{175, "macr"}, {176, "deg"}, {177, "plusmn"}, {178, "sup2"},
{179, "sup3"}, {180, "acute"}, {181, "micro"}, {182, "para"},
{183, "middot"}, {184, "cedil"}, {185, "sup1"}, {186, "ordm"},
{187, "raquo"}, {188, "frac14"}, {189, "frac12"}, {190, "frac34"},
{191, "iquest"}, {192, "Agrave"}, {193, "Aacute"}, {194, "Acirc"},
{195, "Atilde"}, {196, "Auml"}, {197, "Aring"}, {198, "AElig"},
{199, "Ccedil"}, {200, "Egrave"}, {201, "Eacute"}, {202, "Ecirc"},
{203, "Euml"}, {204, "lgrave"}, {205, "lacute"}, {206, "lcirc"},
{207, "luml"}, {208, "ETH"}, {209, "Ntilde"}, {210, "Ograve"},
{211, "Oacute"}, {212, "Ocirc"}, {213, "Otilde"}, {214, "Ouml"},
{215, "times"}, {216, "Oslash"}, {217, "Ugrave"}, {218, "Uacute"},
{219, "Ucirc"}, {220, "Uuml"}, {221, "Yacute"}, {222, "THORN"},
{223, "szlig"}, {224, "agrave"}, {225, "aacute"}, {226, "acirc"},
{227, "atilde"}, {228, "auml"}, {229, "aring"}, {230, "aelig"},
{231, "ccedil"}, {232, "egrave"}, {233, "eacute"}, {234, "ecirc"},
{235, "euml"}, {236, "igrave"}, {237, "iacute"}, {238, "icirc"},
{239, "iuml"}, {240, "eth"}, {241, "ntilde"}, {242, "ograve"},
{243, "oacute"}, {244, "ocirc"}, {245, "otilde"}, {246, "ouml"},
{247, "divide"}, {248, "oslash"}, {249, "ugrave"}, {250, "uacute"},
{251, "ucirc"}, {252, "uuml"}, {253, "yacute"}, {254, "thorn"},
{255, "yuml"}, {338, "OElig"}, {339, "oelig"}, {352, "Scaron"},
{353, "saron"}, {376, "Yuml"}, {402, "fnof"}, {710, "circ"},
{732, "tilde"}, {913, "Alpha"}, {914, "Beta"}, {915, "Gamma"},
{916, "Delta"}, {917, "Epsilon"}, {918, "Zeta"}, {919, "Eta"},
{920, "Theta"}, {921, "lota"}, {922, "Kappa"}, {923, "Lambda"},
{924, "Mu"}, {925, "Nu"}, {926, "Xi"}, {927, "Omicron"},
{928, "Pi"}, {929, "Rho"}, {931, "Sigma"}, {932, "Tau"},
{933, "Upsilon"}, {934, "Phi"}, {935, "Chi"}, {936, "Psi"},
{937, "Omega"}, {945, "alpha"}, {946, "beta"}, {947, "gamma"},
{948, "delta"}, {949, "epsilon"}, {950, "zeta"}, {951, "eta"},
{952, "theta"}, {953, "iota"}, {954, "kappa"}, {955, "lambda"},
{956, "mu"}, {957, "nu"}, {958, "xi"}, {959, "omicron"},
{960, "pi"}, {961, "rho"}, {962, "sigmaf"}, {963, "sigma"},
{964, "tau"}, {965, "upsilon"}, {966, "phi"}, {967, "chi"},
{968, "psi"}, {969, "omega"}, {977, "thetasym"}, {978, "upsih"},
{982, "piv"}, {8194, "ensp"}, {8195, "emsp"}, {8201, "thinsp"},
{8204, "zwnj"}, {8205, "zwj"}, {8206, "lrm"}, {8207, "rlm"},
{8211, "ndash"}, {8212, "mdash"}, {8216, "lsquo"}, {8217, "rsquo"},
{8218, "sbquo"}, {8220, "ldquo"}, {8221, "tdquo"}, {8222, "bdquo"},
{8224, "dagger"}, {8225, "Dagger"}, {8226, "bull"}, {8230, "hellip"},
{8240, "permil"}, {8242, "prime"}, {8249, "lsaquo"}, {8250, "rsaquo"},
{8254, "oline"}, {8260, "frasl"}, {8364, "euro"}, {8465, "image"},
{8472, "weierp"}, {8476, "real"}, {8482, "trade"}, {8501, "alefsym"},
{8592, "larr"}, {8593, "uarr"}, {8594, "rarr"}, {8595, "darr"},
{8596, "harr"}, {8629, "crarr"}, {8656, "lArr"}, {8657, "uArr"},
{8658, "rArr"}, {8659, "dArr"}, {8660, "hArr"}, {8704, "forall"},
{8706, "part"}, {8707, "exist"}, {8709, "empty"}, {8711, "nabla"},
{8712, "isin"}, {8713, "notin"}, {8715, "ni"}, {8719, "prod"},
{8721, "sum"}, {8722, "minus"}, {8727, "lowast"}, {8730, "radic"},
{8733, "prop"}, {8734, "infin"}, {8736, "ang"}, {8743, "and"},
{8744, "or"}, {8745, "cap"}, {8746, "cup"}, {8747, "int"},
{8756, "there4"}, {8764, "sim"}, {8773, "cong"}, {8776, "asymp"},
{8800, "ne"}, {8801, "equiv"}, {8804, "le"}, {8805, "ge"},
{8834, "sub"}, {8835, "sup"}, {8836, "nsub"}, {8838, "sube"},
{8839, "supe"}, {8853, "oplus"}, {8855, "otimes"}, {8869, "perp"},
{8901, "sdot"}, {8968, "lceil"}, {8969, "rceil"}, {8970, "lfloor"},
{8971, "rfloor"}, {9001, "lang"}, {9002, "rang"}, {9674, "loz"},
{9824, "spades"}, {9827, "clubs"}, {9829, "hearts"}, {9830, "diams"},
};
const FXJSE_FUNCTION_DESCRIPTOR kFormCalcFM2JSFunctions[] = {
{kFuncTag, "Abs", CFXJSE_FormCalcContext::Abs},
{kFuncTag, "Avg", CFXJSE_FormCalcContext::Avg},
{kFuncTag, "Ceil", CFXJSE_FormCalcContext::Ceil},
{kFuncTag, "Count", CFXJSE_FormCalcContext::Count},
{kFuncTag, "Floor", CFXJSE_FormCalcContext::Floor},
{kFuncTag, "Max", CFXJSE_FormCalcContext::Max},
{kFuncTag, "Min", CFXJSE_FormCalcContext::Min},
{kFuncTag, "Mod", CFXJSE_FormCalcContext::Mod},
{kFuncTag, "Round", CFXJSE_FormCalcContext::Round},
{kFuncTag, "Sum", CFXJSE_FormCalcContext::Sum},
{kFuncTag, "Date", CFXJSE_FormCalcContext::Date},
{kFuncTag, "Date2Num", CFXJSE_FormCalcContext::Date2Num},
{kFuncTag, "DateFmt", CFXJSE_FormCalcContext::DateFmt},
{kFuncTag, "IsoDate2Num", CFXJSE_FormCalcContext::IsoDate2Num},
{kFuncTag, "IsoTime2Num", CFXJSE_FormCalcContext::IsoTime2Num},
{kFuncTag, "LocalDateFmt", CFXJSE_FormCalcContext::LocalDateFmt},
{kFuncTag, "LocalTimeFmt", CFXJSE_FormCalcContext::LocalTimeFmt},
{kFuncTag, "Num2Date", CFXJSE_FormCalcContext::Num2Date},
{kFuncTag, "Num2GMTime", CFXJSE_FormCalcContext::Num2GMTime},
{kFuncTag, "Num2Time", CFXJSE_FormCalcContext::Num2Time},
{kFuncTag, "Time", CFXJSE_FormCalcContext::Time},
{kFuncTag, "Time2Num", CFXJSE_FormCalcContext::Time2Num},
{kFuncTag, "TimeFmt", CFXJSE_FormCalcContext::TimeFmt},
{kFuncTag, "Apr", CFXJSE_FormCalcContext::Apr},
{kFuncTag, "Cterm", CFXJSE_FormCalcContext::CTerm},
{kFuncTag, "FV", CFXJSE_FormCalcContext::FV},
{kFuncTag, "Ipmt", CFXJSE_FormCalcContext::IPmt},
{kFuncTag, "NPV", CFXJSE_FormCalcContext::NPV},
{kFuncTag, "Pmt", CFXJSE_FormCalcContext::Pmt},
{kFuncTag, "PPmt", CFXJSE_FormCalcContext::PPmt},
{kFuncTag, "PV", CFXJSE_FormCalcContext::PV},
{kFuncTag, "Rate", CFXJSE_FormCalcContext::Rate},
{kFuncTag, "Term", CFXJSE_FormCalcContext::Term},
{kFuncTag, "Choose", CFXJSE_FormCalcContext::Choose},
{kFuncTag, "Exists", CFXJSE_FormCalcContext::Exists},
{kFuncTag, "HasValue", CFXJSE_FormCalcContext::HasValue},
{kFuncTag, "Oneof", CFXJSE_FormCalcContext::Oneof},
{kFuncTag, "Within", CFXJSE_FormCalcContext::Within},
{kFuncTag, "If", CFXJSE_FormCalcContext::If},
{kFuncTag, "Eval", CFXJSE_FormCalcContext::Eval},
{kFuncTag, "Translate", CFXJSE_FormCalcContext::eval_translation},
{kFuncTag, "Ref", CFXJSE_FormCalcContext::Ref},
{kFuncTag, "UnitType", CFXJSE_FormCalcContext::UnitType},
{kFuncTag, "UnitValue", CFXJSE_FormCalcContext::UnitValue},
{kFuncTag, "At", CFXJSE_FormCalcContext::At},
{kFuncTag, "Concat", CFXJSE_FormCalcContext::Concat},
{kFuncTag, "Decode", CFXJSE_FormCalcContext::Decode},
{kFuncTag, "Encode", CFXJSE_FormCalcContext::Encode},
{kFuncTag, "Format", CFXJSE_FormCalcContext::Format},
{kFuncTag, "Left", CFXJSE_FormCalcContext::Left},
{kFuncTag, "Len", CFXJSE_FormCalcContext::Len},
{kFuncTag, "Lower", CFXJSE_FormCalcContext::Lower},
{kFuncTag, "Ltrim", CFXJSE_FormCalcContext::Ltrim},
{kFuncTag, "Parse", CFXJSE_FormCalcContext::Parse},
{kFuncTag, "Replace", CFXJSE_FormCalcContext::Replace},
{kFuncTag, "Right", CFXJSE_FormCalcContext::Right},
{kFuncTag, "Rtrim", CFXJSE_FormCalcContext::Rtrim},
{kFuncTag, "Space", CFXJSE_FormCalcContext::Space},
{kFuncTag, "Str", CFXJSE_FormCalcContext::Str},
{kFuncTag, "Stuff", CFXJSE_FormCalcContext::Stuff},
{kFuncTag, "Substr", CFXJSE_FormCalcContext::Substr},
{kFuncTag, "Uuid", CFXJSE_FormCalcContext::Uuid},
{kFuncTag, "Upper", CFXJSE_FormCalcContext::Upper},
{kFuncTag, "WordNum", CFXJSE_FormCalcContext::WordNum},
{kFuncTag, "Get", CFXJSE_FormCalcContext::Get},
{kFuncTag, "Post", CFXJSE_FormCalcContext::Post},
{kFuncTag, "Put", CFXJSE_FormCalcContext::Put},
{kFuncTag, "pos_op", CFXJSE_FormCalcContext::positive_operator},
{kFuncTag, "neg_op", CFXJSE_FormCalcContext::negative_operator},
{kFuncTag, "log_or_op", CFXJSE_FormCalcContext::logical_or_operator},
{kFuncTag, "log_and_op", CFXJSE_FormCalcContext::logical_and_operator},
{kFuncTag, "log_not_op", CFXJSE_FormCalcContext::logical_not_operator},
{kFuncTag, "eq_op", CFXJSE_FormCalcContext::equality_operator},
{kFuncTag, "neq_op", CFXJSE_FormCalcContext::notequality_operator},
{kFuncTag, "lt_op", CFXJSE_FormCalcContext::less_operator},
{kFuncTag, "le_op", CFXJSE_FormCalcContext::lessequal_operator},
{kFuncTag, "gt_op", CFXJSE_FormCalcContext::greater_operator},
{kFuncTag, "ge_op", CFXJSE_FormCalcContext::greaterequal_operator},
{kFuncTag, "plus_op", CFXJSE_FormCalcContext::plus_operator},
{kFuncTag, "minus_op", CFXJSE_FormCalcContext::minus_operator},
{kFuncTag, "mul_op", CFXJSE_FormCalcContext::multiple_operator},
{kFuncTag, "div_op", CFXJSE_FormCalcContext::divide_operator},
{kFuncTag, "asgn_val_op", CFXJSE_FormCalcContext::assign_value_operator},
{kFuncTag, "dot_acc", CFXJSE_FormCalcContext::dot_accessor},
{kFuncTag, "dotdot_acc", CFXJSE_FormCalcContext::dotdot_accessor},
{kFuncTag, "concat_obj", CFXJSE_FormCalcContext::concat_fm_object},
{kFuncTag, "is_obj", CFXJSE_FormCalcContext::is_fm_object},
{kFuncTag, "is_ary", CFXJSE_FormCalcContext::is_fm_array},
{kFuncTag, "get_val", CFXJSE_FormCalcContext::get_fm_value},
{kFuncTag, "get_jsobj", CFXJSE_FormCalcContext::get_fm_jsobj},
{kFuncTag, "var_filter", CFXJSE_FormCalcContext::fm_var_filter},
};
const uint8_t kAltTableDate[] = {
255, 255, 255, 3, 9, 255, 255, 255, 255, 255, 255,
255, 2, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 1, 255, 255, 255, 255, 255, 255, 255, 255,
};
static_assert(pdfium::size(kAltTableDate) == L'a' - L'A' + 1,
"Invalid kAltTableDate size.");
const uint8_t kAltTableTime[] = {
14, 255, 255, 3, 9, 255, 255, 15, 255, 255, 255,
255, 6, 255, 255, 255, 255, 255, 7, 255, 255, 255,
255, 255, 1, 17, 255, 255, 255, 255, 255, 255, 255,
};
static_assert(pdfium::size(kAltTableTime) == L'a' - L'A' + 1,
"Invalid kAltTableTime size.");
void AlternateDateTimeSymbols(WideString* pPattern,
const WideString& wsAltSymbols,
bool bIsDate) {
const uint8_t* pAltTable = bIsDate ? kAltTableDate : kAltTableTime;
int32_t nLength = pPattern->GetLength();
bool bInConstRange = false;
bool bEscape = false;
int32_t i = 0;
while (i < nLength) {
wchar_t wc = (*pPattern)[i];
if (wc == L'\'') {
bInConstRange = !bInConstRange;
if (bEscape) {
i++;
} else {
pPattern->Delete(i);
nLength--;
}
bEscape = !bEscape;
continue;
}
if (!bInConstRange && wc >= L'A' && wc <= L'a') {
uint8_t nAlt = pAltTable[wc - L'A'];
if (nAlt != 255)
pPattern->SetAt(i, wsAltSymbols[nAlt]);
}
i++;
bEscape = false;
}
}
std::pair<bool, CXFA_LocaleValue::ValueType> PatternStringType(
ByteStringView bsPattern) {
WideString wsPattern = WideString::FromUTF8(bsPattern);
if (L"datetime" == wsPattern.First(8))
return {true, CXFA_LocaleValue::ValueType::kDateTime};
if (L"date" == wsPattern.First(4)) {
auto pos = wsPattern.Find(L"time");
if (pos.has_value() && pos.value() != 0)
return {true, CXFA_LocaleValue::ValueType::kDateTime};
return {true, CXFA_LocaleValue::ValueType::kDate};
}
if (L"time" == wsPattern.First(4))
return {true, CXFA_LocaleValue::ValueType::kTime};
if (L"text" == wsPattern.First(4))
return {true, CXFA_LocaleValue::ValueType::kText};
if (L"num" == wsPattern.First(3)) {
if (L"integer" == wsPattern.Substr(4, 7))
return {true, CXFA_LocaleValue::ValueType::kInteger};
if (L"decimal" == wsPattern.Substr(4, 7))
return {true, CXFA_LocaleValue::ValueType::kDecimal};
if (L"currency" == wsPattern.Substr(4, 8))
return {true, CXFA_LocaleValue::ValueType::kFloat};
if (L"percent" == wsPattern.Substr(4, 7))
return {true, CXFA_LocaleValue::ValueType::kFloat};
return {true, CXFA_LocaleValue::ValueType::kFloat};
}
CXFA_LocaleValue::ValueType type = CXFA_LocaleValue::ValueType::kNull;
wsPattern.MakeLower();
const wchar_t* pData = wsPattern.c_str();
int32_t iLength = wsPattern.GetLength();
int32_t iIndex = 0;
bool bSingleQuotation = false;
while (iIndex < iLength) {
wchar_t wsPatternChar = pData[iIndex];
if (wsPatternChar == 0x27) {
bSingleQuotation = !bSingleQuotation;
iIndex++;
continue;
}
if (bSingleQuotation) {
iIndex++;
continue;
}
if (wsPatternChar == 'h' || wsPatternChar == 'k')
return {false, CXFA_LocaleValue::ValueType::kTime};
if (wsPatternChar == 'x' || wsPatternChar == 'o' || wsPatternChar == '0')
return {false, CXFA_LocaleValue::ValueType::kText};
if (wsPatternChar == 'v' || wsPatternChar == '8' || wsPatternChar == '$')
return {false, CXFA_LocaleValue::ValueType::kFloat};
if (wsPatternChar == 'y' || wsPatternChar == 'j') {
iIndex++;
wchar_t timePatternChar;
while (iIndex < iLength) {
timePatternChar = pData[iIndex];
if (timePatternChar == 0x27) {
bSingleQuotation = !bSingleQuotation;
iIndex++;
continue;
}
if (!bSingleQuotation && timePatternChar == 't')
return {false, CXFA_LocaleValue::ValueType::kDateTime};
iIndex++;
}
return {false, CXFA_LocaleValue::ValueType::kDate};
}
if (wsPatternChar == 'a') {
type = CXFA_LocaleValue::ValueType::kText;
} else if (wsPatternChar == 'z' || wsPatternChar == 's' ||
wsPatternChar == 'e' || wsPatternChar == ',' ||
wsPatternChar == '.') {
type = CXFA_LocaleValue::ValueType::kFloat;
}
iIndex++;
}
return {false, type};
}
CFXJSE_FormCalcContext* ToFormCalcContext(CFXJSE_HostObject* pHostObj) {
return pHostObj ? pHostObj->AsFormCalcContext() : nullptr;
}
GCedLocaleIface* LocaleFromString(CXFA_Document* pDoc,
CXFA_LocaleMgr* pMgr,
ByteStringView bsLocale) {
if (!bsLocale.IsEmpty())
return pMgr->GetLocaleByName(WideString::FromUTF8(bsLocale));
CXFA_Node* pThisNode = ToNode(pDoc->GetScriptContext()->GetThisObject());
return pThisNode->GetLocale();
}
WideString FormatFromString(LocaleIface* pLocale, ByteStringView bsFormat) {
if (!bsFormat.IsEmpty())
return WideString::FromUTF8(bsFormat);
return pLocale->GetDatePattern(LocaleIface::DateTimeSubcategory::kDefault);
}
LocaleIface::DateTimeSubcategory SubCategoryFromInt(int32_t iStyle) {
switch (iStyle) {
case 1:
return LocaleIface::DateTimeSubcategory::kShort;
case 3:
return LocaleIface::DateTimeSubcategory::kLong;
case 4:
return LocaleIface::DateTimeSubcategory::kFull;
case 0:
case 2:
default:
return LocaleIface::DateTimeSubcategory::kMedium;
}
}
ByteString GetLocalDateTimeFormat(CXFA_Document* pDoc,
int32_t iStyle,
ByteStringView bsLocale,
bool bStandard,
bool bIsDate) {
CXFA_LocaleMgr* pMgr = pDoc->GetLocaleMgr();
LocaleIface* pLocale = LocaleFromString(pDoc, pMgr, bsLocale);
if (!pLocale)
return ByteString();
LocaleIface::DateTimeSubcategory category = SubCategoryFromInt(iStyle);
WideString wsLocal = bIsDate ? pLocale->GetDatePattern(category)
: pLocale->GetTimePattern(category);
if (!bStandard)
AlternateDateTimeSymbols(&wsLocal, pLocale->GetDateTimeSymbols(), bIsDate);
return wsLocal.ToUTF8();
}
bool IsWhitespace(char c) {
return c == 0x20 || c == 0x09 || c == 0x0B || c == 0x0C || c == 0x0A ||
c == 0x0D;
}
bool IsPartOfNumber(char ch) {
return std::isdigit(ch) || ch == '-' || ch == '.';
}
bool IsPartOfNumberW(wchar_t ch) {
return FXSYS_IsDecimalDigit(ch) || ch == L'-' || ch == L'.';
}
ByteString GUIDString(bool bSeparator) {
uint8_t data[16];
FX_Random_GenerateMT(reinterpret_cast<uint32_t*>(data), 4);
data[6] = (data[6] & 0x0F) | 0x40;
ByteString bsGUID;
{
// Span's lifetime must end before ReleaseBuffer() below.
pdfium::span<char> pBuf = bsGUID.GetBuffer(40);
size_t out_index = 0;
for (size_t i = 0; i < 16; ++i, out_index += 2) {
if (bSeparator && (i == 4 || i == 6 || i == 8 || i == 10))
pBuf[out_index++] = L'-';
FXSYS_IntToTwoHexChars(data[i], &pBuf[out_index]);
}
}
bsGUID.ReleaseBuffer(bSeparator ? 36 : 32);
return bsGUID;
}
bool IsIsoDateFormat(pdfium::span<const char> pData,
int32_t* pStyle,
int32_t* pYear,
int32_t* pMonth,
int32_t* pDay) {
int32_t& iStyle = *pStyle;
int32_t& iYear = *pYear;
int32_t& iMonth = *pMonth;
int32_t& iDay = *pDay;
iYear = 0;
iMonth = 1;
iDay = 1;
if (pData.size() < 4)
return false;
char szYear[5];
szYear[4] = '\0';
for (int32_t i = 0; i < 4; ++i) {
if (!std::isdigit(pData[i]))
return false;
szYear[i] = pData[i];
}
iYear = FXSYS_atoi(szYear);
iStyle = 0;
if (pData.size() == 4)
return true;
iStyle = pData[4] == '-' ? 1 : 0;
size_t iPosOff = iStyle == 0 ? 4 : 5;
if (!std::isdigit(pData[iPosOff]) || !std::isdigit(pData[iPosOff + 1]))
return false;
char szBuffer[3] = {};
szBuffer[0] = pData[iPosOff];
szBuffer[1] = pData[iPosOff + 1];
iMonth = FXSYS_atoi(szBuffer);
if (iMonth > 12 || iMonth < 1)
return false;
if (iStyle == 0) {
iPosOff += 2;
if (pData.size() == 6)
return true;
} else {
iPosOff += 3;
if (pData.size() == 7)
return true;
}
if (!std::isdigit(pData[iPosOff]) || !std::isdigit(pData[iPosOff + 1]))
return false;
szBuffer[0] = pData[iPosOff];
szBuffer[1] = pData[iPosOff + 1];
iDay = FXSYS_atoi(szBuffer);
if (iPosOff + 2 < pData.size())
return false;
if (iMonth == 2) {
bool bIsLeap = (!(iYear % 4) && (iYear % 100)) || !(iYear % 400);
return iDay <= (bIsLeap ? 29 : 28);
}
if (iMonth < 8)
return iDay <= (iMonth % 2 == 0 ? 30 : 31);
return iDay <= (iMonth % 2 == 0 ? 31 : 30);
}
bool IsIsoTimeFormat(pdfium::span<const char> pData,
int32_t* pHour,
int32_t* pMinute,
int32_t* pSecond,
int32_t* pMilliSecond,
int32_t* pZoneHour,
int32_t* pZoneMinute) {
int32_t& iHour = *pHour;
int32_t& iMinute = *pMinute;
int32_t& iSecond = *pSecond;
int32_t& iMilliSecond = *pMilliSecond;
int32_t& iZoneHour = *pZoneHour;
int32_t& iZoneMinute = *pZoneMinute;
iHour = 0;
iMinute = 0;
iSecond = 0;
iMilliSecond = 0;
iZoneHour = 0;
iZoneMinute = 0;
if (pData.empty())
return false;
size_t iZone = 0;
size_t i = 0;
while (i < pData.size()) {
if (!std::isdigit(pData[i]) && pData[i] != ':') {
iZone = i;
break;
}
++i;
}
if (i == pData.size())
iZone = pData.size();
char szBuffer[3] = {};
size_t iPos = 0;
size_t iIndex = 0;
while (iIndex < iZone) {
if (!std::isdigit(pData[iIndex]))
return false;
szBuffer[0] = pData[iIndex];
if (!std::isdigit(pData[iIndex + 1]))
return false;
szBuffer[1] = pData[iIndex + 1];
if (FXSYS_atoi(szBuffer) > 60)
return false;
if (pData[2] == ':') {
if (iPos == 0) {
iHour = FXSYS_atoi(szBuffer);
++iPos;
} else if (iPos == 1) {
iMinute = FXSYS_atoi(szBuffer);
++iPos;
} else {
iSecond = FXSYS_atoi(szBuffer);
}
iIndex += 3;
} else {
if (iPos == 0) {
iHour = FXSYS_atoi(szBuffer);
++iPos;
} else if (iPos == 1) {
iMinute = FXSYS_atoi(szBuffer);
++iPos;
} else if (iPos == 2) {
iSecond = FXSYS_atoi(szBuffer);
++iPos;
}
iIndex += 2;
}
}
if (iIndex < pData.size() && pData[iIndex] == '.') {
constexpr int kSubSecondLength = 3;
if (iIndex + kSubSecondLength >= pData.size())
return false;
++iIndex;
char szMilliSeconds[kSubSecondLength + 1];
for (int j = 0; j < kSubSecondLength; ++j) {
char c = pData[iIndex + j];
if (!std::isdigit(c))
return false;
szMilliSeconds[j] = c;
}
szMilliSeconds[kSubSecondLength] = '\0';
iMilliSecond = FXSYS_atoi(szMilliSeconds);
if (iMilliSecond > 100) {
iMilliSecond = 0;
return false;
}
iIndex += kSubSecondLength;
}
if (iIndex < pData.size() && FXSYS_towlower(pData[iIndex]) == 'z')
return true;
int32_t iSign = 1;
if (iIndex < pData.size()) {
if (pData[iIndex] == '+') {
++iIndex;
} else if (pData[iIndex] == '-') {
iSign = -1;
++iIndex;
}
}
iPos = 0;
while (iIndex < pData.size()) {
if (!std::isdigit(pData[iIndex]))
return false;
szBuffer[0] = pData[iIndex];
if (!std::isdigit(pData[iIndex + 1]))
return false;
szBuffer[1] = pData[iIndex + 1];
if (FXSYS_atoi(szBuffer) > 60)
return false;
if (pData[2] == ':') {
if (iPos == 0) {
iZoneHour = FXSYS_atoi(szBuffer);
} else if (iPos == 1) {
iZoneMinute = FXSYS_atoi(szBuffer);
}
iIndex += 3;
} else {
if (!iPos) {
iZoneHour = FXSYS_atoi(szBuffer);
++iPos;
} else if (iPos == 1) {
iZoneMinute = FXSYS_atoi(szBuffer);
++iPos;
}
iIndex += 2;
}
}
if (iIndex < pData.size())
return false;
iZoneHour *= iSign;
return true;
}
bool IsIsoDateTimeFormat(pdfium::span<const char> pData,
int32_t* pYear,
int32_t* pMonth,
int32_t* pDay,
int32_t* pHour,
int32_t* pMinute,
int32_t* pSecond,
int32_t* pMilliSecond,
int32_t* pZoneHour,
int32_t* pZoneMinute) {
int32_t& iYear = *pYear;
int32_t& iMonth = *pMonth;
int32_t& iDay = *pDay;
int32_t& iHour = *pHour;
int32_t& iMinute = *pMinute;
int32_t& iSecond = *pSecond;
int32_t& iMilliSecond = *pMilliSecond;
int32_t& iZoneHour = *pZoneHour;
int32_t& iZoneMinute = *pZoneMinute;
iYear = 0;
iMonth = 0;
iDay = 0;
iHour = 0;
iMinute = 0;
iSecond = 0;
if (pData.empty())
return false;
size_t iIndex = 0;
while (pData[iIndex] != 'T' && pData[iIndex] != 't') {
if (iIndex >= pData.size())
return false;
++iIndex;
}
if (iIndex != 8 && iIndex != 10)
return false;
int32_t iStyle = -1;
if (!IsIsoDateFormat(pData.subspan(0, iIndex), &iStyle, &iYear, &iMonth,
&iDay)) {
return false;
}
if (pData[iIndex] != 'T' && pData[iIndex] != 't')
return true;
return IsIsoTimeFormat(pData.subspan(iIndex + 1), &iHour, &iMinute, &iSecond,
&iMilliSecond, &iZoneHour, &iZoneMinute);
}
int32_t DateString2Num(ByteStringView bsDate) {
int32_t iLength = bsDate.GetLength();
int32_t iYear = 0;
int32_t iMonth = 0;
int32_t iDay = 0;
if (iLength <= 10) {
int32_t iStyle = -1;
if (!IsIsoDateFormat(bsDate.span(), &iStyle, &iYear, &iMonth, &iDay))
return 0;
} else {
int32_t iHour = 0;
int32_t iMinute = 0;
int32_t iSecond = 0;
int32_t iMilliSecond = 0;
int32_t iZoneHour = 0;
int32_t iZoneMinute = 0;
if (!IsIsoDateTimeFormat(bsDate.span(), &iYear, &iMonth, &iDay, &iHour,
&iMinute, &iSecond, &iMilliSecond, &iZoneHour,
&iZoneMinute)) {
return 0;
}
}
float dDays = 0;
int32_t i = 1;
if (iYear < 1900)
return 0;
while (iYear - i >= 1900) {
dDays +=
((!((iYear - i) % 4) && ((iYear - i) % 100)) || !((iYear - i) % 400))
? 366
: 365;
++i;
}
i = 1;
while (i < iMonth) {
if (i == 2)
dDays += ((!(iYear % 4) && (iYear % 100)) || !(iYear % 400)) ? 29 : 28;
else if (i <= 7)
dDays += (i % 2 == 0) ? 30 : 31;
else
dDays += (i % 2 == 0) ? 31 : 30;
++i;
}
i = 0;
while (iDay - i > 0) {
++dDays;
++i;
}
return static_cast<int32_t>(dDays);
}
void GetLocalTimeZone(int32_t* pHour, int32_t* pMin, int32_t* pSec) {
time_t now;
FXSYS_time(&now);
struct tm* pGmt = gmtime(&now);
struct tm* pLocal = FXSYS_localtime(&now);
*pHour = pLocal->tm_hour - pGmt->tm_hour;
*pMin = pLocal->tm_min - pGmt->tm_min;
*pSec = pLocal->tm_sec - pGmt->tm_sec;
}
bool HTMLSTR2Code(const WideString& pData, uint32_t* iCode) {
auto cmpFunc = [](const XFA_FMHtmlReserveCode& iter, ByteStringView val) {
return strcmp(val.unterminated_c_str(), iter.m_htmlReserve) > 0;
};
if (!pData.IsASCII())
return false;
ByteString temp = pData.ToASCII();
const XFA_FMHtmlReserveCode* result = std::lower_bound(
std::begin(kReservesForDecode), std::end(kReservesForDecode),
temp.AsStringView(), cmpFunc);
if (result != std::end(kReservesForDecode) &&
!strcmp(temp.c_str(), result->m_htmlReserve)) {
*iCode = result->m_uCode;
return true;
}
return false;
}
bool HTMLCode2STR(uint32_t iCode, WideString* wsHTMLReserve) {
auto cmpFunc = [](const XFA_FMHtmlReserveCode iter, const uint32_t& val) {
return iter.m_uCode < val;
};
const XFA_FMHtmlReserveCode* result =
std::lower_bound(std::begin(kReservesForEncode),
std::end(kReservesForEncode), iCode, cmpFunc);
if (result != std::end(kReservesForEncode) && result->m_uCode == iCode) {
*wsHTMLReserve = WideString::FromASCII(result->m_htmlReserve);
return true;
}
return false;
}
WideString DecodeURL(const WideString& wsURL) {
const wchar_t* pData = wsURL.c_str();
size_t iLen = wsURL.GetLength();
CFX_WideTextBuf wsResultBuf;
for (size_t i = 0; i < iLen; ++i) {
wchar_t ch = pData[i];
if ('%' != ch) {
wsResultBuf.AppendChar(ch);
continue;
}
wchar_t chTemp = 0;
int32_t iCount = 0;
while (iCount < 2) {
if (++i >= iLen)
break;
chTemp *= 16;
ch = pData[i];
if (!FXSYS_IsWideHexDigit(ch))
return WideString();
chTemp += FXSYS_WideHexCharToInt(ch);
++iCount;
}
wsResultBuf.AppendChar(chTemp);
}
return wsResultBuf.MakeString();
}
WideString DecodeMLInternal(const WideString& wsHTML, bool bIsHTML) {
const wchar_t* pData = wsHTML.c_str();
size_t iLen = wsHTML.GetLength();
CFX_WideTextBuf wsResultBuf;
for (size_t i = 0; i < iLen; ++i) {
wchar_t ch = pData[i];
if (ch != '&') {
wsResultBuf.AppendChar(ch);
continue;
}
if (++i >= iLen)
break;
ch = pData[i];
if (ch == '#') {
if (++i >= iLen)
break;
ch = pData[i];
if (ch != 'x' && ch != 'X')
return WideString();
if (++i >= iLen)
break;
ch = pData[i];
uint32_t iCode = 0;
while (ch != ';' && i < iLen) {
iCode *= 16;
if (!FXSYS_IsWideHexDigit(ch))
return WideString();
iCode += FXSYS_WideHexCharToInt(ch);
if (++i >= iLen)
break;
ch = pData[i];
}
wsResultBuf.AppendChar(iCode);
continue;
}
wchar_t szBuffer[9];
size_t iStrIndex = 0;
while (ch != ';' && i < iLen) {
if (iStrIndex < 8)
szBuffer[iStrIndex++] = ch;
if (++i >= iLen)
break;
ch = pData[i];
}
szBuffer[iStrIndex] = 0;
if (bIsHTML) {
uint32_t iData = 0;
if (HTMLSTR2Code(szBuffer, &iData))
wsResultBuf.AppendChar((wchar_t)iData);
} else {
if (wcscmp(szBuffer, L"quot") == 0)
wsResultBuf.AppendChar('"');
else if (wcscmp(szBuffer, L"amp") == 0)
wsResultBuf.AppendChar('&');
else if (wcscmp(szBuffer, L"apos") == 0)
wsResultBuf.AppendChar('\'');
else if (wcscmp(szBuffer, L"lt") == 0)
wsResultBuf.AppendChar('<');
else if (wcscmp(szBuffer, L"gt") == 0)
wsResultBuf.AppendChar('>');
}
}
return wsResultBuf.MakeString();
}
WideString DecodeHTML(const WideString& wsHTML) {
return DecodeMLInternal(wsHTML, true);
}
WideString DecodeXML(const WideString& wsXML) {
return DecodeMLInternal(wsXML, false);
}
WideString EncodeURL(const ByteString& bsURL) {
static const wchar_t kStrUnsafe[] = {' ', '<', '>', '"', '#', '%', '{', '}',
'|', '\\', '^', '~', '[', ']', '`'};
static const wchar_t kStrReserved[] = {';', '/', '?', ':', '@', '=', '&'};
static const wchar_t kStrSpecial[] = {'$', '-', '+', '!', '*',
'\'', '(', ')', ','};
WideString wsURL = WideString::FromUTF8(bsURL.AsStringView());
CFX_WideTextBuf wsResultBuf;
wchar_t szEncode[4];
szEncode[0] = '%';
szEncode[3] = 0;
for (wchar_t ch : wsURL) {
size_t i = 0;
size_t iCount = pdfium::size(kStrUnsafe);
while (i < iCount) {
if (ch == kStrUnsafe[i]) {
int32_t iIndex = ch / 16;
szEncode[1] = kStrCode[iIndex];
szEncode[2] = kStrCode[ch - iIndex * 16];
wsResultBuf << szEncode;
break;
}
++i;
}
if (i < iCount)
continue;
i = 0;
iCount = pdfium::size(kStrReserved);
while (i < iCount) {
if (ch == kStrReserved[i]) {
int32_t iIndex = ch / 16;
szEncode[1] = kStrCode[iIndex];
szEncode[2] = kStrCode[ch - iIndex * 16];
wsResultBuf << szEncode;
break;
}
++i;
}
if (i < iCount)
continue;
i = 0;
iCount = pdfium::size(kStrSpecial);
while (i < iCount) {
if (ch == kStrSpecial[i]) {
wsResultBuf.AppendChar(ch);
break;
}
++i;
}
if (i < iCount)
continue;
if ((ch >= 0x80 && ch <= 0xff) || ch <= 0x1f || ch == 0x7f) {
int32_t iIndex = ch / 16;
szEncode[1] = kStrCode[iIndex];
szEncode[2] = kStrCode[ch - iIndex * 16];
wsResultBuf << szEncode;
} else if (ch >= 0x20 && ch <= 0x7e) {
wsResultBuf.AppendChar(ch);
} else {
const wchar_t iRadix = 16;
WideString wsBuffer;
while (ch >= iRadix) {
wchar_t tmp = kStrCode[ch % iRadix];
ch /= iRadix;
wsBuffer += tmp;
}
wsBuffer += kStrCode[ch];
int32_t iLen = wsBuffer.GetLength();
if (iLen < 2)
break;
int32_t iIndex = 0;
if (iLen % 2 != 0) {
szEncode[1] = '0';
szEncode[2] = wsBuffer[iLen - 1];
iIndex = iLen - 2;
} else {
szEncode[1] = wsBuffer[iLen - 1];
szEncode[2] = wsBuffer[iLen - 2];
iIndex = iLen - 3;
}
wsResultBuf << szEncode;
while (iIndex > 0) {
szEncode[1] = wsBuffer[iIndex];
szEncode[2] = wsBuffer[iIndex - 1];
iIndex -= 2;
wsResultBuf << szEncode;
}
}
}
return wsResultBuf.MakeString();
}
WideString EncodeHTML(const ByteString& bsHTML) {
WideString wsHTML = WideString::FromUTF8(bsHTML.AsStringView());
wchar_t szEncode[9];
szEncode[0] = '&';
szEncode[1] = '#';
szEncode[2] = 'x';
CFX_WideTextBuf wsResultBuf;
for (uint32_t ch : wsHTML) {
WideString htmlReserve;
if (HTMLCode2STR(ch, &htmlReserve)) {
wsResultBuf.AppendChar(L'&');
wsResultBuf << htmlReserve;
wsResultBuf.AppendChar(L';');
} else if (ch >= 32 && ch <= 126) {
wsResultBuf.AppendChar(static_cast<wchar_t>(ch));
} else if (ch < 256) {
int32_t iIndex = ch / 16;
szEncode[3] = kStrCode[iIndex];
szEncode[4] = kStrCode[ch - iIndex * 16];
szEncode[5] = ';';
szEncode[6] = 0;
wsResultBuf << szEncode;
} else if (ch < 65536) {
int32_t iBigByte = ch / 256;
int32_t iLittleByte = ch % 256;
szEncode[3] = kStrCode[iBigByte / 16];
szEncode[4] = kStrCode[iBigByte % 16];
szEncode[5] = kStrCode[iLittleByte / 16];
szEncode[6] = kStrCode[iLittleByte % 16];
szEncode[7] = ';';
szEncode[8] = 0;
wsResultBuf << szEncode;
} else {
// TODO(tsepez): Handle codepoint not in BMP.
}
}
return wsResultBuf.MakeString();
}
WideString EncodeXML(const ByteString& bsXML) {
WideString wsXML = WideString::FromUTF8(bsXML.AsStringView());
CFX_WideTextBuf wsResultBuf;
wchar_t szEncode[9];
szEncode[0] = '&';
szEncode[1] = '#';
szEncode[2] = 'x';
for (uint32_t ch : wsXML) {
switch (ch) {
case '"':
wsResultBuf.AppendChar('&');
wsResultBuf << WideStringView(L"quot");
wsResultBuf.AppendChar(';');
break;
case '&':
wsResultBuf.AppendChar('&');
wsResultBuf << WideStringView(L"amp");
wsResultBuf.AppendChar(';');
break;
case '\'':
wsResultBuf.AppendChar('&');
wsResultBuf << WideStringView(L"apos");
wsResultBuf.AppendChar(';');
break;
case '<':
wsResultBuf.AppendChar('&');
wsResultBuf << WideStringView(L"lt");
wsResultBuf.AppendChar(';');
break;
case '>':
wsResultBuf.AppendChar('&');
wsResultBuf << WideStringView(L"gt");
wsResultBuf.AppendChar(';');
break;
default: {
if (ch >= 32 && ch <= 126) {
wsResultBuf.AppendChar(static_cast<wchar_t>(ch));
} else if (ch < 256) {
int32_t iIndex = ch / 16;
szEncode[3] = kStrCode[iIndex];
szEncode[4] = kStrCode[ch - iIndex * 16];
szEncode[5] = ';';
szEncode[6] = 0;
wsResultBuf << szEncode;
} else if (ch < 65536) {
int32_t iBigByte = ch / 256;
int32_t iLittleByte = ch % 256;
szEncode[3] = kStrCode[iBigByte / 16];
szEncode[4] = kStrCode[iBigByte % 16];
szEncode[5] = kStrCode[iLittleByte / 16];
szEncode[6] = kStrCode[iLittleByte % 16];
szEncode[7] = ';';
szEncode[8] = 0;
wsResultBuf << szEncode;
} else {
// TODO(tsepez): Handle codepoint not in BMP.
}
break;
}
}
}
return wsResultBuf.MakeString();
}
ByteString TrillionUS(ByteStringView bsData) {
static const char kUnits[][6] = {"zero", "one", "two", "three", "four",
"five", "six", "seven", "eight", "nine"};
static const char kCapUnits[][6] = {"Zero", "One", "Two", "Three", "Four",
"Five", "Six", "Seven", "Eight", "Nine"};
static const char kTens[][10] = {
"Ten", "Eleven", "Twelve", "Thirteen", "Fourteen",
"Fifteen", "Sixteen", "Seventeen", "Eighteen", "Nineteen"};
static const char kLastTens[][8] = {"Twenty", "Thirty", "Forty", "Fifty",
"Sixty", "Seventy", "Eighty", "Ninety"};
static const char kComm[][11] = {" Hundred ", " Thousand ", " Million ",
" Billion ", "Trillion"};
const char* pData = bsData.unterminated_c_str();
int32_t iLength = bsData.GetLength();
int32_t iComm = 0;
if (iLength > 12)
iComm = 4;
else if (iLength > 9)
iComm = 3;
else if (iLength > 6)
iComm = 2;
else if (iLength > 3)
iComm = 1;
int32_t iFirstCount = iLength % 3;
if (iFirstCount == 0)
iFirstCount = 3;
std::ostringstream strBuf;
int32_t iIndex = 0;
if (iFirstCount == 3) {
if (pData[iIndex] != '0') {
strBuf << kCapUnits[pData[iIndex] - '0'];
strBuf << kComm[0];
}
if (pData[iIndex + 1] == '0') {
strBuf << kCapUnits[pData[iIndex + 2] - '0'];
} else {
if (pData[iIndex + 1] > '1') {
strBuf << kLastTens[pData[iIndex + 1] - '2'];
strBuf << "-";
strBuf << kUnits[pData[iIndex + 2] - '0'];
} else if (pData[iIndex + 1] == '1') {
strBuf << kTens[pData[iIndex + 2] - '0'];
} else if (pData[iIndex + 1] == '0') {
strBuf << kCapUnits[pData[iIndex + 2] - '0'];
}
}
iIndex += 3;
} else if (iFirstCount == 2) {
if (pData[iIndex] == '0') {
strBuf << kCapUnits[pData[iIndex + 1] - '0'];
} else {
if (pData[iIndex] > '1') {
strBuf << kLastTens[pData[iIndex] - '2'];
strBuf << "-";
strBuf << kUnits[pData[iIndex + 1] - '0'];
} else if (pData[iIndex] == '1') {
strBuf << kTens[pData[iIndex + 1] - '0'];
} else if (pData[iIndex] == '0') {
strBuf << kCapUnits[pData[iIndex + 1] - '0'];
}
}
iIndex += 2;
} else if (iFirstCount == 1) {
strBuf << kCapUnits[pData[iIndex] - '0'];
++iIndex;
}
if (iLength > 3 && iFirstCount > 0) {
strBuf << kComm[iComm];
--iComm;
}
while (iIndex < iLength) {
if (pData[iIndex] != '0') {
strBuf << kCapUnits[pData[iIndex] - '0'];
strBuf << kComm[0];
}
if (pData[iIndex + 1] == '0') {
strBuf << kCapUnits[pData[iIndex + 2] - '0'];
} else {
if (pData[iIndex + 1] > '1') {
strBuf << kLastTens[pData[iIndex + 1] - '2'];
strBuf << "-";
strBuf << kUnits[pData[iIndex + 2] - '0'];
} else if (pData[iIndex + 1] == '1') {
strBuf << kTens[pData[iIndex + 2] - '0'];
} else if (pData[iIndex + 1] == '0') {
strBuf << kCapUnits[pData[iIndex + 2] - '0'];
}
}
if (iIndex < iLength - 3) {
strBuf << kComm[iComm];
--iComm;
}
iIndex += 3;
}
return ByteString(strBuf);
}
ByteString WordUS(const ByteString& bsData, int32_t iStyle) {
const char* pData = bsData.c_str();
int32_t iLength = bsData.GetLength();
if (iStyle < 0 || iStyle > 2) {
return ByteString();
}
std::ostringstream strBuf;
int32_t iIndex = 0;
while (iIndex < iLength) {
if (pData[iIndex] == '.')
break;
++iIndex;
}
int32_t iInteger = iIndex;
iIndex = 0;
while (iIndex < iInteger) {
int32_t iCount = (iInteger - iIndex) % 12;
if (!iCount && iInteger - iIndex > 0)
iCount = 12;
strBuf << TrillionUS(ByteStringView(pData + iIndex, iCount));
iIndex += iCount;
if (iIndex < iInteger)
strBuf << " Trillion ";
}
if (iStyle > 0)
strBuf << " Dollars";
if (iStyle > 1 && iInteger < iLength) {
strBuf << " And ";
iIndex = iInteger + 1;
while (iIndex < iLength) {
int32_t iCount = (iLength - iIndex) % 12;
if (!iCount && iLength - iIndex > 0)
iCount = 12;
strBuf << TrillionUS(ByteStringView(pData + iIndex, iCount));
iIndex += iCount;
if (iIndex < iLength)
strBuf << " Trillion ";
}
strBuf << " Cents";
}
return ByteString(strBuf);
}
v8::Local<v8::Value> GetObjectDefaultValue(v8::Isolate* pIsolate,
v8::Local<v8::Object> pObject) {
CXFA_Node* pNode = ToNode(CFXJSE_Engine::ToObject(pIsolate, pObject));
if (!pNode)
return fxv8::NewNullHelper(pIsolate);
v8::Local<v8::Value> value;
pNode->JSObject()->ScriptSomDefaultValue(pIsolate, &value, false,
XFA_Attribute::Unknown);
return value;
}
bool SetObjectDefaultValue(v8::Isolate* pIsolate,
v8::Local<v8::Object> pObject,
v8::Local<v8::Value> hNewValue) {
CXFA_Node* pNode = ToNode(CFXJSE_Engine::ToObject(pIsolate, pObject));
if (!pNode)
return false;
pNode->JSObject()->ScriptSomDefaultValue(pIsolate, &hNewValue, true,
XFA_Attribute::Unknown);
return true;
}
v8::Local<v8::Value> GetExtractedValue(v8::Isolate* pIsolate,
v8::Local<v8::Value> pValue) {
if (pValue.IsEmpty())
return v8::Local<v8::Value>();
if (fxv8::IsArray(pValue)) {
v8::Local<v8::Array> arr = pValue.As<v8::Array>();
uint32_t iLength = fxv8::GetArrayLengthHelper(arr);
if (iLength < 3)
return fxv8::NewUndefinedHelper(pIsolate);
v8::Local<v8::Value> propertyValue =
fxv8::ReentrantGetArrayElementHelper(pIsolate, arr, 1);
v8::Local<v8::Value> jsValue =
fxv8::ReentrantGetArrayElementHelper(pIsolate, arr, 2);
if (!fxv8::IsObject(jsValue))
return fxv8::NewUndefinedHelper(pIsolate);
v8::Local<v8::Object> jsObjectValue = jsValue.As<v8::Object>();
if (fxv8::IsNull(propertyValue))
return GetObjectDefaultValue(pIsolate, jsObjectValue);
ByteString bsName =
fxv8::ReentrantToByteStringHelper(pIsolate, propertyValue);
return fxv8::ReentrantGetObjectPropertyHelper(pIsolate, jsObjectValue,
bsName.AsStringView());
}
if (fxv8::IsObject(pValue))
return GetObjectDefaultValue(pIsolate, pValue.As<v8::Object>());
return pValue;
}
v8::Local<v8::Value> GetSimpleValue(
const v8::FunctionCallbackInfo<v8::Value>& info,
uint32_t index) {
DCHECK(index < static_cast<uint32_t>(info.Length()));
return GetExtractedValue(info.GetIsolate(), info[index]);
}
bool ValueIsNull(v8::Isolate* pIsolate, v8::Local<v8::Value> arg) {
v8::Local<v8::Value> extracted = GetExtractedValue(pIsolate, arg);
return extracted.IsEmpty() || fxv8::IsNull(extracted);
}
int32_t ValueToInteger(v8::Isolate* pIsolate, v8::Local<v8::Value> arg) {
v8::Local<v8::Value> extracted = GetExtractedValue(pIsolate, arg);
if (extracted.IsEmpty())
return 0;
if (fxv8::IsObject(extracted) || fxv8::IsArray(extracted))
return ValueToInteger(pIsolate, extracted);
if (fxv8::IsString(extracted)) {
ByteString bsValue = fxv8::ReentrantToByteStringHelper(pIsolate, extracted);
return FXSYS_atoi(bsValue.c_str());
}
return fxv8::ReentrantToInt32Helper(pIsolate, extracted);
}
float ValueToFloat(v8::Isolate* pIsolate, v8::Local<v8::Value> arg) {
v8::Local<v8::Value> extracted = GetExtractedValue(pIsolate, arg);
if (extracted.IsEmpty())
return 0.0f;
if (fxv8::IsUndefined(extracted))
return 0.0f;
if (fxv8::IsObject(extracted) || fxv8::IsArray(extracted))
return ValueToFloat(pIsolate, extracted);
if (fxv8::IsString(extracted)) {
ByteString bsValue = fxv8::ReentrantToByteStringHelper(pIsolate, extracted);
return strtof(bsValue.c_str(), nullptr);
}
return fxv8::ReentrantToFloatHelper(pIsolate, extracted);
}
double ValueToDouble(v8::Isolate* pIsolate, v8::Local<v8::Value> arg) {
v8::Local<v8::Value> extracted = GetExtractedValue(pIsolate, arg);
if (extracted.IsEmpty())
return 0.0;
if (fxv8::IsUndefined(extracted))
return 0.0;
if (fxv8::IsObject(extracted) || fxv8::IsArray(extracted))
return ValueToDouble(pIsolate, extracted);
if (fxv8::IsString(extracted)) {
ByteString bsValue = fxv8::ReentrantToByteStringHelper(pIsolate, extracted);
return strtod(bsValue.c_str(), nullptr);
}
return fxv8::ReentrantToDoubleHelper(pIsolate, extracted);
}
Optional<double> ExtractDouble(v8::Isolate* pIsolate,
v8::Local<v8::Value> src) {
if (src.IsEmpty())
return 0.0;
if (!fxv8::IsArray(src))
return ValueToDouble(pIsolate, src);
v8::Local<v8::Array> arr = src.As<v8::Array>();
uint32_t iLength = fxv8::GetArrayLengthHelper(arr);
if (iLength < 3)
return pdfium::nullopt;
v8::Local<v8::Value> propertyValue =
fxv8::ReentrantGetArrayElementHelper(pIsolate, arr, 1);
v8::Local<v8::Value> jsValue =
fxv8::ReentrantGetArrayElementHelper(pIsolate, arr, 2);
if (fxv8::IsNull(propertyValue) || !fxv8::IsObject(jsValue))
return ValueToDouble(pIsolate, jsValue);
ByteString bsName =
fxv8::ReentrantToByteStringHelper(pIsolate, propertyValue);
return ValueToDouble(
pIsolate, fxv8::ReentrantGetObjectPropertyHelper(
pIsolate, jsValue.As<v8::Object>(), bsName.AsStringView()));
}
ByteString ValueToUTF8String(v8::Isolate* pIsolate, v8::Local<v8::Value> arg) {
if (arg.IsEmpty())
return ByteString();
if (fxv8::IsNull(arg) || fxv8::IsUndefined(arg))
return ByteString();
if (fxv8::IsBoolean(arg))
return fxv8::ReentrantToBooleanHelper(pIsolate, arg) ? "1" : "0";
return fxv8::ReentrantToByteStringHelper(pIsolate, arg);
}
bool SimpleValueCompare(v8::Isolate* pIsolate,
v8::Local<v8::Value> firstValue,
v8::Local<v8::Value> secondValue) {
if (firstValue.IsEmpty())
return false;
if (fxv8::IsString(firstValue)) {
const ByteString first = ValueToUTF8String(pIsolate, firstValue);
const ByteString second = ValueToUTF8String(pIsolate, secondValue);
return first == second;
}
if (fxv8::IsNumber(firstValue)) {
const float first = ValueToFloat(pIsolate, firstValue);
const float second = ValueToFloat(pIsolate, secondValue);
return first == second;
}
if (fxv8::IsBoolean(firstValue)) {
const bool first = fxv8::ReentrantToBooleanHelper(pIsolate, firstValue);
const bool second = fxv8::ReentrantToBooleanHelper(pIsolate, secondValue);
return first == second;
}
return fxv8::IsNull(firstValue) && fxv8::IsNull(secondValue);
}
std::vector<v8::Local<v8::Value>> UnfoldArgs(
const v8::FunctionCallbackInfo<v8::Value>& info) {
std::vector<v8::Local<v8::Value>> results;
v8::Isolate* pIsolate = info.GetIsolate();
for (int i = 1; i < info.Length(); ++i) {
v8::Local<v8::Value> arg = info[i];
if (fxv8::IsArray(arg)) {
v8::Local<v8::Array> arr = arg.As<v8::Array>();
uint32_t iLength = fxv8::GetArrayLengthHelper(arr);
if (iLength < 3)
continue;
v8::Local<v8::Value> propertyValue =
fxv8::ReentrantGetArrayElementHelper(pIsolate, arr, 1);
for (uint32_t j = 2; j < iLength; j++) {
v8::Local<v8::Value> jsValue =
fxv8::ReentrantGetArrayElementHelper(pIsolate, arr, j);
if (!fxv8::IsObject(jsValue)) {
results.push_back(fxv8::NewUndefinedHelper(pIsolate));
} else if (fxv8::IsNull(propertyValue)) {
results.push_back(
GetObjectDefaultValue(pIsolate, jsValue.As<v8::Object>()));
} else {
ByteString bsName =
fxv8::ReentrantToByteStringHelper(pIsolate, propertyValue);
results.push_back(fxv8::ReentrantGetObjectPropertyHelper(
pIsolate, jsValue.As<v8::Object>(), bsName.AsStringView()));
}
}
} else if (fxv8::IsObject(arg)) {
results.push_back(GetObjectDefaultValue(pIsolate, arg.As<v8::Object>()));
} else {
results.push_back(arg);
}
}
return results;
}
// Returns empty value on failure.
v8::Local<v8::Value> GetObjectForName(CFXJSE_HostObject* pHostObject,
ByteStringView bsAccessorName) {
CXFA_Document* pDoc = ToFormCalcContext(pHostObject)->GetDocument();
if (!pDoc)
return v8::Local<v8::Value>();
CFXJSE_Engine* pScriptContext = pDoc->GetScriptContext();
constexpr XFA_ResolveNodeMask kFlags =
XFA_RESOLVENODE_Children | XFA_RESOLVENODE_Properties |
XFA_RESOLVENODE_Siblings | XFA_RESOLVENODE_Parent;
Optional<CFXJSE_Engine::ResolveResult> maybeResult =
pScriptContext->ResolveObjects(
pScriptContext->GetThisObject(),
WideString::FromUTF8(bsAccessorName).AsStringView(), kFlags);
if (!maybeResult.has_value() ||
maybeResult.value().type != CFXJSE_Engine::ResolveResult::Type::kNodes ||
maybeResult.value().objects.empty()) {
return v8::Local<v8::Value>();
}
return pScriptContext->GetOrCreateJSBindingFromMap(
maybeResult.value().objects.front().Get());
}
Optional<CFXJSE_Engine::ResolveResult> ResolveObjects(
CFXJSE_HostObject* pHostObject,
v8::Local<v8::Value> pRefValue,
ByteStringView bsSomExp,
bool bDotAccessor,
bool bHasNoResolveName) {
CXFA_Document* pDoc = ToFormCalcContext(pHostObject)->GetDocument();
if (!pDoc)
return pdfium::nullopt;
v8::Isolate* pIsolate = ToFormCalcContext(pHostObject)->GetIsolate();
WideString wsSomExpression = WideString::FromUTF8(bsSomExp);
CFXJSE_Engine* pScriptContext = pDoc->GetScriptContext();
CXFA_Object* pNode = nullptr;
XFA_ResolveNodeMask dwFlags = 0;
if (bDotAccessor) {
if (fxv8::IsNull(pRefValue)) {
pNode = pScriptContext->GetThisObject();
dwFlags = XFA_RESOLVENODE_Siblings | XFA_RESOLVENODE_Parent;
} else {
pNode = CFXJSE_Engine::ToObject(pIsolate, pRefValue);
if (!pNode)
return pdfium::nullopt;
if (bHasNoResolveName) {
WideString wsName;
if (CXFA_Node* pXFANode = pNode->AsNode()) {
Optional<WideString> ret =
pXFANode->JSObject()->TryAttribute(XFA_Attribute::Name, false);
if (ret.has_value())
wsName = ret.value();
}
if (wsName.IsEmpty())
wsName = L"#" + WideString::FromASCII(pNode->GetClassName());
wsSomExpression = wsName + wsSomExpression;
dwFlags = XFA_RESOLVENODE_Siblings;
} else {
dwFlags = (bsSomExp == "*")
? (XFA_RESOLVENODE_Children)
: (XFA_RESOLVENODE_Children | XFA_RESOLVENODE_Attributes |
XFA_RESOLVENODE_Properties);
}
}
} else {
pNode = CFXJSE_Engine::ToObject(pIsolate, pRefValue);
dwFlags = XFA_RESOLVENODE_AnyChild;
}
return pScriptContext->ResolveObjects(pNode, wsSomExpression.AsStringView(),
dwFlags);
}
std::vector<v8::Local<v8::Value>> ParseResolveResult(
CFXJSE_HostObject* pHostObject,
const CFXJSE_Engine::ResolveResult& resolveNodeRS,
v8::Local<v8::Value> pParentValue,
bool* bAttribute) {
std::vector<v8::Local<v8::Value>> resultValues;
CFXJSE_FormCalcContext* pContext = ToFormCalcContext(pHostObject);
v8::Isolate* pIsolate = pContext->GetIsolate();
if (resolveNodeRS.type == CFXJSE_Engine::ResolveResult::Type::kNodes) {
*bAttribute = false;
CFXJSE_Engine* pScriptContext = pContext->GetDocument()->GetScriptContext();
for (auto& pObject : resolveNodeRS.objects) {
resultValues.push_back(
pScriptContext->GetOrCreateJSBindingFromMap(pObject.Get()));
}
return resultValues;
}
*bAttribute = true;
if (resolveNodeRS.script_attribute.callback &&
resolveNodeRS.script_attribute.eValueType == XFA_ScriptType::Object) {
for (auto& pObject : resolveNodeRS.objects) {
v8::Local<v8::Value> pValue;
CJX_Object* jsObject = pObject->JSObject();
(*resolveNodeRS.script_attribute.callback)(
pIsolate, jsObject, &pValue, false,
resolveNodeRS.script_attribute.attribute);
resultValues.push_back(pValue);
*bAttribute = false;
}
}
if (*bAttribute && fxv8::IsObject(pParentValue))
resultValues.push_back(pParentValue);
return resultValues;
}
} // namespace
const FXJSE_CLASS_DESCRIPTOR kFormCalcFM2JSDescriptor = {
kClassTag, // tag
"XFA_FM2JS_FormCalcClass", // name
kFormCalcFM2JSFunctions, // methods
pdfium::size(kFormCalcFM2JSFunctions), // number of methods
nullptr, // dynamic prop type
nullptr, // dynamic prop getter
nullptr, // dynamic prop setter
nullptr, // dynamic prop method call
};
// static
void CFXJSE_FormCalcContext::Abs(
CFXJSE_HostObject* pThis,
const v8::FunctionCallbackInfo<v8::Value>& info) {
if (info.Length() != 1) {
ToFormCalcContext(pThis)->ThrowParamCountMismatchException(L"Abs");
return;
}
if (ValueIsNull(info.GetIsolate(), info[0])) {
info.GetReturnValue().SetNull();
return;
}
double dValue = ValueToDouble(info.GetIsolate(), info[0]);
if (dValue < 0)
dValue = -dValue;
info.GetReturnValue().Set(dValue);
}
// static
void CFXJSE_FormCalcContext::Avg(
CFXJSE_HostObject* pThis,
const v8::FunctionCallbackInfo<v8::Value>& info) {
uint32_t uCount = 0;
double dSum = 0.0;
auto fn = [&uCount, &dSum](v8::Isolate* pIsolate,
v8::Local<v8::Value> pValue) {
dSum += ValueToDouble(pIsolate, pValue);
uCount++;
};
if (!ToFormCalcContext(pThis)->ApplyToExpansion(fn, info, /*bStrict=*/false))
return;
if (uCount == 0) {
info.GetReturnValue().SetNull();
return;
}
info.GetReturnValue().Set(dSum / uCount);
}
// static
void CFXJSE_FormCalcContext::Ceil(
CFXJSE_HostObject* pThis,
const v8::FunctionCallbackInfo<v8::Value>& info) {
if (info.Length() != 1) {
ToFormCalcContext(pThis)->ThrowParamCountMismatchException(L"Ceil");
return;
}
v8::Local<v8::Value> argValue = GetSimpleValue(info, 0);
if (ValueIsNull(info.GetIsolate(), argValue)) {
info.GetReturnValue().SetNull();
return;
}
info.GetReturnValue().Set(ceil(ValueToFloat(info.GetIsolate(), argValue)));
}
// static
void CFXJSE_FormCalcContext::Count(
CFXJSE_HostObject* pThis,
const v8::FunctionCallbackInfo<v8::Value>& info) {
uint32_t iCount = 0;
auto fn = [&iCount](v8::Isolate* pIsolate, v8::Local<v8::Value> pvalue) {
++iCount;
};
if (!ToFormCalcContext(pThis)->ApplyToExpansion(fn, info, /*bStrict=*/true))
return;
info.GetReturnValue().Set(iCount);
}
// static
void CFXJSE_FormCalcContext::Floor(
CFXJSE_HostObject* pThis,
const v8::FunctionCallbackInfo<v8::Value>& info) {
if (info.Length() != 1) {
ToFormCalcContext(pThis)->ThrowParamCountMismatchException(L"Floor");
return;
}
v8::Local<v8::Value> argValue = GetSimpleValue(info, 0);
if (ValueIsNull(info.GetIsolate(), argValue)) {
info.GetReturnValue().SetNull();
return;
}
info.GetReturnValue().Set(floor(ValueToFloat(info.GetIsolate(), argValue)));
}
// static
void CFXJSE_FormCalcContext::Max(
CFXJSE_HostObject* pThis,
const v8::FunctionCallbackInfo<v8::Value>& info) {
uint32_t uCount = 0;
double dMaxValue = 0.0;
auto fn = [&uCount, &dMaxValue](v8::Isolate* pIsolate,
v8::Local<v8::Value> pValue) {
++uCount;
double dValue = ValueToDouble(pIsolate, pValue);
dMaxValue = uCount == 1 ? dValue : std::max(dMaxValue, dValue);
};
if (!ToFormCalcContext(pThis)->ApplyToExpansion(fn, info, /*bStrict=*/true))
return;
if (uCount == 0) {
info.GetReturnValue().SetNull();
return;
}
info.GetReturnValue().Set(dMaxValue);
}
// static
void CFXJSE_FormCalcContext::Min(
CFXJSE_HostObject* pThis,
const v8::FunctionCallbackInfo<v8::Value>& info) {
uint32_t uCount = 0;
double dMinValue = 0.0;
auto fn = [&uCount, &dMinValue](v8::Isolate* pIsolate,
v8::Local<v8::Value> pValue) {
++uCount;
double dValue = ValueToDouble(pIsolate, pValue);
dMinValue = uCount == 1 ? dValue : std::min(dMinValue, dValue);
};
if (!ToFormCalcContext(pThis)->ApplyToExpansion(fn, info, /*bStrict=*/true))
return;
if (uCount == 0) {
info.GetReturnValue().SetNull();
return;
}
info.GetReturnValue().Set(dMinValue);
}
// static
void CFXJSE_FormCalcContext::Mod(
CFXJSE_HostObject* pThis,
const v8::FunctionCallbackInfo<v8::Value>& info) {
CFXJSE_FormCalcContext* pContext = ToFormCalcContext(pThis);
if (info.Length() != 2) {
pContext->ThrowParamCountMismatchException(L"Mod");
return;
}
if (fxv8::IsNull(info[0]) || fxv8::IsNull(info[1])) {
info.GetReturnValue().SetNull();
return;
}
Optional<double> maybe_dividend = ExtractDouble(info.GetIsolate(), info[0]);
Optional<double> maybe_divisor = ExtractDouble(info.GetIsolate(), info[1]);
if (!maybe_dividend.has_value() || !maybe_divisor.has_value()) {
pContext->ThrowArgumentMismatchException();
return;
}
double dividend = maybe_dividend.value();
double divisor = maybe_divisor.value();
if (divisor == 0.0) {
pContext->ThrowDivideByZeroException();
return;
}
info.GetReturnValue().Set(dividend -
divisor * static_cast<int32_t>(dividend / divisor));
}
// static
void CFXJSE_FormCalcContext::Round(
CFXJSE_HostObject* pThis,
const v8::FunctionCallbackInfo<v8::Value>& info) {
CFXJSE_FormCalcContext* pContext = ToFormCalcContext(pThis);
int32_t argc = info.Length();
if (argc < 1 || argc > 2) {
pContext->ThrowParamCountMismatchException(L"Round");
return;
}
if (fxv8::IsNull(info[0])) {
info.GetReturnValue().SetNull();
return;
}
Optional<double> maybe_value = ExtractDouble(info.GetIsolate(), info[0]);
if (!maybe_value.has_value()) {
pContext->ThrowArgumentMismatchException();
return;
}
double dValue = maybe_value.value();
uint8_t uPrecision = 0;
if (argc > 1) {
if (fxv8::IsNull(info[1])) {
info.GetReturnValue().SetNull();
return;
}
Optional<double> maybe_precision =
ExtractDouble(info.GetIsolate(), info[1]);
if (!maybe_precision.has_value()) {
pContext->ThrowArgumentMismatchException();
return;
}
double dPrecision = maybe_precision.value();
uPrecision = static_cast<uint8_t>(pdfium::clamp(dPrecision, 0.0, 12.0));
}
CFGAS_Decimal decimalValue(static_cast<float>(dValue), uPrecision);
info.GetReturnValue().Set(decimalValue.ToDouble());
}
// static
void CFXJSE_FormCalcContext::Sum(
CFXJSE_HostObject* pThis,
const v8::FunctionCallbackInfo<v8::Value>& info) {
uint32_t uCount = 0;
double dSum = 0.0;
auto fn = [&uCount, &dSum](v8::Isolate* pIsolate,
v8::Local<v8::Value> pValue) {
++uCount;
dSum += ValueToDouble(pIsolate, pValue);
};
if (!ToFormCalcContext(pThis)->ApplyToExpansion(fn, info, /*bStrict=*/true))
return;
if (uCount == 0) {
info.GetReturnValue().SetNull();
return;
}
info.GetReturnValue().Set(dSum);
}
// static
void CFXJSE_FormCalcContext::Date(
CFXJSE_HostObject* pThis,
const v8::FunctionCallbackInfo<v8::Value>& info) {
if (info.Length() != 0) {
ToFormCalcContext(pThis)->ThrowParamCountMismatchException(L"Date");
return;
}
time_t currentTime;
FXSYS_time(&currentTime);
struct tm* pTmStruct = gmtime(&currentTime);
info.GetReturnValue().Set(DateString2Num(
ByteString::Format("%d%02d%02d", pTmStruct->tm_year + 1900,
pTmStruct->tm_mon + 1, pTmStruct->tm_mday)
.AsStringView()));
}
// static
void CFXJSE_FormCalcContext::Date2Num(
CFXJSE_HostObject* pThis,
const v8::FunctionCallbackInfo<v8::Value>& info) {
int32_t argc = info.Length();
if (argc < 1 || argc > 3) {
ToFormCalcContext(pThis)->ThrowParamCountMismatchException(L"Date2Num");
return;
}
v8::Local<v8::Value> dateValue = GetSimpleValue(info, 0);
if (ValueIsNull(info.GetIsolate(), dateValue)) {
info.GetReturnValue().SetNull();
return;
}
ByteString bsDate = ValueToUTF8String(info.GetIsolate(), dateValue);
ByteString bsFormat;
if (argc > 1) {
v8::Local<v8::Value> formatValue = GetSimpleValue(info, 1);
if (ValueIsNull(info.GetIsolate(), formatValue)) {
info.GetReturnValue().SetNull();
return;
}
bsFormat = ValueToUTF8String(info.GetIsolate(), formatValue);
}
ByteString bsLocale;
if (argc > 2) {
v8::Local<v8::Value> localeValue = GetSimpleValue(info, 2);
if (ValueIsNull(info.GetIsolate(), localeValue)) {
info.GetReturnValue().SetNull();
return;
}
bsLocale = ValueToUTF8String(info.GetIsolate(), localeValue);
}
ByteString bsIsoDate =
Local2IsoDate(pThis, bsDate.AsStringView(), bsFormat.AsStringView(),
bsLocale.AsStringView());
info.GetReturnValue().Set(DateString2Num(bsIsoDate.AsStringView()));
}
// static
void CFXJSE_FormCalcContext::DateFmt(
CFXJSE_HostObject* pThis,
const v8::FunctionCallbackInfo<v8::Value>& info) {
int32_t argc = info.Length();
if (argc > 2) {
ToFormCalcContext(pThis)->ThrowParamCountMismatchException(L"Date2Num");
return;
}
int32_t iStyle = 0;
if (argc > 0) {
v8::Local<v8::Value> infotyle = GetSimpleValue(info, 0);
if (fxv8::IsNull(infotyle)) {
info.GetReturnValue().SetNull();
return;
}
iStyle = static_cast<int32_t>(ValueToFloat(info.GetIsolate(), infotyle));
if (iStyle < 0 || iStyle > 4)
iStyle = 0;
}
ByteString bsLocale;
if (argc > 1) {
v8::Local<v8::Value> argLocale = GetSimpleValue(info, 1);
if (fxv8::IsNull(argLocale)) {
info.GetReturnValue().SetNull();
return;
}
bsLocale = ValueToUTF8String(info.GetIsolate(), argLocale);
}
ByteString bsFormat =
GetStandardDateFormat(pThis, iStyle, bsLocale.AsStringView());
info.GetReturnValue().Set(
fxv8::NewStringHelper(info.GetIsolate(), bsFormat.AsStringView()));
}
// static
void CFXJSE_FormCalcContext::IsoDate2Num(
CFXJSE_HostObject* pThis,
const v8::FunctionCallbackInfo<v8::Value>& info) {
if (info.Length() != 1) {
ToFormCalcContext(pThis)->ThrowParamCountMismatchException(L"IsoDate2Num");
return;
}
v8::Local<v8::Value> argOne = GetSimpleValue(info, 0);
if (fxv8::IsNull(argOne)) {
info.GetReturnValue().SetNull();
return;
}
ByteString bsArg = ValueToUTF8String(info.GetIsolate(), argOne);
info.GetReturnValue().Set(DateString2Num(bsArg.AsStringView()));
}
// static
void CFXJSE_FormCalcContext::IsoTime2Num(
CFXJSE_HostObject* pThis,
const v8::FunctionCallbackInfo<v8::Value>& info) {
CFXJSE_FormCalcContext* pContext = ToFormCalcContext(pThis);
if (info.Length() != 1) {
pContext->ThrowParamCountMismatchException(L"IsoTime2Num");
return;
}
v8::Local<v8::Value> argOne = GetSimpleValue(info, 0);
if (ValueIsNull(info.GetIsolate(), argOne)) {
info.GetReturnValue().SetNull();
return;
}
CXFA_Document* pDoc = pContext->GetDocument();
CXFA_LocaleMgr* pMgr = pDoc->GetLocaleMgr();
ByteString bsArg = ValueToUTF8String(info.GetIsolate(), argOne);
auto pos = bsArg.Find('T', 0);
if (!pos.has_value() || pos.value() == bsArg.GetLength() - 1) {
info.GetReturnValue().Set(0);
return;
}
bsArg = bsArg.Last(bsArg.GetLength() - (pos.value() + 1));
CXFA_LocaleValue timeValue(CXFA_LocaleValue::ValueType::kTime,
WideString::FromUTF8(bsArg.AsStringView()), pMgr);
if (!timeValue.IsValid()) {
info.GetReturnValue().Set(0);
return;
}
CFX_DateTime uniTime = timeValue.GetTime();
int32_t hour = uniTime.GetHour();
int32_t min = uniTime.GetMinute();
int32_t second = uniTime.GetSecond();
int32_t milSecond = uniTime.GetMillisecond();
// TODO(dsinclair): See if there is other time conversion code in pdfium and
// consolidate.
int32_t mins = hour * 60 + min;
mins -= pMgr->GetDefLocale()->GetTimeZoneInMinutes();
while (mins > 1440)
mins -= 1440;
while (mins < 0)
mins += 1440;
hour = mins / 60;
min = mins % 60;
info.GetReturnValue().Set(hour * 3600000 + min * 60000 + second * 1000 +
milSecond + 1);
}
// static
void CFXJSE_FormCalcContext::LocalDateFmt(
CFXJSE_HostObject* pThis,
const v8::FunctionCallbackInfo<v8::Value>& info) {
int32_t argc = info.Length();
if (argc > 2) {
ToFormCalcContext(pThis)->ThrowParamCountMismatchException(L"LocalDateFmt");
return;
}
int32_t iStyle = 0;
if (argc > 0) {
v8::Local<v8::Value> infotyle = GetSimpleValue(info, 0);
if (fxv8::IsNull(infotyle)) {
info.GetReturnValue().SetNull();
return;
}
iStyle = static_cast<int32_t>(ValueToFloat(info.GetIsolate(), infotyle));
if (iStyle > 4 || iStyle < 0)
iStyle = 0;
}
ByteString bsLocale;
if (argc > 1) {
v8::Local<v8::Value> argLocale = GetSimpleValue(info, 1);
if (fxv8::IsNull(argLocale)) {
info.GetReturnValue().SetNull();
return;
}
bsLocale = ValueToUTF8String(info.GetIsolate(), argLocale);
}
ByteString bsFormat =
GetLocalDateFormat(pThis, iStyle, bsLocale.AsStringView(), false);
info.GetReturnValue().Set(
fxv8::NewStringHelper(info.GetIsolate(), bsFormat.AsStringView()));
}
// static
void CFXJSE_FormCalcContext::LocalTimeFmt(
CFXJSE_HostObject* pThis,
const v8::FunctionCallbackInfo<v8::Value>& info) {
int32_t argc = info.Length();
if (argc > 2) {
ToFormCalcContext(pThis)->ThrowParamCountMismatchException(L"LocalTimeFmt");
return;
}
int32_t iStyle = 0;
if (argc > 0) {
v8::Local<v8::Value> infotyle = GetSimpleValue(info, 0);
if (fxv8::IsNull(infotyle)) {
info.GetReturnValue().SetNull();
return;
}
iStyle = static_cast<int32_t>(ValueToFloat(info.GetIsolate(), infotyle));
if (iStyle > 4 || iStyle < 0)
iStyle = 0;
}
ByteString bsLocale;
if (argc > 1) {
v8::Local<v8::Value> argLocale = GetSimpleValue(info, 1);
if (fxv8::IsNull(argLocale)) {
info.GetReturnValue().SetNull();
return;
}
bsLocale = ValueToUTF8String(info.GetIsolate(), argLocale);
}
ByteString bsFormat =
GetLocalTimeFormat(pThis, iStyle, bsLocale.AsStringView(), false);
info.GetReturnValue().Set(
fxv8::NewStringHelper(info.GetIsolate(), bsFormat.AsStringView()));
}
// static
void CFXJSE_FormCalcContext::Num2Date(
CFXJSE_HostObject* pThis,
const v8::FunctionCallbackInfo<v8::Value>& info) {
int32_t argc = info.Length();
if (argc < 1 || argc > 3) {
ToFormCalcContext(pThis)->ThrowParamCountMismatchException(L"Num2Date");
return;
}
v8::Local<v8::Value> dateValue = GetSimpleValue(info, 0);
if (ValueIsNull(info.GetIsolate(), dateValue)) {
info.GetReturnValue().SetNull();
return;
}
int32_t dDate =
static_cast<int32_t>(ValueToFloat(info.GetIsolate(), dateValue));
if (dDate < 1) {
info.GetReturnValue().SetNull();
return;
}
ByteString bsFormat;
if (argc > 1) {
v8::Local<v8::Value> formatValue = GetSimpleValue(info, 1);
if (ValueIsNull(info.GetIsolate(), formatValue)) {
info.GetReturnValue().SetNull();
return;
}
bsFormat = ValueToUTF8String(info.GetIsolate(), formatValue);
}
ByteString bsLocale;
if (argc > 2) {
v8::Local<v8::Value> localeValue = GetSimpleValue(info, 2);
if (ValueIsNull(info.GetIsolate(), localeValue)) {
info.GetReturnValue().SetNull();
return;
}
bsLocale = ValueToUTF8String(info.GetIsolate(), localeValue);
}
int32_t iYear = 1900;
int32_t iMonth = 1;
int32_t iDay = 1;
int32_t i = 0;
while (dDate > 0) {
if (iMonth == 2) {
if ((!((iYear + i) % 4) && ((iYear + i) % 100)) || !((iYear + i) % 400)) {
if (dDate > 29) {
++iMonth;
if (iMonth > 12) {
iMonth = 1;
++i;
}
iDay = 1;
dDate -= 29;
} else {
iDay += static_cast<int32_t>(dDate) - 1;
dDate = 0;
}
} else {
if (dDate > 28) {
++iMonth;
if (iMonth > 12) {
iMonth = 1;
++i;
}
iDay = 1;
dDate -= 28;
} else {
iDay += static_cast<int32_t>(dDate) - 1;
dDate = 0;
}
}
} else if (iMonth < 8) {
if ((iMonth % 2 == 0)) {
if (dDate > 30) {
++iMonth;
if (iMonth > 12) {
iMonth = 1;
++i;
}
iDay = 1;
dDate -= 30;
} else {
iDay += static_cast<int32_t>(dDate) - 1;
dDate = 0;
}
} else {
if (dDate > 31) {
++iMonth;
if (iMonth > 12) {
iMonth = 1;
++i;
}
iDay = 1;
dDate -= 31;
} else {
iDay += static_cast<int32_t>(dDate) - 1;
dDate = 0;
}
}
} else {
if (iMonth % 2 != 0) {
if (dDate > 30) {
++iMonth;
if (iMonth > 12) {
iMonth = 1;
++i;
}
iDay = 1;
dDate -= 30;
} else {
iDay += static_cast<int32_t>(dDate) - 1;
dDate = 0;
}
} else {
if (dDate > 31) {
++iMonth;
if (iMonth > 12) {
iMonth = 1;
++i;
}
iDay = 1;
dDate -= 31;
} else {
iDay += static_cast<int32_t>(dDate) - 1;
dDate = 0;
}
}
}
}
ByteString bsLocalDate = IsoDate2Local(
pThis,
ByteString::Format("%d%02d%02d", iYear + i, iMonth, iDay).AsStringView(),
bsFormat.AsStringView(), bsLocale.AsStringView());
info.GetReturnValue().Set(
fxv8::NewStringHelper(info.GetIsolate(), bsLocalDate.AsStringView()));
}
// static
void CFXJSE_FormCalcContext::Num2GMTime(
CFXJSE_HostObject* pThis,
const v8::FunctionCallbackInfo<v8::Value>& info) {
int32_t argc = info.Length();
if (argc < 1 || argc > 3) {
ToFormCalcContext(pThis)->ThrowParamCountMismatchException(L"Num2GMTime");
return;
}
v8::Local<v8::Value> timeValue = GetSimpleValue(info, 0);
if (fxv8::IsNull(timeValue)) {
info.GetReturnValue().SetNull();
return;
}
int32_t iTime =
static_cast<int32_t>(ValueToFloat(info.GetIsolate(), timeValue));
if (abs(iTime) < 1.0) {
info.GetReturnValue().SetNull();
return;
}
ByteString bsFormat;
if (argc > 1) {
v8::Local<v8::Value> formatValue = GetSimpleValue(info, 1);
if (fxv8::IsNull(formatValue)) {
info.GetReturnValue().SetNull();
return;
}
bsFormat = ValueToUTF8String(info.GetIsolate(), formatValue);
}
ByteString bsLocale;
if (argc > 2) {
v8::Local<v8::Value> localeValue = GetSimpleValue(info, 2);
if (fxv8::IsNull(localeValue)) {
info.GetReturnValue().SetNull();
return;
}
bsLocale = ValueToUTF8String(info.GetIsolate(), localeValue);
}
ByteString bsGMTTime = Num2AllTime(pThis, iTime, bsFormat.AsStringView(),
bsLocale.AsStringView(), true);
info.GetReturnValue().Set(
fxv8::NewStringHelper(info.GetIsolate(), bsGMTTime.AsStringView()));
}
// static
void CFXJSE_FormCalcContext::Num2Time(
CFXJSE_HostObject* pThis,
const v8::FunctionCallbackInfo<v8::Value>& info) {
int32_t argc = info.Length();
if (argc < 1 || argc > 3) {
ToFormCalcContext(pThis)->ThrowParamCountMismatchException(L"Num2Time");
return;
}
v8::Local<v8::Value> timeValue = GetSimpleValue(info, 0);
if (fxv8::IsNull(timeValue)) {
info.GetReturnValue().SetNull();
return;
}
float fTime = ValueToFloat(info.GetIsolate(), timeValue);
if (fabs(fTime) < 1.0) {
info.GetReturnValue().SetNull();
return;
}
ByteString bsFormat;
if (argc > 1) {
v8::Local<v8::Value> formatValue = GetSimpleValue(info, 1);
if (fxv8::IsNull(formatValue)) {
info.GetReturnValue().SetNull();
return;
}
bsFormat = ValueToUTF8String(info.GetIsolate(), formatValue);
}
ByteString bsLocale;
if (argc > 2) {
v8::Local<v8::Value> localeValue = GetSimpleValue(info, 2);
if (fxv8::IsNull(localeValue)) {
info.GetReturnValue().SetNull();
return;
}
bsLocale = ValueToUTF8String(info.GetIsolate(), localeValue);
}
ByteString bsLocalTime =
Num2AllTime(pThis, static_cast<int32_t>(fTime), bsFormat.AsStringView(),
bsLocale.AsStringView(), false);
info.GetReturnValue().Set(
fxv8::NewStringHelper(info.GetIsolate(), bsLocalTime.AsStringView()));
}
// static
void CFXJSE_FormCalcContext::Time(
CFXJSE_HostObject* pThis,
const v8::FunctionCallbackInfo<v8::Value>& info) {
if (info.Length()