From 221f0b3e09b9d77b1873a52fff23c7c39df251bb Mon Sep 17 00:00:00 2001 From: Tom Sepez Date: Mon, 4 Jun 2018 22:11:27 +0000 Subject: Lowercase JS_Define.{h,cpp} and CJS_Define.h Consistency with file naming conventions. No functional change. Change-Id: I596c4be5bbf0510950c44a7d9d80f59537739c3b Reviewed-on: https://pdfium-review.googlesource.com/33593 Commit-Queue: Tom Sepez Reviewed-by: Lei Zhang Reviewed-by: Tom Sepez --- fxjs/js_define.cpp | 312 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 312 insertions(+) create mode 100644 fxjs/js_define.cpp (limited to 'fxjs/js_define.cpp') diff --git a/fxjs/js_define.cpp b/fxjs/js_define.cpp new file mode 100644 index 0000000000..3e14a3dd1d --- /dev/null +++ b/fxjs/js_define.cpp @@ -0,0 +1,312 @@ +// 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/js_define.h" + +#include + +#include +#include +#include +#include + +#include "fxjs/cjs_document.h" +#include "fxjs/cjs_object.h" + +namespace { + +double GetLocalTZA() { + if (!FSDK_IsSandBoxPolicyEnabled(FPDF_POLICY_MACHINETIME_ACCESS)) + return 0; + time_t t = 0; + time(&t); + localtime(&t); +#if _FX_PLATFORM_ == _FX_PLATFORM_WINDOWS_ + // In gcc 'timezone' is a global variable declared in time.h. In VC++, that + // variable was removed in VC++ 2015, with _get_timezone replacing it. + long timezone = 0; + _get_timezone(&timezone); +#endif // _FX_PLATFORM_ == _FX_PLATFORM_WINDOWS_ + return (double)(-(timezone * 1000)); +} + +int GetDaylightSavingTA(double d) { + if (!FSDK_IsSandBoxPolicyEnabled(FPDF_POLICY_MACHINETIME_ACCESS)) + return 0; + time_t t = (time_t)(d / 1000); + struct tm* tmp = localtime(&t); + if (!tmp) + return 0; + if (tmp->tm_isdst > 0) + // One hour. + return (int)60 * 60 * 1000; + return 0; +} + +double Mod(double x, double y) { + double r = fmod(x, y); + if (r < 0) + r += y; + return r; +} + +bool IsLeapYear(int year) { + return (year % 4 == 0) && ((year % 100 != 0) || (year % 400 != 0)); +} + +int DayFromYear(int y) { + return (int)(365 * (y - 1970.0) + floor((y - 1969.0) / 4) - + floor((y - 1901.0) / 100) + floor((y - 1601.0) / 400)); +} + +double TimeFromYear(int y) { + return 86400000.0 * DayFromYear(y); +} + +static const uint16_t daysMonth[12] = {0, 31, 59, 90, 120, 151, + 181, 212, 243, 273, 304, 334}; +static const uint16_t leapDaysMonth[12] = {0, 31, 60, 91, 121, 152, + 182, 213, 244, 274, 305, 335}; + +double TimeFromYearMonth(int y, int m) { + const uint16_t* pMonth = IsLeapYear(y) ? leapDaysMonth : daysMonth; + return TimeFromYear(y) + ((double)pMonth[m]) * 86400000; +} + +int Day(double t) { + return static_cast(floor(t / 86400000.0)); +} + +int YearFromTime(double t) { + // estimate the time. + int y = 1970 + static_cast(t / (365.2425 * 86400000.0)); + if (TimeFromYear(y) <= t) { + while (TimeFromYear(y + 1) <= t) + y++; + } else { + while (TimeFromYear(y) > t) + y--; + } + return y; +} + +int DayWithinYear(double t) { + int year = YearFromTime(t); + int day = Day(t); + return day - DayFromYear(year); +} + +int MonthFromTime(double t) { + int day = DayWithinYear(t); + int year = YearFromTime(t); + if (0 <= day && day < 31) + return 0; + if (31 <= day && day < 59 + IsLeapYear(year)) + return 1; + if ((59 + IsLeapYear(year)) <= day && day < (90 + IsLeapYear(year))) + return 2; + if ((90 + IsLeapYear(year)) <= day && day < (120 + IsLeapYear(year))) + return 3; + if ((120 + IsLeapYear(year)) <= day && day < (151 + IsLeapYear(year))) + return 4; + if ((151 + IsLeapYear(year)) <= day && day < (181 + IsLeapYear(year))) + return 5; + if ((181 + IsLeapYear(year)) <= day && day < (212 + IsLeapYear(year))) + return 6; + if ((212 + IsLeapYear(year)) <= day && day < (243 + IsLeapYear(year))) + return 7; + if ((243 + IsLeapYear(year)) <= day && day < (273 + IsLeapYear(year))) + return 8; + if ((273 + IsLeapYear(year)) <= day && day < (304 + IsLeapYear(year))) + return 9; + if ((304 + IsLeapYear(year)) <= day && day < (334 + IsLeapYear(year))) + return 10; + if ((334 + IsLeapYear(year)) <= day && day < (365 + IsLeapYear(year))) + return 11; + + return -1; +} + +int DateFromTime(double t) { + int day = DayWithinYear(t); + int year = YearFromTime(t); + int leap = IsLeapYear(year); + int month = MonthFromTime(t); + switch (month) { + case 0: + return day + 1; + case 1: + return day - 30; + case 2: + return day - 58 - leap; + case 3: + return day - 89 - leap; + case 4: + return day - 119 - leap; + case 5: + return day - 150 - leap; + case 6: + return day - 180 - leap; + case 7: + return day - 211 - leap; + case 8: + return day - 242 - leap; + case 9: + return day - 272 - leap; + case 10: + return day - 303 - leap; + case 11: + return day - 333 - leap; + default: + return 0; + } +} + +} // namespace + +void JSDestructor(v8::Local obj) { + CFXJS_Engine::SetObjectPrivate(obj, nullptr); +} + +double JS_GetDateTime() { + if (!FSDK_IsSandBoxPolicyEnabled(FPDF_POLICY_MACHINETIME_ACCESS)) + return 0; + time_t t = time(nullptr); + struct tm* pTm = localtime(&t); + + int year = pTm->tm_year + 1900; + double t1 = TimeFromYear(year); + + return t1 + pTm->tm_yday * 86400000.0 + pTm->tm_hour * 3600000.0 + + pTm->tm_min * 60000.0 + pTm->tm_sec * 1000.0; +} + +int JS_GetYearFromTime(double dt) { + return YearFromTime(dt); +} + +int JS_GetMonthFromTime(double dt) { + return MonthFromTime(dt); +} + +int JS_GetDayFromTime(double dt) { + return DateFromTime(dt); +} + +int JS_GetHourFromTime(double dt) { + return (int)Mod(floor(dt / (60 * 60 * 1000)), 24); +} + +int JS_GetMinFromTime(double dt) { + return (int)Mod(floor(dt / (60 * 1000)), 60); +} + +int JS_GetSecFromTime(double dt) { + return (int)Mod(floor(dt / 1000), 60); +} + +double JS_LocalTime(double d) { + return d + GetLocalTZA() + GetDaylightSavingTA(d); +} + +double JS_DateParse(const WideString& str) { + v8::Isolate* pIsolate = v8::Isolate::GetCurrent(); + v8::Isolate::Scope isolate_scope(pIsolate); + v8::HandleScope scope(pIsolate); + + v8::Local context = pIsolate->GetCurrentContext(); + + // Use the built-in object method. + v8::Local v = + context->Global() + ->Get(context, v8::String::NewFromUtf8(pIsolate, "Date", + v8::NewStringType::kNormal) + .ToLocalChecked()) + .ToLocalChecked(); + if (v->IsObject()) { + v8::Local o = v->ToObject(context).ToLocalChecked(); + v = o->Get(context, v8::String::NewFromUtf8(pIsolate, "parse", + v8::NewStringType::kNormal) + .ToLocalChecked()) + .ToLocalChecked(); + if (v->IsFunction()) { + v8::Local funC = v8::Local::Cast(v); + const int argc = 1; + v8::Local timeStr = + CJS_Runtime::RuntimeFromIsolateCurrentContext(pIsolate)->NewString( + str.AsStringView()); + v8::Local argv[argc] = {timeStr}; + v = funC->Call(context, context->Global(), argc, argv).ToLocalChecked(); + if (v->IsNumber()) { + double date = v->ToNumber(context).ToLocalChecked()->Value(); + if (!std::isfinite(date)) + return date; + return JS_LocalTime(date); + } + } + } + return 0; +} + +double JS_MakeDay(int nYear, int nMonth, int nDate) { + double y = static_cast(nYear); + double m = static_cast(nMonth); + double dt = static_cast(nDate); + double ym = y + floor(m / 12); + double mn = Mod(m, 12); + double t = TimeFromYearMonth(static_cast(ym), static_cast(mn)); + if (YearFromTime(t) != ym || MonthFromTime(t) != mn || DateFromTime(t) != 1) + return std::nan(""); + + return Day(t) + dt - 1; +} + +double JS_MakeTime(int nHour, int nMin, int nSec, int nMs) { + double h = static_cast(nHour); + double m = static_cast(nMin); + double s = static_cast(nSec); + double milli = static_cast(nMs); + return h * 3600000 + m * 60000 + s * 1000 + milli; +} + +double JS_MakeDate(double day, double time) { + if (!std::isfinite(day) || !std::isfinite(time)) + return std::nan(""); + + return day * 86400000 + time; +} + +std::vector> ExpandKeywordParams( + CJS_Runtime* pRuntime, + const std::vector>& originals, + size_t nKeywords, + ...) { + ASSERT(nKeywords); + + std::vector> result(nKeywords, v8::Local()); + size_t size = std::min(originals.size(), nKeywords); + for (size_t i = 0; i < size; ++i) + result[i] = originals[i]; + + if (originals.size() != 1 || !originals[0]->IsObject() || + originals[0]->IsArray()) { + return result; + } + result[0] = v8::Local(); // Make unknown. + + v8::Local pObj = pRuntime->ToObject(originals[0]); + va_list ap; + va_start(ap, nKeywords); + for (size_t i = 0; i < nKeywords; ++i) { + const wchar_t* property = va_arg(ap, const wchar_t*); + v8::Local v8Value = pRuntime->GetObjectProperty(pObj, property); + if (!v8Value->IsUndefined()) + result[i] = v8Value; + } + va_end(ap); + + return result; +} -- cgit v1.2.3