// 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/cjs_util.h"
#include <time.h>
#include <algorithm>
#include <cmath>
#include <cwctype>
#include <string>
#include <vector>
#include "core/fxcrt/fx_extension.h"
#include "fxjs/JS_Define.h"
#include "fxjs/cjs_event_context.h"
#include "fxjs/cjs_eventhandler.h"
#include "fxjs/cjs_object.h"
#include "fxjs/cjs_publicmethods.h"
#include "fxjs/cjs_runtime.h"
#include "fxjs/js_resources.h"
#if _FX_OS_ == _FX_OS_ANDROID_
#include <ctype.h>
#endif
namespace {
// Map PDF-style directives to equivalent wcsftime directives. Not
// all have direct equivalents, though.
struct TbConvert {
const wchar_t* lpszJSMark;
const wchar_t* lpszCppMark;
};
// Map PDF-style directives lacking direct wcsftime directives to
// the value with which they will be replaced.
struct TbConvertAdditional {
const wchar_t* lpszJSMark;
int iValue;
};
const TbConvert TbConvertTable[] = {
{L"mmmm", L"%B"}, {L"mmm", L"%b"}, {L"mm", L"%m"}, {L"dddd", L"%A"},
{L"ddd", L"%a"}, {L"dd", L"%d"}, {L"yyyy", L"%Y"}, {L"yy", L"%y"},
{L"HH", L"%H"}, {L"hh", L"%I"}, {L"MM", L"%M"}, {L"ss", L"%S"},
{L"TT", L"%p"},
#if defined(_WIN32)
{L"tt", L"%p"}, {L"h", L"%#I"},
#else
{L"tt", L"%P"}, {L"h", L"%l"},
#endif
};
} // namespace
const JSMethodSpec CJS_Util::MethodSpecs[] = {
{"printd", printd_static},
{"printf", printf_static},
{"printx", printx_static},
{"scand", scand_static},
{"byteToChar", byteToChar_static}};
int CJS_Util::ObjDefnID = -1;
// static
void CJS_Util::DefineJSObjects(CFXJS_Engine* pEngine) {
ObjDefnID =
pEngine->DefineObj("util", FXJSOBJTYPE_STATIC,
JSConstructor<CJS_Util, util>, JSDestructor<CJS_Util>);
DefineMethods(pEngine, ObjDefnID, MethodSpecs, FX_ArraySize(MethodSpecs));
}
util::util(CJS_Object* pJSObject) : CJS_EmbedObj(pJSObject) {}
util::~util() {}
CJS_Return util::printf(CJS_Runtime* pRuntime,
const std::vector<v8::Local<v8::Value>>& params) {
const size_t iSize = params.size();
if (iSize < 1)
return CJS_Return(false);
std::wstring unsafe_fmt_string(pRuntime->ToWideString(params[0]).c_str());
std::vector<std::wstring> unsafe_conversion_specifiers;
int iOffset = 0;
int iOffend = 0;
unsafe_fmt_string.insert(unsafe_fmt_string.begin(), L'S');
while (iOffset != -1) {
iOffend = unsafe_fmt_string.find(L"%", iOffset + 1);
std::wstring strSub;
if (iOffend == -1)
strSub = unsafe_fmt_string.substr(iOffset);
else
strSub = unsafe_fmt_string.substr(iOffset, iOffend - iOffset);
unsafe_conversion_specifiers.push_back(strSub);
iOffset = iOffend;
}
std::wstring c_strResult;
for (size_t iIndex = 0; iIndex < unsafe_conversion_specifiers.size();
++iIndex) {
std::wstring c_strFormat = unsafe_conversion_specifiers[iIndex];
if (iIndex == 0) {
c_strResult = c_strFormat;
continue;
}
if (iIndex >= iSize) {
c_strResult += c_strFormat;
continue;
}
WideString strSegment;
switch (ParseDataType(&c_strFormat)) {
case UTIL_INT:
strSegment = WideString::Format(c_strFormat.c_str(),
pRuntime->ToInt32(params[iIndex]));
break;
case UTIL_DOUBLE:
strSegment = WideString::Format(c_strFormat.c_str(),
pRuntime->ToDouble(params[iIndex]));
break;
case UTIL_STRING:
strSegment =
WideString::Format(c_strFormat.c_str(),
pRuntime->ToWideString(params[iIndex]).c_str());
break;
default:
strSegment = WideString::Format(L"%ls", c_strFormat.c_str());
break;
}
c_strResult += strSegment.c_str();
}
c_strResult.erase(c_strResult.begin());
return CJS_Return(pRuntime->NewString(c_strResult.c_str()));
}
CJS_Return util::printd(CJS_Runtime* pRuntime,
const std::vector<v8::Local<v8::Value>>& params) {
const size_t iSize = params.size();
if (iSize < 2)
return CJS_Return(false);
if (params[1].IsEmpty() || !params[1]->IsDate())
return CJS_Return(JSGetStringFromID(JSMessage::kSecondParamNotDateError));
v8::Local<v8::Date> v8_date = params[1].As<v8::Date>();
if (v8_date.IsEmpty() || std::isnan(pRuntime->ToDouble(v8_date))) {
return CJS_Return(
JSGetStringFromID(JSMessage::kSecondParamInvalidDateError));
}
double date = JS_LocalTime(pRuntime->ToDouble(v8_date));
int year = JS_GetYearFromTime(date);
int month = JS_GetMonthFromTime(date) + 1; // One-based.
int day = JS_GetDayFromTime(date);
int hour = JS_GetHourFromTime(date);
int min = JS_GetMinFromTime(date);
int sec = JS_GetSecFromTime(date);
if (params[0]->IsNumber()) {
WideString swResult;
switch (pRuntime->ToInt32(params[0])) {
case 0:
swResult = WideString::Format(L"D:%04d%02d%02d%02d%02d%02d", year,
month, day, hour, min, sec);
break;
case 1:
swResult = WideString::Format(L"%04d.%02d.%02d %02d:%02d:%02d", year,
month, day, hour, min, sec);
break;
case 2:
swResult = WideString::Format(L"%04d/%02d/%02d %02d:%02d:%02d", year,
month, day, hour, min, sec);
break;
default:
return CJS_Return(JSGetStringFromID(JSMessage::kValueError));
}
return CJS_Return(pRuntime->NewString(swResult.c_str()));
}
if (params[0]->IsString()) {
// We don't support XFAPicture at the moment.
if (iSize > 2 && pRuntime->ToBoolean(params[2]))
return CJS_Return(JSGetStringFromID(JSMessage::kNotSupportedError));
// Convert PDF-style format specifiers to wcsftime specifiers. Remove any
// pre-existing %-directives before inserting our own.
std::basic_string<wchar_t> cFormat =
pRuntime->ToWideString(params[0]).c_str();
cFormat.erase(std::remove(cFormat.begin(), cFormat.end(), '%'),
cFormat.end());
for (size_t i = 0; i < FX_ArraySize(TbConvertTable); ++i) {
int iStart = 0;
int iEnd;
while ((iEnd = cFormat.find(TbConvertTable[i].lpszJSMark, iStart)) !=
-1) {
cFormat.replace(iEnd, wcslen(TbConvertTable[i].lpszJSMark),
TbConvertTable[i].lpszCppMark);
iStart = iEnd;
}
}
if (year < 0)
return CJS_Return(JSGetStringFromID(JSMessage::kValueError));
static const TbConvertAdditional cTableAd[] = {
{L"m", month}, {L"d", day},
{L"H", hour}, {L"h", hour > 12 ? hour - 12 : hour},
{L"M", min}, {L"s", sec},
};
for (size_t i = 0; i < FX_ArraySize(cTableAd); ++i) {
int iStart = 0;
int iEnd;
while ((iEnd = cFormat.find(cTableAd[i].lpszJSMark, iStart)) != -1) {
if (iEnd > 0) {
if (cFormat[iEnd - 1] == L'%') {
iStart = iEnd + 1;
continue;
}
}
cFormat.replace(iEnd, wcslen(cTableAd[i].lpszJSMark),
WideString::Format(L"%d", cTableAd[i].iValue).c_str());
iStart = iEnd;
}
}
struct tm time = {};
time.tm_year = year - 1900;
time.tm_mon = month - 1;
time.tm_mday = day;
time.tm_hour = hour;
time.tm_min = min;
time.tm_sec = sec;
wchar_t buf[64] = {};
FXSYS_wcsftime(buf, 64, cFormat.c_str(), &time);
cFormat = buf;
return CJS_Return(pRuntime->NewString(cFormat.c_str()));
}
return CJS_Return(JSGetStringFromID(JSMessage::kTypeError));
}
CJS_Return util::printx(CJS_Runtime* pRuntime,
const std::vector<v8::Local<v8::Value>>& params) {
if (params.size() < 2)
return CJS_Return(JSGetStringFromID(JSMessage::kParamError));
return CJS_Return(
pRuntime->NewString(printx(pRuntime->ToWideString(params[0]),
pRuntime->ToWideString(params[1]))
.c_str()));
}
enum CaseMode { kPreserveCase, kUpperCase, kLowerCase };
static wchar_t TranslateCase(wchar_t input, CaseMode eMode) {
if (eMode == kLowerCase && FXSYS_isupper(input))
return input | 0x20;
if (eMode == kUpperCase && FXSYS_islower(input))
return input & ~0x20;
return input;
}
WideString util::printx(const WideString& wsFormat,
const WideString& wsSource) {
WideString wsResult;
size_t iSourceIdx = 0;
size_t iFormatIdx = 0;
CaseMode eCaseMode = kPreserveCase;
bool bEscaped = false;
while (iFormatIdx < wsFormat.GetLength()) {
if (bEscaped) {
bEscaped = false;
wsResult += wsFormat[iFormatIdx];
++iFormatIdx;
continue;
}
switch (wsFormat[iFormatIdx]) {
case '\\': {
bEscaped = true;
++iFormatIdx;
} break;
case '<': {
eCaseMode = kLowerCase;
++iFormatIdx;
} break;
case '>': {
eCaseMode = kUpperCase;
++iFormatIdx;
} break;
case '=': {
eCaseMode = kPreserveCase;
++iFormatIdx;
} break;
case '?': {
if (iSourceIdx < wsSource.GetLength()) {
wsResult += TranslateCase(wsSource[iSourceIdx], eCaseMode);
++iSourceIdx;
}
++iFormatIdx;
} break;
case 'X': {
if (iSourceIdx < wsSource.GetLength()) {
if (FXSYS_iswalnum(wsSource[iSourceIdx])) {
wsResult += TranslateCase(wsSource[iSourceIdx], eCaseMode);
++iFormatIdx;
}
++iSourceIdx;
} else {
++iFormatIdx;
}
} break;
case 'A': {
if (iSourceIdx < wsSource.GetLength()) {
if (FXSYS_iswalpha(wsSource[iSourceIdx])) {
wsResult += TranslateCase(wsSource[iSourceIdx], eCaseMode);
++iFormatIdx;
}
++iSourceIdx;
} else {
++iFormatIdx;
}
} break;
case '9': {
if (iSourceIdx < wsSource.GetLength()) {
if (std::iswdigit(wsSource[iSourceIdx])) {
wsResult += wsSource[iSourceIdx];
++iFormatIdx;
}
++iSourceIdx;
} else {
++iFormatIdx;
}
} break;
case '*': {
if (iSourceIdx < wsSource.GetLength()) {
wsResult += TranslateCase(wsSource[iSourceIdx], eCaseMode);
++iSourceIdx;
} else {
++iFormatIdx;
}
} break;
default: {
wsResult += wsFormat[iFormatIdx];
++iFormatIdx;
} break;
}
}
return wsResult;
}
CJS_Return util::scand(CJS_Runtime* pRuntime,
const std::vector<v8::Local<v8::Value>>& params) {
if (params.size() < 2)
return CJS_Return(false);
WideString sFormat = pRuntime->ToWideString(params[0]);
WideString sDate = pRuntime->ToWideString(params[1]);
double dDate = JS_GetDateTime();
if (sDate.GetLength() > 0)
dDate = CJS_PublicMethods::MakeRegularDate(sDate, sFormat, nullptr);
if (std::isnan(dDate))
return CJS_Return(pRuntime->NewUndefined());
return CJS_Return(pRuntime->NewDate(dDate));
}
CJS_Return util::byteToChar(CJS_Runtime* pRuntime,
const std::vector<v8::Local<v8::Value>>& params) {
if (params.size() < 1)
return CJS_Return(JSGetStringFromID(JSMessage::kParamError));
int arg = pRuntime->ToInt32(params[0]);
if (arg < 0 || arg > 255)
return CJS_Return(JSGetStringFromID(JSMessage::kValueError));
WideString wStr(static_cast<wchar_t>(arg));
return CJS_Return(pRuntime->NewString(wStr.c_str()));
}
// Ensure that sFormat contains at most one well-understood printf formatting
// directive which is safe to use with a single argument, and return the type
// of argument expected, or -1 otherwise. If -1 is returned, it is NOT safe
// to use sFormat with printf() and it must be copied byte-by-byte.
int util::ParseDataType(std::wstring* sFormat) {
enum State { BEFORE, FLAGS, WIDTH, PRECISION, SPECIFIER, AFTER };
int result = -1;
State state = BEFORE;
size_t precision_digits = 0;
size_t i = 0;
while (i < sFormat->length()) {
wchar_t c = (*sFormat)[i];
switch (state) {
case BEFORE:
if (c == L'%')
state = FLAGS;
break;
case FLAGS:
if (c == L'+' || c == L'-' || c == L'#' || c == L' ') {
// Stay in same state.
} else {
state = WIDTH;
continue; // Re-process same character.
}
break;
case WIDTH:
if (c == L'*')
return -1;
if (std::iswdigit(c)) {
// Stay in same state.
} else if (c == L'.') {
state = PRECISION;
} else {
state = SPECIFIER;
continue; // Re-process same character.
}
break;
case PRECISION:
if (c == L'*')
return -1;
if (std::iswdigit(c)) {
// Stay in same state.
++precision_digits;
} else {
state = SPECIFIER;
continue; // Re-process same character.
}
break;
case SPECIFIER:
if (c == L'c' || c == L'C' || c == L'd' || c == L'i' || c == L'o' ||
c == L'u' || c == L'x' || c == L'X') {
result = UTIL_INT;
} else if (c == L'e' || c == L'E' || c == L'f' || c == L'g' ||
c == L'G') {
result = UTIL_DOUBLE;
} else if (c == L's' || c == L'S') {
// Map s to S since we always deal internally with wchar_t strings.
// TODO(tsepez): Probably 100% borked. %S is not a standard
// conversion.
(*sFormat)[i] = L'S';
result = UTIL_STRING;
} else {
return -1;
}
state = AFTER;
break;
case AFTER:
if (c == L'%')
return -1;
// Stay in same state until string exhausted.
break;
}
++i;
}
// See https://crbug.com/740166
if (result == UTIL_INT && precision_digits > 2)
return -1;
return result;
}