void FXJSE_ThrowMessage(const CFX_ByteStringC& utf8Name,
const CFX_ByteStringC& utf8Message) {
v8::Isolate* pIsolate = v8::Isolate::GetCurrent();
ASSERT(pIsolate);
CFXJSE_ScopeUtil_IsolateHandleRootContext scope(pIsolate);
v8::Local<v8::String> hMessage = v8::String::NewFromUtf8(
pIsolate, utf8Message.GetCStr(), v8::String::kNormalString,
utf8Message.GetLength());
v8::Local<v8::Value> hError;
if (utf8Name == "RangeError") {
hError = v8::Exception::RangeError(hMessage);
} else if (utf8Name == "ReferenceError") {
hError = v8::Exception::ReferenceError(hMessage);
} else if (utf8Name == "SyntaxError") {
hError = v8::Exception::SyntaxError(hMessage);
} else if (utf8Name == "TypeError") {
hError = v8::Exception::TypeError(hMessage);
} else {
hError = v8::Exception::Error(hMessage);
if (utf8Name != "Error" && !utf8Name.IsEmpty()) {
hError.As<v8::Object>()->Set(
v8::String::NewFromUtf8(pIsolate, "name"),
v8::String::NewFromUtf8(pIsolate, utf8Name.GetCStr(),
v8::String::kNormalString,
utf8Name.GetLength()));
}
}
pIsolate->ThrowException(hError);
}
bool CFX_ByteString::operator==(const CFX_ByteStringC& str) const {
if (!m_pData)
return str.IsEmpty();
return m_pData->m_nDataLength == str.GetLength() &&
FXSYS_memcmp(m_pData->m_String, str.c_str(), str.GetLength()) == 0;
}
void CPDF_GeneralStateData::SetBlendMode(const CFX_ByteStringC& blend_mode) {
if (blend_mode.GetLength() > 15) {
return;
}
FXSYS_memcpy(m_BlendMode, blend_mode.raw_str(), blend_mode.GetLength());
m_BlendMode[blend_mode.GetLength()] = 0;
m_BlendType = GetBlendTypeInternal(blend_mode);
}
CFX_ByteString::CFX_ByteString(const CFX_ByteStringC& str1,
const CFX_ByteStringC& str2) {
int nNewLen = str1.GetLength() + str2.GetLength();
if (nNewLen == 0)
return;
m_pData.Reset(StringData::Create(nNewLen));
m_pData->CopyContents(str1.c_str(), str1.GetLength());
m_pData->CopyContentsAt(str1.GetLength(), str2.c_str(), str2.GetLength());
}
void CFX_CMapByteStringToPtr::SetAt(const CFX_ByteStringC& key, void* value) {
ASSERT(value != NULL);
int index, key_len = key.GetLength();
int size = m_Buffer.GetSize();
for (index = 0; index < size; index++) {
_CompactString* pKey = (_CompactString*)m_Buffer.GetAt(index);
if (!_CompactStringSame(pKey, key.GetPtr(), key_len)) {
continue;
}
*(void**)(pKey + 1) = value;
return;
}
for (index = 0; index < size; index++) {
_CompactString* pKey = (_CompactString*)m_Buffer.GetAt(index);
if (pKey->m_CompactLen) {
continue;
}
_CompactStringStore(pKey, key.GetPtr(), key_len);
*(void**)(pKey + 1) = value;
return;
}
_CompactString* pKey = (_CompactString*)m_Buffer.Add();
_CompactStringStore(pKey, key.GetPtr(), key_len);
*(void**)(pKey + 1) = value;
}
void CFX_CMapByteStringToPtr::AddValue(const CFX_ByteStringC& key,
void* value) {
ASSERT(value != NULL);
_CompactString* pKey = (_CompactString*)m_Buffer.Add();
_CompactStringStore(pKey, key.GetPtr(), key.GetLength());
*(void**)(pKey + 1) = value;
}
void CXML_Parser::SkipLiterals(const CFX_ByteStringC& str) {
m_nOffset = m_nBufferOffset + (FX_FILESIZE)m_dwIndex;
if (IsEOF()) {
return;
}
int32_t i = 0, iLen = str.GetLength();
do {
while (m_dwIndex < m_dwBufferSize) {
if (str.GetAt(i) != m_pBuffer[m_dwIndex++]) {
i = 0;
} else {
i++;
if (i == iLen) {
break;
}
}
}
m_nOffset = m_nBufferOffset + (FX_FILESIZE)m_dwIndex;
if (i == iLen) {
return;
}
if (m_dwIndex < m_dwBufferSize || IsEOF()) {
break;
}
} while (ReadNextBlock());
while (!m_pDataAcc->IsEOF()) {
ReadNextBlock();
m_nOffset = m_nBufferOffset + (FX_FILESIZE)m_dwBufferSize;
}
m_dwIndex = m_dwBufferSize;
}
void CFXJSE_Value::SetString(const CFX_ByteStringC& szString) {
CFXJSE_ScopeUtil_IsolateHandle scope(m_pIsolate);
v8::Local<v8::Value> hValue = v8::String::NewFromUtf8(
m_pIsolate, reinterpret_cast<const char*>(szString.raw_str()),
v8::String::kNormalString, szString.GetLength());
m_hValue.Reset(m_pIsolate, hValue);
}
static void FXJSE_DynPropGetterAdapter(const FXJSE_CLASS* lpClass,
FXJSE_HOBJECT hObject,
const CFX_ByteStringC& szPropName,
FXJSE_HVALUE hValue) {
ASSERT(lpClass);
int32_t nPropType =
lpClass->dynPropTypeGetter == nullptr
? FXJSE_ClassPropType_Property
: lpClass->dynPropTypeGetter(hObject, szPropName, FALSE);
if (nPropType == FXJSE_ClassPropType_Property) {
if (lpClass->dynPropGetter) {
lpClass->dynPropGetter(hObject, szPropName, hValue);
}
} else if (nPropType == FXJSE_ClassPropType_Method) {
if (lpClass->dynMethodCall && hValue) {
CFXJSE_Value* lpValue = reinterpret_cast<CFXJSE_Value*>(hValue);
v8::Isolate* pIsolate = lpValue->GetIsolate();
v8::HandleScope hscope(pIsolate);
v8::Local<v8::ObjectTemplate> hCallBackInfoTemplate =
v8::ObjectTemplate::New();
hCallBackInfoTemplate->SetInternalFieldCount(2);
v8::Local<v8::Object> hCallBackInfo =
hCallBackInfoTemplate->NewInstance();
hCallBackInfo->SetAlignedPointerInInternalField(
0, const_cast<FXJSE_CLASS*>(lpClass));
hCallBackInfo->SetInternalField(
1, v8::String::NewFromUtf8(
pIsolate, reinterpret_cast<const char*>(szPropName.GetPtr()),
v8::String::kNormalString, szPropName.GetLength()));
lpValue->ForceSetValue(v8::Function::New(
lpValue->GetIsolate(), FXJSE_DynPropGetterAdapter_MethodCallback,
hCallBackInfo));
}
}
}
bool CFX_ByteString::EqualNoCase(const CFX_ByteStringC& str) const {
if (!m_pData)
return str.IsEmpty();
FX_STRSIZE len = str.GetLength();
if (m_pData->m_nDataLength != len)
return false;
const uint8_t* pThis = (const uint8_t*)m_pData->m_String;
const uint8_t* pThat = str.raw_str();
for (FX_STRSIZE i = 0; i < len; i++) {
if ((*pThis) != (*pThat)) {
uint8_t bThis = *pThis;
if (bThis >= 'A' && bThis <= 'Z')
bThis += 'a' - 'A';
uint8_t bThat = *pThat;
if (bThat >= 'A' && bThat <= 'Z')
bThat += 'a' - 'A';
if (bThis != bThat)
return false;
}
pThis++;
pThat++;
}
return true;
}
FX_BOOL CJS_Runtime::GetValueByName(const CFX_ByteStringC& utf8Name,
CFXJSE_Value* pValue) {
const FX_CHAR* name = utf8Name.c_str();
v8::Isolate::Scope isolate_scope(GetIsolate());
v8::HandleScope handle_scope(GetIsolate());
v8::Local<v8::Context> old_context = GetIsolate()->GetCurrentContext();
v8::Local<v8::Context> context =
v8::Local<v8::Context>::New(GetIsolate(), m_context);
v8::Context::Scope context_scope(context);
// Caution: We're about to hand to XFA an object that in order to invoke
// methods will require that the current v8::Context always has a pointer
// to a CJS_Runtime in its embedder data slot. Unfortunately, XFA creates
// its own v8::Context which has not initialized the embedder data slot.
// Do so now.
// TODO(tsepez): redesign PDF-side objects to not rely on v8::Context's
// embedder data slots, and/or to always use the right context.
FXJS_SetRuntimeForV8Context(old_context, this);
v8::Local<v8::Value> propvalue =
context->Global()->Get(v8::String::NewFromUtf8(
GetIsolate(), name, v8::String::kNormalString, utf8Name.GetLength()));
if (propvalue.IsEmpty()) {
pValue->SetUndefined();
return FALSE;
}
pValue->ForceSetValue(propvalue);
return TRUE;
}
bool FX_atonum(const CFX_ByteStringC& strc, void* pData) {
if (strc.Find('.') != -1) {
FX_FLOAT* pFloat = static_cast<FX_FLOAT*>(pData);
*pFloat = FX_atof(strc);
return false;
}
// Note, numbers in PDF are typically of the form 123, -123, etc. But,
// for things like the Permissions on the encryption hash the number is
// actually an unsigned value. We use a uint32_t so we can deal with the
// unsigned and then check for overflow if the user actually signed the value.
// The Permissions flag is listed in Table 3.20 PDF 1.7 spec.
pdfium::base::CheckedNumeric<uint32_t> integer = 0;
bool bNegative = false;
bool bSigned = false;
int cc = 0;
if (strc[0] == '+') {
cc++;
bSigned = true;
} else if (strc[0] == '-') {
bNegative = true;
bSigned = true;
cc++;
}
while (cc < strc.GetLength() && std::isdigit(strc[cc])) {
integer = integer * 10 + FXSYS_toDecimalDigit(strc.CharAt(cc));
if (!integer.IsValid())
break;
cc++;
}
// We have a sign, and the value was greater then a regular integer
// we've overflowed, reset to the default value.
if (bSigned) {
if (bNegative) {
if (integer.ValueOrDefault(kDefaultIntValue) >
static_cast<uint32_t>(std::numeric_limits<int>::max()) + 1) {
integer = kDefaultIntValue;
}
} else if (integer.ValueOrDefault(kDefaultIntValue) >
static_cast<uint32_t>(std::numeric_limits<int>::max())) {
integer = kDefaultIntValue;
}
}
// Switch back to the int space so we can flip to a negative if we need.
int value = static_cast<int>(integer.ValueOrDefault(kDefaultIntValue));
if (bNegative)
value = -value;
int* pInt = static_cast<int*>(pData);
*pInt = value;
return true;
}
void FXJSE_ThrowMessage(const CFX_ByteStringC& utf8Message) {
v8::Isolate* pIsolate = v8::Isolate::GetCurrent();
ASSERT(pIsolate);
CFXJSE_ScopeUtil_IsolateHandleRootContext scope(pIsolate);
v8::Local<v8::String> hMessage = v8::String::NewFromUtf8(
pIsolate, utf8Message.c_str(), v8::String::kNormalString,
utf8Message.GetLength());
v8::Local<v8::Value> hError = v8::Exception::Error(hMessage);
pIsolate->ThrowException(hError);
}
void FX_XML_SplitQualifiedName(const CFX_ByteStringC& bsFullName,
CFX_ByteStringC& bsSpace,
CFX_ByteStringC& bsName) {
if (bsFullName.IsEmpty()) {
return;
}
int32_t iStart = 0;
for (; iStart < bsFullName.GetLength(); iStart++) {
if (bsFullName.GetAt(iStart) == ':') {
break;
}
}
if (iStart >= bsFullName.GetLength()) {
bsName = bsFullName;
} else {
bsSpace = CFX_ByteStringC(bsFullName.GetCStr(), iStart);
iStart++;
bsName = CFX_ByteStringC(bsFullName.GetCStr() + iStart,
bsFullName.GetLength() - iStart);
}
}
FX_BOOL CFXJSE_Value::DeleteObjectProperty(const CFX_ByteStringC& szPropName) {
CFXJSE_ScopeUtil_IsolateHandleRootContext scope(m_pIsolate);
v8::Local<v8::Value> hObject =
v8::Local<v8::Value>::New(m_pIsolate, m_hValue);
if (!hObject->IsObject()) {
return FALSE;
}
hObject.As<v8::Object>()->Delete(v8::String::NewFromUtf8(
m_pIsolate, szPropName.GetCStr(), v8::String::kNormalString,
szPropName.GetLength()));
return TRUE;
}
static uint32_t FPF_SKIANormalizeFontName(const CFX_ByteStringC& bsfamily) {
uint32_t dwHash = 0;
int32_t iLength = bsfamily.GetLength();
const FX_CHAR* pBuffer = bsfamily.c_str();
for (int32_t i = 0; i < iLength; i++) {
FX_CHAR ch = pBuffer[i];
if (ch == ' ' || ch == '-' || ch == ',') {
continue;
}
dwHash = 31 * dwHash + FXSYS_tolower(ch);
}
return dwHash;
}
void CFX_CMapByteStringToPtr::RemoveKey(const CFX_ByteStringC& key) {
int key_len = key.GetLength();
int size = m_Buffer.GetSize();
for (int index = 0; index < size; index++) {
_CompactString* pKey = (_CompactString*)m_Buffer.GetAt(index);
if (!_CompactStringSame(pKey, key.GetPtr(), key_len)) {
continue;
}
_CompactStringRelease(pKey);
pKey->m_CompactLen = 0xfe;
return;
}
}
FX_BOOL CFXJSE_Value::HasObjectOwnProperty(const CFX_ByteStringC& szPropName,
FX_BOOL bUseTypeGetter) {
CFXJSE_ScopeUtil_IsolateHandleRootContext scope(m_pIsolate);
v8::Local<v8::Value> hObject =
v8::Local<v8::Value>::New(m_pIsolate, m_hValue);
if (!hObject->IsObject()) {
return FALSE;
}
v8::Local<v8::String> hKey = v8::String::NewFromUtf8(
m_pIsolate, szPropName.GetCStr(), v8::String::kNormalString,
szPropName.GetLength());
return hObject.As<v8::Object>()->HasRealNamedProperty(hKey) ||
(bUseTypeGetter && hObject.As<v8::Object>()->HasOwnProperty(hKey));
}
FX_BOOL CPDF_SimpleParser::SearchToken(const CFX_ByteStringC& token) {
int token_len = token.GetLength();
while (m_dwCurPos < m_dwSize - token_len) {
if (FXSYS_memcmp(m_pData + m_dwCurPos, token.GetPtr(), token_len) == 0) {
break;
}
m_dwCurPos++;
}
if (m_dwCurPos == m_dwSize - token_len) {
return FALSE;
}
m_dwCurPos += token_len;
return TRUE;
}
FX_BOOL CFXJSE_Value::GetObjectProperty(const CFX_ByteStringC& szPropName,
CFXJSE_Value* lpPropValue) {
ASSERT(lpPropValue);
CFXJSE_ScopeUtil_IsolateHandleRootContext scope(m_pIsolate);
v8::Local<v8::Value> hObject =
v8::Local<v8::Value>::New(m_pIsolate, m_hValue);
if (!hObject->IsObject())
return FALSE;
v8::Local<v8::Value> hPropValue =
hObject.As<v8::Object>()->Get(v8::String::NewFromUtf8(
m_pIsolate, szPropName.c_str(), v8::String::kNormalString,
szPropName.GetLength()));
lpPropValue->ForceSetValue(hPropValue);
return TRUE;
}
FX_BOOL CFXJSE_Value::SetObjectOwnProperty(const CFX_ByteStringC& szPropName,
CFXJSE_Value* lpPropValue) {
CFXJSE_ScopeUtil_IsolateHandleRootContext scope(m_pIsolate);
v8::Local<v8::Value> hObject =
v8::Local<v8::Value>::New(m_pIsolate, m_hValue);
if (!hObject->IsObject()) {
return FALSE;
}
v8::Local<v8::Value> hValue =
v8::Local<v8::Value>::New(m_pIsolate, lpPropValue->m_hValue);
return hObject.As<v8::Object>()->ForceSet(
v8::String::NewFromUtf8(m_pIsolate, szPropName.GetCStr(),
v8::String::kNormalString,
szPropName.GetLength()),
hValue);
}
TEST(SimpleParserTest, GetWord) {
pdfium::StrFuncTestData test_data[] = {
// Empty src string.
STR_IN_OUT_CASE("", ""),
// Content with whitespaces only.
STR_IN_OUT_CASE(" \t \0 \n", ""),
// Content with comments only.
STR_IN_OUT_CASE("%this is a test case\r\n%2nd line", ""),
// Mixed whitespaces and comments.
STR_IN_OUT_CASE(" \t \0%try()%haha\n %another line \aa", ""),
// Name.
STR_IN_OUT_CASE(" /Tester ", "/Tester"),
// String.
STR_IN_OUT_CASE("\t(nice day)!\n ", "(nice day)"),
// String with nested braces.
STR_IN_OUT_CASE("\t(It is a (long) day)!\n ", "(It is a (long) day)"),
// String with escaped chars.
STR_IN_OUT_CASE("\t(It is a \\(long\\) day!)hi\n ",
"(It is a \\(long\\) day!)"),
// Hex string.
STR_IN_OUT_CASE(" \n<4545acdfedertt>abc ", "<4545acdfedertt>"),
STR_IN_OUT_CASE(" \n<4545a<ed>ertt>abc ", "<4545a<ed>"),
// Dictionary.
STR_IN_OUT_CASE("<</oc 234 /color 2 3 R>>", "<<"),
STR_IN_OUT_CASE("\t\t<< /abc>>", "<<"),
// Handling ending delimiters.
STR_IN_OUT_CASE("> little bear", ">"),
STR_IN_OUT_CASE(") another bear", ")"), STR_IN_OUT_CASE(">> end ", ">>"),
// No ending delimiters.
STR_IN_OUT_CASE("(sdfgfgbcv", "(sdfgfgbcv"),
// Regular cases.
STR_IN_OUT_CASE("apple pear", "apple"),
STR_IN_OUT_CASE(" pi=3.1415 ", "pi=3.1415"),
STR_IN_OUT_CASE(" p t x c ", "p"), STR_IN_OUT_CASE(" pt\0xc ", "pt"),
STR_IN_OUT_CASE(" $^&&*\t\0sdff ", "$^&&*"),
STR_IN_OUT_CASE("\n\r+3.5656 -11.0", "+3.5656"),
};
for (size_t i = 0; i < FX_ArraySize(test_data); ++i) {
const pdfium::StrFuncTestData& data = test_data[i];
CPDF_SimpleParser parser(data.input, data.input_size);
CFX_ByteStringC word = parser.GetWord();
EXPECT_EQ(std::string(reinterpret_cast<const char*>(data.expected),
data.expected_size),
std::string(word.c_str(), word.GetLength()))
<< " for case " << i;
}
}
bool CJS_Runtime::GetValueByName(const CFX_ByteStringC& utf8Name,
CFXJSE_Value* pValue) {
const FX_CHAR* name = utf8Name.c_str();
v8::Isolate::Scope isolate_scope(GetIsolate());
v8::HandleScope handle_scope(GetIsolate());
v8::Local<v8::Context> context = NewLocalContext();
v8::Context::Scope context_scope(context);
v8::Local<v8::Value> propvalue =
context->Global()->Get(v8::String::NewFromUtf8(
GetIsolate(), name, v8::String::kNormalString, utf8Name.GetLength()));
if (propvalue.IsEmpty()) {
pValue->SetUndefined();
return false;
}
pValue->ForceSetValue(propvalue);
return true;
}
FX_BOOL CFXJSE_Value::SetObjectOwnProperty(const CFX_ByteStringC& szPropName,
CFXJSE_Value* lpPropValue) {
ASSERT(lpPropValue);
CFXJSE_ScopeUtil_IsolateHandleRootContext scope(m_pIsolate);
v8::Local<v8::Value> hObject =
v8::Local<v8::Value>::New(m_pIsolate, m_hValue);
if (!hObject->IsObject())
return FALSE;
v8::Local<v8::Value> pValue =
v8::Local<v8::Value>::New(m_pIsolate, lpPropValue->m_hValue);
return hObject.As<v8::Object>()
->DefineOwnProperty(
m_pIsolate->GetCurrentContext(),
v8::String::NewFromUtf8(m_pIsolate, szPropName.c_str(),
v8::String::kNormalString,
szPropName.GetLength()),
pValue)
.FromMaybe(false);
}
CFX_ByteString PDF_NameDecode(const CFX_ByteStringC& bstr) {
int size = bstr.GetLength();
const FX_CHAR* pSrc = bstr.GetCStr();
if (FXSYS_memchr(pSrc, '#', size) == NULL) {
return bstr;
}
CFX_ByteString result;
FX_CHAR* pDestStart = result.GetBuffer(size);
FX_CHAR* pDest = pDestStart;
for (int i = 0; i < size; i++) {
if (pSrc[i] == '#' && i < size - 2) {
*pDest++ = _hex2dec(pSrc[i + 1]) * 16 + _hex2dec(pSrc[i + 2]);
i += 2;
} else {
*pDest++ = pSrc[i];
}
}
result.ReleaseBuffer((FX_STRSIZE)(pDest - pDestStart));
return result;
}
FX_FLOAT FX_atof(const CFX_ByteStringC& strc) {
if (strc.IsEmpty())
return 0.0;
int cc = 0;
bool bNegative = false;
int len = strc.GetLength();
if (strc[0] == '+') {
cc++;
} else if (strc[0] == '-') {
bNegative = TRUE;
cc++;
}
while (cc < len) {
if (strc[cc] != '+' && strc[cc] != '-') {
break;
}
cc++;
}
FX_FLOAT value = 0;
while (cc < len) {
if (strc[cc] == '.') {
break;
}
value = value * 10 + FXSYS_toDecimalDigit(strc.CharAt(cc));
cc++;
}
int scale = 0;
if (cc < len && strc[cc] == '.') {
cc++;
while (cc < len) {
value +=
FXSYS_FractionalScale(scale, FXSYS_toDecimalDigit(strc.CharAt(cc)));
scale++;
if (scale == FXSYS_FractionalScaleCount())
break;
cc++;
}
}
return bNegative ? -value : value;
}
bool CJS_Runtime::SetValueByName(const CFX_ByteStringC& utf8Name,
CFXJSE_Value* pValue) {
if (utf8Name.IsEmpty() || !pValue)
return false;
const FX_CHAR* name = utf8Name.c_str();
v8::Isolate* pIsolate = GetIsolate();
v8::Isolate::Scope isolate_scope(pIsolate);
v8::HandleScope handle_scope(pIsolate);
v8::Local<v8::Context> context = NewLocalContext();
v8::Context::Scope context_scope(context);
// v8::Local<v8::Context> tmpCotext =
// v8::Local<v8::Context>::New(GetIsolate(), m_context);
v8::Local<v8::Value> propvalue =
v8::Local<v8::Value>::New(GetIsolate(), pValue->DirectGetValue());
context->Global()->Set(
v8::String::NewFromUtf8(pIsolate, name, v8::String::kNormalString,
utf8Name.GetLength()),
propvalue);
return true;
}
void CFX_ByteTextBuf::operator=(const CFX_ByteStringC& str) {
CopyData(str.GetPtr(), str.GetLength());
}
FX_DOUBLE XFA_ByteStringToDouble(const CFX_ByteStringC& szStringVal) {
CFX_WideString wsValue =
CFX_WideString::FromUTF8(szStringVal.GetCStr(), szStringVal.GetLength());
return XFA_WideStringToDouble(wsValue);
}
CPDF_SimpleParser::CPDF_SimpleParser(const CFX_ByteStringC& str) {
m_pData = str.GetPtr();
m_dwSize = str.GetLength();
m_dwCurPos = 0;
}
