//+------------------------------------------------------------------------
//
// Member: BuildNamedArray
//
// Synopsis: Fills in an array based on names found in the array of the
// given index.
// If we are building a named array on the ELEMENT_COLLECTION
// we check if we have already created a collection of all
// named elements, if not, we build it, if yes, we use this
// collection to access all named elements
//
// Result: S_OK
// E_OUTOFMEMORY
//
// Note: It is now the semantics of this function to always return a
// named array (albeit with a size of 0) instead of returning
// DISPID_MEMBERNOTFOUND. This allows for Tags to return an empty
// collection.
//-------------------------------------------------------------------------
HRESULT CCollectionCache::BuildNamedArray(
long lCollectionIndex,
LPCTSTR Name,
BOOL fTagName,
CCollectionCacheItem* pIntoCacheItem,
long iStartFrom,
BOOL fCaseSensitive,
BOOL fUrn /*=FALSE*/)
{
HRESULT hr = S_OK;
CElement* pElem;
CCollectionCacheItem* pFromCacheItem;
BOOL fAddElement;
Assert(lCollectionIndex>=0 && lCollectionIndex<_aryItems.Size());
Assert(pIntoCacheItem);
pFromCacheItem = _aryItems[lCollectionIndex]._pCacheItem;
pIntoCacheItem->ResetContents();
for(pFromCacheItem->MoveTo(iStartFrom); ;)
{
pElem = pFromCacheItem->GetNext();
if(!pElem)
{
break;
}
if(fUrn)
{
// 'Name' is the Urn we are looking for. Check if this element has the requested Urn
/*fAddElement = pElem->HasPeerWithUrn(Name); wlw note*/
}
else if(CompareName(pElem, Name, fTagName, fCaseSensitive))
{
fAddElement = TRUE;
}
else
{
fAddElement = FALSE;
}
if(fAddElement)
{
hr = pIntoCacheItem->AppendElement(pElem);
if(hr)
{
goto Cleanup;
}
}
}
Cleanup:
RRETURN(hr);
}
bool DumpWrapper<T>::Compare(DumpBuffer& buffer, float threshold, OutputFormat output, size_t length , size_t stride ,size_t start)
{
if(!CompareName(buffer)) return false;
if(!CompareSize(buffer)){
cout << "Buffer " << getName() << " differ in number of elements: " << getSize()/sizeof(T) << " / " << buffer.getSize()/sizeof(T) << endl;
return false;
}
return CompareData((void*)buffer.getData(), threshold, output, length ,stride ,start);
}
bool DumpBuffer::Compare(DumpBuffer& buffer, float threshold, OutputFormat output, size_t length , size_t stride ,size_t start)
{
if(!CompareName(buffer)) return false;
if(!CompareSize(buffer)){
cout << "Buffer " << getName() << " differ in size: " << getSize() << " / " << buffer.getSize() << " Bytes" << endl;
return false;
}
return CompareData((void*)buffer.getData(), threshold, output, length ,stride ,start);
}
// Get the CA which signed the certificate
X *FindCaSignedX(LIST *o, X *x)
{
X *ret;
// Validate arguments
if (o == NULL || x == NULL)
{
return NULL;
}
ret = NULL;
LockList(o);
{
UINT i;
for (i = 0;i < LIST_NUM(o);i++)
{
X *ca = LIST_DATA(o, i);
if (CheckXDateNow(ca))
{
if (CompareName(ca->subject_name, x->issuer_name))
{
K *k = GetKFromX(ca);
if (k != NULL)
{
if (CheckSignature(x, k))
{
ret = CloneX(ca);
}
FreeK(k);
}
}
else if (CompareX(ca, x))
{
ret = CloneX(ca);
}
}
if (ret != NULL)
{
break;
}
}
}
UnlockList(o);
return ret;
}
//+------------------------------------------------------------------------
//
// Member: GetDisp
//
// Synopsis: Get a dispatch ptr on an element from the cache.
// Return the nth element that mathces the name
//
//-------------------------------------------------------------------------
HRESULT CCollectionCache::GetDisp(
long lIndex,
LPCTSTR Name,
long lNthElement,
IDispatch** ppdisp,
BOOL fCaseSensitive)
{
long lSize,l;
HRESULT hr = DISP_E_MEMBERNOTFOUND;
CCollectionCacheItem* pItem;
CElement* pElem;
Assert((lIndex>=0) && (lIndex<_aryItems.Size()));
Assert(ppdisp);
pItem = _aryItems[lIndex]._pCacheItem;
*ppdisp = NULL;
// if lIndexElement is too large, just pretend we
// didn't find it rather then erroring out
if(lNthElement < 0)
{
hr = E_INVALIDARG;
goto Cleanup;
}
lSize = pItem->Length();
if(lNthElement >= lSize)
{
goto Cleanup;
}
for(l=0; l<lSize; ++l)
{
pElem = pItem->GetAt(l);
Assert(pElem);
if(CompareName(pElem, Name, FALSE, fCaseSensitive) && !lNthElement--)
{
RRETURN(pElem->QueryInterface(IID_IDispatch, (void**)ppdisp));
}
}
Cleanup:
RRETURN(hr);
}
// Get the root certificate that signed the specified certificate from the list
X *GetIssuerFromList(LIST *cert_list, X *cert)
{
UINT i;
X *ret = NULL;
// Validate arguments
if (cert_list == NULL || cert == NULL)
{
return NULL;
}
for (i = 0;i < LIST_NUM(cert_list);i++)
{
X *x = LIST_DATA(cert_list, i);
// Name comparison
if (CheckXDateNow(x))
{
if (CompareName(x->subject_name, cert->issuer_name))
{
// Get the public key of the root certificate
K *k = GetKFromX(x);
if (k != NULL)
{
// Check the signature
if (CheckSignature(cert, k))
{
ret = x;
}
FreeK(k);
}
}
}
if (CompareX(x, cert))
{
// Complete identical
ret = x;
}
}
return ret;
}
void Visit(const Waypoint &waypoint) {
if (CompareType(waypoint, type_index) &&
(filter_data.distance_index == 0 || CompareName(waypoint, name)) &&
CompareDirection(waypoint, direction_index, location, heading))
waypoint_list.push_back(WaypointListItem(waypoint));
}
/*
函数功能： 根据文件(夹)名在文件夹中寻找文件(夹)，如果找到则获取文件(夹)参数
参数 ： CurDir 结构体指针，当前文件夹
Target 结构体指针，目标文件(夹)
Target_Name 目标文件(夹)名
Object FILE或DIR，用于区分目标是文件还是文件夹
返回值 ： FILE_EXIST或FILE_NOTEXIST
*/
FS_Status Search_inDir(FS_Object *CurDir,
FS_Object *Target,
u8 *Target_Name,
u8 Object)
{
DIR_tag *DirTag;
LongDir_Ent *LongDirEnt;
u32 CurClus;
u16 CurEntAddr;
u8 CurSec,LngNmCnt,DirEntCnt;
u16 Name_Buffer[53]; //最多容纳4个目录项 共52个Unicode字符
u8 *Name;
Name_Buffer[52]=0;
CurClus=CurDir->FstClus;
LngNmCnt=4;
DirEntCnt=4;
do
{
/***** Read and Scan FS_Object Data Aera by Sector ******/
for(CurSec=0;CurSec<FS.Sec_PerClus;CurSec++)
{
ReadSec(CurClus,CurSec,FS_Buffer);
/***** Scan Every DirEntry , 32 Bytes per DirEntry! *****/
for(CurEntAddr=0;CurEntAddr<BYTES_PERSEC;CurEntAddr+=DIRENT_SIZE)
{
DirTag=(DIR_tag*)((u32)FS_Buffer+CurEntAddr);
if(DirTag->FileName[0]==EMPTY)
{
return FILE_NOTEXIST;
}
if(DirTag->FileName[0]!=DELETED)
{
if(DirTag->Attribute==LONG_NAME)
{
if(LngNmCnt!=0)
{
LngNmCnt--;
LongDirEnt=(LongDir_Ent*)DirTag;
Name=(u8 *)Name_Buffer+LngNmCnt*26;
CopyRam(LongDirEnt->Name1,Name,10);
CopyRam(LongDirEnt->Name2,Name+10,12);
CopyRam(LongDirEnt->Name3,Name+22,4);
}
}
else if(DirTag->Attribute&Object)
{
if(LngNmCnt!=4)
{
LngNmCnt=4;
Convert_LngNm(Name);
}
else
{
Name=(u8 *)Name_Buffer;
CopyRam(DirTag->FileName,Name,11);
Convert_ShortNm(Name);
}
if(CompareName(Name,Target_Name)==SUCCESSED)
{
Target->Name =Target_Name;
Target->Attrib =DirTag->Attribute;
Target->Size =DirTag->FileLength;
Target->FstClus=DirTag->FstClusHI;
Target->FstClus<<=16;
Target->FstClus+=DirTag->FstClusLO;
Target->DirEntryAddr=Get_ClusAddr(CurClus)
+CurSec*BYTES_PERSEC
+CurEntAddr;
Target->CurClus=Target->FstClus;
Target->CurSec=0;
return FILE_EXIST;
}
}
if(LngNmCnt!=4)
{
DirEntCnt--;
}
if(LngNmCnt!=DirEntCnt)
{
LngNmCnt=4;
DirEntCnt=4;
}
}
}
}
CurClus=Read_NextClusNum(CurClus);
}
while(CurClus!=0x0fffffff);
return FILE_NOTEXIST;
}
//+------------------------------------------------------------------------
//
// Member: GetIntoAry
//
// Synopsis: Return the element with a given name
//
// Returns: S_OK, if it found the element. *ppNode is set
// S_FALSE, if multiple elements w/ name were found.
// *ppNode is set to the first element in list.
// Other errors.
//-------------------------------------------------------------------------
HRESULT CCollectionCache::GetIntoAry(
long lCollectionIndex,
LPCTSTR Name,
BOOL fTagName,
CElement** ppElem,
long iStartFrom/*=0*/,
BOOL fCaseSensitive/*=FALSE*/)
{
HRESULT hr = S_OK;
CElement* pElemFirstMatched = NULL;
CElement* pElemLastMatched = NULL;
CElement* pElem;
CCollectionCacheItem* pCacheItem = _aryItems[lCollectionIndex]._pCacheItem;
BOOL fLastOne = FALSE;
Assert(ppElem);
*ppElem = NULL;
if(iStartFrom == -1)
{
iStartFrom = 0;
fLastOne = TRUE;
}
for(pCacheItem->MoveTo(iStartFrom); ;)
{
pElem = pCacheItem->GetNext();
if(!pElem)
{
break;
}
if(CompareName(pElem, Name, fTagName, fCaseSensitive))
{
if(!pElemFirstMatched)
{
pElemFirstMatched = pElem;
}
pElemLastMatched = pElem;
}
}
if(!pElemLastMatched)
{
hr = DISP_E_MEMBERNOTFOUND;
if(pCacheItem->IsRangeSyntaxSupported())
{
CCellRangeParser cellRangeParser(Name);
if(!cellRangeParser.Failed())
{
hr = S_FALSE; // for allowing expando and properties/methods on the collection (TABLE_CELL_COLLECTION)
}
}
goto Cleanup;
}
// A collection can be marked to always return the last matching name,
// rather than the default first matching name.
if(DoGetLastMatchedName(lCollectionIndex))
{
*ppElem = pElemLastMatched;
}
else
{
// The iStartFrom has higher precedence on which element we really
// return first or last in the collection.
*ppElem = fLastOne ? pElemLastMatched : pElemFirstMatched;
}
// return S_FALSE if we have more than one element that matced
hr = (pElemFirstMatched==pElemLastMatched ) ? S_OK : S_FALSE;
Cleanup:
RRETURN1(hr, S_FALSE);
}
