GMPErr
GMPStorageChild::Write(GMPRecordImpl* aRecord,
const uint8_t* aData,
uint32_t aDataSize)
{
if (aDataSize > GMP_MAX_RECORD_SIZE) {
return GMPQuotaExceededErr;
}
MonitorAutoLock lock(mMonitor);
if (mShutdown) {
NS_WARNING("GMPStorage used after it's been shutdown!");
return GMPClosedErr;
}
if (!HasRecord(aRecord->Name())) {
// Record not opened.
return GMPClosedErr;
}
CALL_ON_GMP_THREAD(SendWrite, aRecord->Name(), ToArray(aData, aDataSize));
return GMPNoErr;
}
int CPDF_FormField::InsertOption(CFX_WideString csOptLabel,
int index,
FX_BOOL bNotify) {
if (csOptLabel.IsEmpty())
return -1;
if (bNotify && !NotifyListOrComboBoxBeforeChange(csOptLabel))
return -1;
CFX_ByteString csStr =
PDF_EncodeText(csOptLabel.c_str(), csOptLabel.GetLength());
CPDF_Object* pValue = FPDF_GetFieldAttr(m_pDict, "Opt");
CPDF_Array* pOpt = ToArray(pValue);
if (!pOpt) {
pOpt = new CPDF_Array;
m_pDict->SetAt("Opt", pOpt);
}
int iCount = (int)pOpt->GetCount();
if (index < 0 || index >= iCount) {
pOpt->AddString(csStr);
index = iCount;
} else {
CPDF_String* pString = new CPDF_String(csStr, FALSE);
pOpt->InsertAt(index, pString);
}
if (bNotify)
NotifyListOrComboBoxAfterChange();
return index;
}
// Stop all listener in Cedar
void StopAllListener(CEDAR *c)
{
LISTENER **array;
UINT i, num;
// Validate arguments
if (c == NULL)
{
return;
}
LockList(c->ListenerList);
{
array = ToArray(c->ListenerList);
num = LIST_NUM(c->ListenerList);
DeleteAll(c->ListenerList);
}
UnlockList(c->ListenerList);
for (i = 0;i < num;i++)
{
StopListener(array[i]);
ReleaseListener(array[i]);
}
Free(array);
}
int CPDF_FormField::InsertOption(CFX_WideString csOptLabel,
int index,
bool bNotify) {
if (csOptLabel.IsEmpty())
return -1;
if (bNotify && !NotifyListOrComboBoxBeforeChange(csOptLabel))
return -1;
CFX_ByteString csStr =
PDF_EncodeText(csOptLabel.c_str(), csOptLabel.GetLength());
CPDF_Array* pOpt = ToArray(FPDF_GetFieldAttr(m_pDict, "Opt"));
if (!pOpt)
pOpt = m_pDict->SetNewFor<CPDF_Array>("Opt");
int iCount = pdfium::base::checked_cast<int>(pOpt->GetCount());
if (index >= iCount) {
pOpt->AddNew<CPDF_String>(csStr, false);
index = iCount;
} else {
pOpt->InsertNewAt<CPDF_String>(index, csStr, false);
}
if (bNotify)
NotifyListOrComboBoxAfterChange();
return index;
}
// Stop all hubs in Cedar
void StopAllHub(CEDAR *c)
{
HUB **hubs;
UINT i, num;
// Validate arguments
if (c == NULL)
{
return;
}
LockHubList(c);
{
hubs = ToArray(c->HubList);
num = LIST_NUM(c->HubList);
DeleteAll(c->HubList);
}
UnlockHubList(c);
for (i = 0;i < num;i++)
{
StopHub(hubs[i]);
ReleaseHub(hubs[i]);
}
Free(hubs);
}
// Release the table
void FreeTable()
{
UINT i, num;
TABLE **tables;
if (TableList == NULL)
{
return;
}
TrackingDisable();
num = LIST_NUM(TableList);
tables = ToArray(TableList);
for (i = 0;i < num;i++)
{
TABLE *t = tables[i];
Free(t->name);
Free(t->str);
Free(t->unistr);
Free(t);
}
ReleaseList(TableList);
TableList = NULL;
Free(tables);
Zero(old_table_name, sizeof(old_table_name));
TrackingEnable();
}
void CPDFSDK_ActionHandler::DoAction_GoTo(CPDFSDK_Document* pDocument,
const CPDF_Action& action) {
ASSERT(action);
CPDF_Document* pPDFDocument = pDocument->GetPDFDocument();
ASSERT(pPDFDocument);
CPDF_Dest MyDest = action.GetDest(pPDFDocument);
int nPageIndex = MyDest.GetPageIndex(pPDFDocument);
int nFitType = MyDest.GetZoomMode();
const CPDF_Array* pMyArray = ToArray(MyDest.GetObject());
float* pPosAry = nullptr;
int sizeOfAry = 0;
if (pMyArray) {
pPosAry = new float[pMyArray->GetCount()];
int j = 0;
for (int i = 2; i < (int)pMyArray->GetCount(); i++) {
pPosAry[j++] = pMyArray->GetFloat(i);
}
sizeOfAry = j;
}
CPDFDoc_Environment* pApp = pDocument->GetEnv();
pApp->FFI_DoGoToAction(nPageIndex, nFitType, pPosAry, sizeOfAry);
delete[] pPosAry;
}
// Stop all links
void StopAllLink(HUB *h)
{
LINK **link_list;
UINT num_link;
UINT i;
// Validate arguments
if (h == NULL)
{
return;
}
LockList(h->LinkList);
{
link_list = ToArray(h->LinkList);
num_link = LIST_NUM(h->LinkList);
for (i = 0;i < num_link;i++)
{
AddRef(link_list[i]->ref);
}
}
UnlockList(h->LinkList);
for (i = 0;i < num_link;i++)
{
StopLink(link_list[i]);
ReleaseLink(link_list[i]);
}
Free(link_list);
}
// Release all links
void ReleaseAllLink(HUB *h)
{
LINK **kk;
UINT num, i;
// Validate arguments
if (h == NULL)
{
return;
}
LockList(h->LinkList);
{
num = LIST_NUM(h->LinkList);
kk = ToArray(h->LinkList);
DeleteAll(h->LinkList);
}
UnlockList(h->LinkList);
for (i = 0;i < num;i++)
{
LINK *k = kk[i];
ReleaseLink(k);
}
Free(kk);
}
// Stop all connections
void StopAllConnection(CEDAR *c)
{
UINT num;
UINT i;
CONNECTION **connections;
// Validate arguments
if (c == NULL)
{
return;
}
LockList(c->ConnectionList);
{
connections = ToArray(c->ConnectionList);
num = LIST_NUM(c->ConnectionList);
DeleteAll(c->ConnectionList);
}
UnlockList(c->ConnectionList);
for (i = 0;i < num;i++)
{
StopConnection(connections[i], false);
ReleaseConnection(connections[i]);
}
Free(connections);
}
FX_BOOL CPDF_FormField::CheckControl(int iControlIndex,
bool bChecked,
bool bNotify) {
ASSERT(GetType() == CheckBox || GetType() == RadioButton);
CPDF_FormControl* pControl = GetControl(iControlIndex);
if (!pControl) {
return FALSE;
}
if (!bChecked && pControl->IsChecked() == bChecked) {
return FALSE;
}
CFX_WideString csWExport = pControl->GetExportValue();
CFX_ByteString csBExport = PDF_EncodeText(csWExport);
int iCount = CountControls();
bool bUnison = PDF_FormField_IsUnison(this);
for (int i = 0; i < iCount; i++) {
CPDF_FormControl* pCtrl = GetControl(i);
if (bUnison) {
CFX_WideString csEValue = pCtrl->GetExportValue();
if (csEValue == csWExport) {
if (pCtrl->GetOnStateName() == pControl->GetOnStateName()) {
pCtrl->CheckControl(bChecked);
} else if (bChecked) {
pCtrl->CheckControl(FALSE);
}
} else if (bChecked) {
pCtrl->CheckControl(FALSE);
}
} else {
if (i == iControlIndex) {
pCtrl->CheckControl(bChecked);
} else if (bChecked) {
pCtrl->CheckControl(FALSE);
}
}
}
CPDF_Object* pOpt = FPDF_GetFieldAttr(m_pDict, "Opt");
if (!ToArray(pOpt)) {
if (bChecked) {
m_pDict->SetAtName("V", csBExport);
} else {
CFX_ByteString csV;
CPDF_Object* pV = FPDF_GetFieldAttr(m_pDict, "V");
if (pV) {
csV = pV->GetString();
}
if (csV == csBExport) {
m_pDict->SetAtName("V", "Off");
}
}
} else if (bChecked) {
CFX_ByteString csIndex;
csIndex.Format("%d", iControlIndex);
m_pDict->SetAtName("V", csIndex);
}
if (bNotify && m_pForm->m_pFormNotify)
m_pForm->m_pFormNotify->AfterCheckedStatusChange(this);
return TRUE;
}
// Listener stop
void ElStopListener(EL *e)
{
UINT i;
THREAD **threads;
SOCK **socks;
UINT num_threads, num_socks;
// Validate arguments
if (e == NULL)
{
return;
}
StopAllListener(e->Cedar);
LockList(e->AdminThreadList);
{
threads = ToArray(e->AdminThreadList);
num_threads = LIST_NUM(e->AdminThreadList);
DeleteAll(e->AdminThreadList);
socks = ToArray(e->AdminSockList);
num_socks = LIST_NUM(e->AdminSockList);
DeleteAll(e->AdminSockList);
}
UnlockList(e->AdminThreadList);
for (i = 0;i < num_socks;i++)
{
Disconnect(socks[i]);
ReleaseSock(socks[i]);
}
for (i = 0;i < num_threads;i++)
{
WaitThread(threads[i], INFINITE);
ReleaseThread(threads[i]);
}
Free(threads);
Free(socks);
ReleaseList(e->AdminSockList);
ReleaseList(e->AdminThreadList);
ReleaseListener(e->Listener);
}
Cmd getCmd(char *cmd,char *del ){
Cmd c;
Array *arr=split(cmd,del);
c.argc =ToArray(arr,&c.argv);
c.parent=NULL;
c.prev=NULL;
c.next=NULL;
return c;
}
int CPDF_FormField::GetSelectedOptionIndex(int index) const {
CPDF_Array* pArray = ToArray(FPDF_GetFieldAttr(m_pDict, "I"));
if (!pArray)
return -1;
int iCount = pArray->GetCount();
if (iCount < 0 || index >= iCount)
return -1;
return pArray->GetIntegerAt(index);
}
FX_BOOL CPDF_FormField::IsOptionSelected(int iOptIndex) const {
CPDF_Array* pArray = ToArray(FPDF_GetFieldAttr(m_pDict, "I"));
if (!pArray)
return FALSE;
for (CPDF_Object* pObj : *pArray) {
if (pObj->GetInteger() == iOptIndex)
return TRUE;
}
return FALSE;
}
bool CPDF_FormField::IsOptionSelected(int iOptIndex) const {
CPDF_Array* pArray = ToArray(FPDF_GetFieldAttr(m_pDict, "I"));
if (!pArray)
return false;
for (const auto& pObj : *pArray) {
if (pObj->GetInteger() == iOptIndex)
return true;
}
return false;
}
FX_ARGB CPDF_StructElementImpl::GetColor(const CFX_ByteStringC& owner,
const CFX_ByteStringC& name,
FX_ARGB default_value,
FX_BOOL bInheritable,
int subindex) {
CPDF_Array* pArray = ToArray(GetAttr(owner, name, bInheritable, subindex));
if (!pArray)
return default_value;
return 0xff000000 | ((int)(pArray->GetNumberAt(0) * 255) << 16) |
((int)(pArray->GetNumberAt(1) * 255) << 8) |
(int)(pArray->GetNumberAt(2) * 255);
}
bool CPDF_DataAvail::CheckPage(DownloadHints* pHints) {
uint32_t iPageObjs = m_PageObjList.GetSize();
CFX_ArrayTemplate<uint32_t> UnavailObjList;
for (uint32_t i = 0; i < iPageObjs; ++i) {
uint32_t dwPageObjNum = m_PageObjList.GetAt(i);
bool bExist = false;
std::unique_ptr<CPDF_Object> pObj =
GetObject(dwPageObjNum, pHints, &bExist);
if (!pObj) {
if (bExist)
UnavailObjList.Add(dwPageObjNum);
continue;
}
CPDF_Array* pArray = ToArray(pObj.get());
if (pArray) {
for (const auto& pArrayObj : *pArray) {
if (CPDF_Reference* pRef = ToReference(pArrayObj.get()))
UnavailObjList.Add(pRef->GetRefObjNum());
}
}
if (!pObj->IsDictionary())
continue;
CFX_ByteString type = pObj->GetDict()->GetStringFor("Type");
if (type == "Pages") {
m_PagesArray.push_back(std::move(pObj));
continue;
}
}
m_PageObjList.RemoveAll();
if (UnavailObjList.GetSize()) {
m_PageObjList.Append(UnavailObjList);
return false;
}
uint32_t iPages = m_PagesArray.size();
for (uint32_t i = 0; i < iPages; i++) {
std::unique_ptr<CPDF_Object> pPages = std::move(m_PagesArray[i]);
if (pPages && !GetPageKids(m_pCurrentParser, pPages.get())) {
m_PagesArray.clear();
m_docStatus = PDF_DATAAVAIL_ERROR;
return false;
}
}
m_PagesArray.clear();
if (!m_PageObjList.GetSize())
m_docStatus = PDF_DATAAVAIL_DONE;
return true;
}
CPDF_Action CPDF_Action::GetSubAction(FX_DWORD iIndex) const {
if (!m_pDict || !m_pDict->KeyExist("Next")) {
return CPDF_Action();
}
CPDF_Object* pNext = m_pDict->GetElementValue("Next");
if (CPDF_Dictionary* pDict = ToDictionary(pNext)) {
if (iIndex == 0)
return CPDF_Action(pDict);
} else if (CPDF_Array* pArray = ToArray(pNext)) {
return CPDF_Action(pArray->GetDict(iIndex));
}
return CPDF_Action();
}
CPDF_Object* CPDF_StructElementImpl::GetAttr(const CFX_ByteStringC& owner,
const CFX_ByteStringC& name,
FX_BOOL bInheritable,
int subindex) {
CPDF_Object* pAttr = GetAttr(owner, name, bInheritable);
CPDF_Array* pArray = ToArray(pAttr);
if (!pArray || subindex == -1)
return pAttr;
if (subindex >= static_cast<int>(pArray->GetCount()))
return pAttr;
return pArray->GetDirectObjectAt(subindex);
}
CPDF_Action CPDF_Action::GetSubAction(size_t iIndex) const {
if (!m_pDict || !m_pDict->KeyExist("Next"))
return CPDF_Action();
CPDF_Object* pNext = m_pDict->GetDirectObjectFor("Next");
if (CPDF_Dictionary* pDict = ToDictionary(pNext)) {
if (iIndex == 0)
return CPDF_Action(pDict);
} else if (CPDF_Array* pArray = ToArray(pNext)) {
return CPDF_Action(pArray->GetDictAt(iIndex));
}
return CPDF_Action();
}
int main(int argc,char *argv[],char *envp[])
{
int a=0;
int b=1;
printf("a=%d b=%d\n",a,b);
printf("push &a=%p &b=%p\n",&a,&b);
push(stack,&a);
push(stack,&b);
int *arr;
int arr_size=ToArray(stack,&arr);
printf("arrsize=%d\n",arr_size);
printf("stack[0]=%p [1]=%p\n",*STACK.address,*(STACK.address+1));
printf("pop=%d\n",*pop(stack,int*));
printf("pop=%d\n",*pop(stack,int*));
printf("a=%d b=%d\n",a,b);
int i;
for(i=0;i<arr_size;i++){
int v=GetItem(arr,i,int);
printf("arr[%d]=%d \n",i,v);
}
free(arr);
char aaa[10]="aaaa";
char bbb[10]="bbaa";
char ccc[10]="cccc";
push(stack,aaa);
push(stack,bbb);
push(stack,ccc);
char **ddd;
arr_size=ToArray(stack,&ddd);
for(i=0;i<arr_size;i++){
printf("ddd[%d]=%s \n",i,ddd[i]);
}
return 0;
}
FX_DWORD CPDF_Dest::GetPageObjNum() {
CPDF_Array* pArray = ToArray(m_pObj);
if (!pArray)
return 0;
CPDF_Object* pPage = pArray->GetElementValue(0);
if (!pPage)
return 0;
if (pPage->IsNumber())
return pPage->GetInteger();
if (pPage->IsDictionary())
return pPage->GetObjNum();
return 0;
}
int CPDF_Dest::GetPageIndex(CPDF_Document* pDoc) {
CPDF_Array* pArray = ToArray(m_pObj);
if (!pArray)
return 0;
CPDF_Object* pPage = pArray->GetElementValue(0);
if (!pPage)
return 0;
if (pPage->IsNumber())
return pPage->GetInteger();
if (!pPage->IsDictionary())
return 0;
return pDoc->GetPageIndex(pPage->GetObjNum());
}
uint32_t CPDF_Dest::GetPageObjNum() {
CPDF_Array* pArray = ToArray(m_pObj);
if (!pArray)
return 0;
CPDF_Object* pPage = pArray->GetDirectObjectAt(0);
if (!pPage)
return 0;
if (pPage->IsNumber())
return pPage->GetInteger();
if (pPage->IsDictionary())
return pPage->GetObjNum();
return 0;
}
CFX_WideString CPDF_FormField::GetOptionText(int index, int sub_index) const {
CPDF_Array* pArray = ToArray(FPDF_GetFieldAttr(m_pDict, "Opt"));
if (!pArray)
return CFX_WideString();
CPDF_Object* pOption = pArray->GetDirectObjectAt(index);
if (!pOption)
return CFX_WideString();
if (CPDF_Array* pOptionArray = pOption->AsArray())
pOption = pOptionArray->GetDirectObjectAt(sub_index);
CPDF_String* pString = ToString(pOption);
return pString ? pString->GetUnicodeText() : CFX_WideString();
}
CFX_ByteString CPDF_FormControl::GetCheckedAPState() {
ASSERT(GetType() == CPDF_FormField::CheckBox ||
GetType() == CPDF_FormField::RadioButton);
CFX_ByteString csOn = GetOnStateName();
if (GetType() == CPDF_FormField::RadioButton ||
GetType() == CPDF_FormField::CheckBox) {
if (ToArray(FPDF_GetFieldAttr(m_pField->m_pDict, "Opt"))) {
int iIndex = m_pField->GetControlIndex(this);
csOn.Format("%d", iIndex);
}
}
if (csOn.IsEmpty())
csOn = "Yes";
return csOn;
}
CFX_WideString CPDF_FormControl::GetExportValue() const {
ASSERT(GetType() == CPDF_FormField::CheckBox ||
GetType() == CPDF_FormField::RadioButton);
CFX_ByteString csOn = GetOnStateName();
if (GetType() == CPDF_FormField::RadioButton ||
GetType() == CPDF_FormField::CheckBox) {
if (CPDF_Array* pArray =
ToArray(FPDF_GetFieldAttr(m_pField->m_pDict, "Opt"))) {
int iIndex = m_pField->GetControlIndex(this);
csOn = pArray->GetStringAt(iIndex);
}
}
if (csOn.IsEmpty())
csOn = "Yes";
return PDF_DecodeText(csOn);
}
int CPDF_Dest::GetZoomMode() {
CPDF_Array* pArray = ToArray(m_pObj);
if (!pArray)
return 0;
CFX_ByteString mode;
CPDF_Object* pObj = pArray->GetElementValue(1);
mode = pObj ? pObj->GetString() : CFX_ByteString();
int i = 0;
while (g_sZoomModes[i][0] != '\0') {
if (mode == g_sZoomModes[i]) {
return i + 1;
}
i++;
}
return 0;
}
int CPDF_Dest::GetZoomMode() {
CPDF_Array* pArray = ToArray(m_pObj);
if (!pArray)
return 0;
CPDF_Object* pObj = pArray->GetDirectObjectAt(1);
if (!pObj)
return 0;
CFX_ByteString mode = pObj->GetString();
for (int i = 0; g_sZoomModes[i]; ++i) {
if (mode == g_sZoomModes[i])
return i + 1;
}
return 0;
}