std::unique_ptr<CPDF_Object> CPDF_FontEncoding::Realize(
WeakPtr<ByteStringPool> pPool) {
int predefined = 0;
for (int cs = PDFFONT_ENCODING_WINANSI; cs < PDFFONT_ENCODING_ZAPFDINGBATS;
cs++) {
const uint16_t* pSrc = PDF_UnicodesForPredefinedCharSet(cs);
bool match = true;
for (size_t i = 0; i < FX_ArraySize(m_Unicodes); i++) {
if (m_Unicodes[i] != pSrc[i]) {
match = false;
break;
}
}
if (match) {
predefined = cs;
break;
}
}
if (predefined) {
const char* pName;
if (predefined == PDFFONT_ENCODING_WINANSI)
pName = "WinAnsiEncoding";
else if (predefined == PDFFONT_ENCODING_MACROMAN)
pName = "MacRomanEncoding";
else if (predefined == PDFFONT_ENCODING_MACEXPERT)
pName = "MacExpertEncoding";
else
return nullptr;
return pdfium::MakeUnique<CPDF_Name>(pPool, pName);
}
const uint16_t* pStandard =
PDF_UnicodesForPredefinedCharSet(PDFFONT_ENCODING_WINANSI);
auto pDiff = pdfium::MakeUnique<CPDF_Array>();
for (size_t i = 0; i < FX_ArraySize(m_Unicodes); i++) {
if (pStandard[i] == m_Unicodes[i])
continue;
pDiff->AddNew<CPDF_Number>(static_cast<int>(i));
pDiff->AddNew<CPDF_Name>(PDF_AdobeNameFromUnicode(m_Unicodes[i]));
}
auto pDict = pdfium::MakeUnique<CPDF_Dictionary>(pPool);
pDict->SetNewFor<CPDF_Name>("BaseEncoding", "WinAnsiEncoding");
pDict->SetFor("Differences", std::move(pDiff));
return std::move(pDict);
}
std::unique_ptr<CFDF_Document> CPDF_InterForm::ExportToFDF(
const CFX_WideStringC& pdf_path,
const std::vector<CPDF_FormField*>& fields,
bool bIncludeOrExclude,
bool bSimpleFileSpec) const {
std::unique_ptr<CFDF_Document> pDoc = CFDF_Document::CreateNewDoc();
if (!pDoc)
return nullptr;
CPDF_Dictionary* pMainDict = pDoc->GetRoot()->GetDictFor("FDF");
if (!pdf_path.IsEmpty()) {
if (bSimpleFileSpec) {
CFX_WideString wsFilePath = CPDF_FileSpec::EncodeFileName(pdf_path);
pMainDict->SetNewFor<CPDF_String>(
"F", CFX_ByteString::FromUnicode(wsFilePath), false);
pMainDict->SetNewFor<CPDF_String>("UF", PDF_EncodeText(wsFilePath),
false);
} else {
CPDF_FileSpec filespec(pDoc->GetByteStringPool());
filespec.SetFileName(pdf_path);
pMainDict->SetFor("F", pdfium::WrapUnique(filespec.GetObj()));
}
}
CPDF_Array* pFields = pMainDict->SetNewFor<CPDF_Array>("Fields");
size_t nCount = m_pFieldTree->m_Root.CountFields();
for (size_t i = 0; i < nCount; ++i) {
CPDF_FormField* pField = m_pFieldTree->m_Root.GetFieldAtIndex(i);
if (!pField || pField->GetType() == CPDF_FormField::PushButton)
continue;
uint32_t dwFlags = pField->GetFieldFlags();
if (dwFlags & 0x04)
continue;
if (bIncludeOrExclude == pdfium::ContainsValue(fields, pField)) {
if ((dwFlags & 0x02) != 0 && pField->m_pDict->GetStringFor("V").IsEmpty())
continue;
CFX_WideString fullname = FPDF_GetFullName(pField->GetFieldDict());
auto pFieldDict =
pdfium::MakeUnique<CPDF_Dictionary>(pDoc->GetByteStringPool());
pFieldDict->SetNewFor<CPDF_String>("T", fullname);
if (pField->GetType() == CPDF_FormField::CheckBox ||
pField->GetType() == CPDF_FormField::RadioButton) {
CFX_WideString csExport = pField->GetCheckValue(false);
CFX_ByteString csBExport = PDF_EncodeText(csExport);
CPDF_Object* pOpt = FPDF_GetFieldAttr(pField->m_pDict, "Opt");
if (pOpt)
pFieldDict->SetNewFor<CPDF_String>("V", csBExport, false);
else
pFieldDict->SetNewFor<CPDF_Name>("V", csBExport);
} else {
CPDF_Object* pV = FPDF_GetFieldAttr(pField->m_pDict, "V");
if (pV)
pFieldDict->SetFor("V", pV->CloneDirectObject());
}
pFields->Add(std::move(pFieldDict));
}
}
return pDoc;
}
std::unique_ptr<CPDF_Object> CPDF_StreamParser::ReadNextObject(
bool bAllowNestedArray,
bool bInArray,
uint32_t dwRecursionLevel) {
bool bIsNumber;
// Must get the next word before returning to avoid infinite loops.
GetNextWord(bIsNumber);
if (!m_WordSize || dwRecursionLevel > kMaxNestedParsingLevel)
return nullptr;
if (bIsNumber) {
m_WordBuffer[m_WordSize] = 0;
return pdfium::MakeUnique<CPDF_Number>(
ByteStringView(m_WordBuffer, m_WordSize));
}
int first_char = m_WordBuffer[0];
if (first_char == '/') {
ByteString name =
PDF_NameDecode(ByteStringView(m_WordBuffer + 1, m_WordSize - 1));
return pdfium::MakeUnique<CPDF_Name>(m_pPool, name);
}
if (first_char == '(') {
ByteString str = ReadString();
return pdfium::MakeUnique<CPDF_String>(m_pPool, str, false);
}
if (first_char == '<') {
if (m_WordSize == 1)
return pdfium::MakeUnique<CPDF_String>(m_pPool, ReadHexString(), true);
auto pDict = pdfium::MakeUnique<CPDF_Dictionary>(m_pPool);
while (1) {
GetNextWord(bIsNumber);
if (m_WordSize == 2 && m_WordBuffer[0] == '>')
break;
if (!m_WordSize || m_WordBuffer[0] != '/')
return nullptr;
ByteString key =
PDF_NameDecode(ByteStringView(m_WordBuffer + 1, m_WordSize - 1));
std::unique_ptr<CPDF_Object> pObj =
ReadNextObject(true, bInArray, dwRecursionLevel + 1);
if (!pObj)
return nullptr;
if (!key.IsEmpty())
pDict->SetFor(key, std::move(pObj));
}
return std::move(pDict);
}
if (first_char == '[') {
if ((!bAllowNestedArray && bInArray))
return nullptr;
auto pArray = pdfium::MakeUnique<CPDF_Array>();
while (1) {
std::unique_ptr<CPDF_Object> pObj =
ReadNextObject(bAllowNestedArray, true, dwRecursionLevel + 1);
if (pObj) {
pArray->Add(std::move(pObj));
continue;
}
if (!m_WordSize || m_WordBuffer[0] == ']')
break;
}
return std::move(pArray);
}
if (m_WordSize == 5 && !memcmp(m_WordBuffer, "false", 5))
return pdfium::MakeUnique<CPDF_Boolean>(false);
if (m_WordSize == 4) {
if (memcmp(m_WordBuffer, "true", 4) == 0)
return pdfium::MakeUnique<CPDF_Boolean>(true);
if (memcmp(m_WordBuffer, "null", 4) == 0)
return pdfium::MakeUnique<CPDF_Null>();
}
return nullptr;
}
