bool ParseSubCharsCommand(int numForms, const CCommandSubCharsSet *forms,
const UString &commandString, CIntVector &indices)
{
indices.Clear();
int numUsedChars = 0;
for(int i = 0; i < numForms; i++)
{
const CCommandSubCharsSet &set = forms[i];
int currentIndex = -1;
int len = MyStringLen(set.Chars);
for(int j = 0; j < len; j++)
{
wchar_t c = set.Chars[j];
int newIndex = commandString.Find(c);
if (newIndex >= 0)
{
if (currentIndex >= 0)
return false;
if (commandString.Find(c, newIndex + 1) >= 0)
return false;
currentIndex = j;
numUsedChars++;
}
}
if(currentIndex == -1 && !set.EmptyAllowed)
return false;
indices.Add(currentIndex);
}
return (numUsedChars == commandString.Length());
}
void SortFileNames(const UStringVector &strings, CIntVector &indices)
{
indices.Clear();
int numItems = strings.Size();
indices.Reserve(numItems);
for(int i = 0; i < numItems; i++)
indices.Add(i);
indices.Sort(CompareStrings, (void *)&strings);
}
bool CCodecs::FindFormatForArchiveType(const UString &arcType, CIntVector &formatIndices) const
{
formatIndices.Clear();
for (int pos = 0; pos < arcType.Length();)
{
int pos2 = arcType.Find('.', pos);
if (pos2 < 0)
pos2 = arcType.Length();
const UString name = arcType.Mid(pos, pos2 - pos);
int index = FindFormatForArchiveType(name);
if (index < 0 && name != L"*")
{
formatIndices.Clear();
return false;
}
formatIndices.Add(index);
pos = pos2 + 1;
}
return true;
}
HRESULT CompressFiles(const CObjectVector<PluginPanelItem> &pluginPanelItems)
{
if (pluginPanelItems.Size() == 0)
return E_FAIL;
UStringVector fileNames;
int i;
for (i = 0; i < pluginPanelItems.Size(); i++)
{
const PluginPanelItem &panelItem = pluginPanelItems[i];
if (strcmp(panelItem.FindData.cFileName, "..") == 0 &&
NFind::NAttributes::IsDir(panelItem.FindData.dwFileAttributes))
return E_FAIL;
if (strcmp(panelItem.FindData.cFileName, ".") == 0 &&
NFind::NAttributes::IsDir(panelItem.FindData.dwFileAttributes))
return E_FAIL;
FString fullPath;
FString fileNameUnicode = us2fs(MultiByteToUnicodeString(panelItem.FindData.cFileName, CP_OEMCP));
if (!MyGetFullPathName(fileNameUnicode, fullPath))
return E_FAIL;
fileNames.Add(fs2us(fullPath));
}
NCompression::CInfo compressionInfo;
compressionInfo.Load();
int archiverIndex = 0;
CCodecs *codecs = new CCodecs;
CMyComPtr<ICompressCodecsInfo> compressCodecsInfo = codecs;
if (codecs->Load() != S_OK)
throw "Can't load 7-Zip codecs";
{
for (int i = 0; i < codecs->Formats.Size(); i++)
{
const CArcInfoEx &arcInfo = codecs->Formats[i];
if (arcInfo.UpdateEnabled)
{
if (archiverIndex == -1)
archiverIndex = i;
if (arcInfo.Name.CompareNoCase(compressionInfo.ArcType) == 0)
archiverIndex = i;
}
}
}
UString resultPath;
{
CParsedPath parsedPath;
parsedPath.ParsePath(fileNames.Front());
if (parsedPath.PathParts.Size() == 0)
return E_FAIL;
if (fileNames.Size() == 1 || parsedPath.PathParts.Size() == 1)
{
// CSysString pureName, dot, extension;
resultPath = parsedPath.PathParts.Back();
}
else
{
parsedPath.PathParts.DeleteBack();
resultPath = parsedPath.PathParts.Back();
}
}
UString archiveNameSrc = resultPath;
UString archiveName = archiveNameSrc;
const CArcInfoEx &arcInfo = codecs->Formats[archiverIndex];
int prevFormat = archiverIndex;
if (!arcInfo.KeepName)
{
int dotPos = archiveName.ReverseFind('.');
int slashPos = MyMax(archiveName.ReverseFind('\\'), archiveName.ReverseFind('/'));
if (dotPos > slashPos)
archiveName = archiveName.Left(dotPos);
}
archiveName += L'.';
archiveName += arcInfo.GetMainExt();
const CActionSet *actionSet = &kAddActionSet;
for (;;)
{
AString archiveNameA = UnicodeStringToMultiByte(archiveName, CP_OEMCP);
const int kYSize = 16;
const int kXMid = 38;
const int kArchiveNameIndex = 2;
const int kMethodRadioIndex = kArchiveNameIndex + 2;
const int kModeRadioIndex = kMethodRadioIndex + 7;
const CArcInfoEx &arcInfo = codecs->Formats[archiverIndex];
char updateAddToArchiveString[512];
const AString s = UnicodeStringToMultiByte(arcInfo.Name, CP_OEMCP);
sprintf(updateAddToArchiveString,
g_StartupInfo.GetMsgString(NMessageID::kUpdateAddToArchive), (const char *)s);
int methodIndex = 0;
int i;
for (i = sizeof(g_MethodMap) / sizeof(g_MethodMap[0]) - 1; i >= 0; i--)
if (compressionInfo.Level >= g_MethodMap[i])
{
methodIndex = i;
break;
}
struct CInitDialogItem initItems[]=
{
{ DI_DOUBLEBOX, 3, 1, 72, kYSize - 2, false, false, 0, false, NMessageID::kUpdateTitle, NULL, NULL },
{ DI_TEXT, 5, 2, 0, 0, false, false, 0, false, -1, updateAddToArchiveString, NULL },
{ DI_EDIT, 5, 3, 70, 3, true, false, DIF_HISTORY, false, -1, archiveNameA, kArchiveHistoryKeyName},
// { DI_EDIT, 5, 3, 70, 3, true, false, 0, false, -1, archiveName, NULL},
{ DI_SINGLEBOX, 4, 4, kXMid - 2, 4 + 7, false, false, 0, false, NMessageID::kUpdateMethod, NULL, NULL },
{ DI_RADIOBUTTON, 6, 5, 0, 0, false, methodIndex == 0,
DIF_GROUP, false, NMessageID::kUpdateMethodStore, NULL, NULL },
{ DI_RADIOBUTTON, 6, 6, 0, 0, false, methodIndex == 1,
0, false, NMessageID::kUpdateMethodFastest, NULL, NULL },
{ DI_RADIOBUTTON, 6, 7, 0, 0, false, methodIndex == 2,
0, false, NMessageID::kUpdateMethodFast, NULL, NULL },
{ DI_RADIOBUTTON, 6, 8, 0, 0, false, methodIndex == 3,
0, false, NMessageID::kUpdateMethodNormal, NULL, NULL },
{ DI_RADIOBUTTON, 6, 9, 0, 0, false, methodIndex == 4,
false, 0, NMessageID::kUpdateMethodMaximum, NULL, NULL },
{ DI_RADIOBUTTON, 6, 10, 0, 0, false, methodIndex == 5,
false, 0, NMessageID::kUpdateMethodUltra, NULL, NULL },
{ DI_SINGLEBOX, kXMid, 4, 70, 4 + 5, false, false, 0, false, NMessageID::kUpdateMode, NULL, NULL },
{ DI_RADIOBUTTON, kXMid + 2, 5, 0, 0, false,
actionSet == &kAddActionSet,
DIF_GROUP, false, NMessageID::kUpdateModeAdd, NULL, NULL },
{ DI_RADIOBUTTON, kXMid + 2, 6, 0, 0, false,
actionSet == &kUpdateActionSet,
0, false, NMessageID::kUpdateModeUpdate, NULL, NULL },
{ DI_RADIOBUTTON, kXMid + 2, 7, 0, 0, false,
actionSet == &kFreshActionSet,
0, false, NMessageID::kUpdateModeFreshen, NULL, NULL },
{ DI_RADIOBUTTON, kXMid + 2, 8, 0, 0, false,
actionSet == &kSynchronizeActionSet,
0, false, NMessageID::kUpdateModeSynchronize, NULL, NULL },
{ DI_TEXT, 3, kYSize - 4, 0, 0, false, false, DIF_BOXCOLOR|DIF_SEPARATOR, false, -1, "", NULL },
{ DI_BUTTON, 0, kYSize - 3, 0, 0, false, false, DIF_CENTERGROUP, true, NMessageID::kUpdateAdd, NULL, NULL },
{ DI_BUTTON, 0, kYSize - 3, 0, 0, false, false, DIF_CENTERGROUP, false, NMessageID::kUpdateSelectArchiver, NULL, NULL },
{ DI_BUTTON, 0, kYSize - 3, 0, 0, false, false, DIF_CENTERGROUP, false, NMessageID::kCancel, NULL, NULL }
};
const int kNumDialogItems = sizeof(initItems) / sizeof(initItems[0]);
const int kOkButtonIndex = kNumDialogItems - 3;
const int kSelectarchiverButtonIndex = kNumDialogItems - 2;
FarDialogItem dialogItems[kNumDialogItems];
g_StartupInfo.InitDialogItems(initItems, dialogItems, kNumDialogItems);
int askCode = g_StartupInfo.ShowDialog(76, kYSize,
kHelpTopic, dialogItems, kNumDialogItems);
archiveNameA = dialogItems[kArchiveNameIndex].Data;
archiveNameA.Trim();
archiveName = MultiByteToUnicodeString(archiveNameA, CP_OEMCP);
compressionInfo.Level = g_MethodMap[0];
for (i = 0; i < sizeof(g_MethodMap)/ sizeof(g_MethodMap[0]); i++)
if (dialogItems[kMethodRadioIndex + i].Selected)
compressionInfo.Level = g_MethodMap[i];
if (dialogItems[kModeRadioIndex].Selected)
actionSet = &kAddActionSet;
else if (dialogItems[kModeRadioIndex + 1].Selected)
actionSet = &kUpdateActionSet;
else if (dialogItems[kModeRadioIndex + 2].Selected)
actionSet = &kFreshActionSet;
else if (dialogItems[kModeRadioIndex + 3].Selected)
actionSet = &kSynchronizeActionSet;
else
throw 51751;
if (askCode == kSelectarchiverButtonIndex)
{
CIntVector indices;
CSysStringVector archiverNames;
for (int i = 0; i < codecs->Formats.Size(); i++)
{
const CArcInfoEx &arc = codecs->Formats[i];
if (arc.UpdateEnabled)
{
indices.Add(i);
archiverNames.Add(GetSystemString(arc.Name, CP_OEMCP));
}
}
int index = g_StartupInfo.Menu(FMENU_AUTOHIGHLIGHT,
g_StartupInfo.GetMsgString(NMessageID::kUpdateSelectArchiverMenuTitle),
NULL, archiverNames, archiverIndex);
if (index >= 0)
{
const CArcInfoEx &prevArchiverInfo = codecs->Formats[prevFormat];
if (prevArchiverInfo.KeepName)
{
const UString &prevExtension = prevArchiverInfo.GetMainExt();
const int prevExtensionLen = prevExtension.Length();
if (archiveName.Right(prevExtensionLen).CompareNoCase(prevExtension) == 0)
{
int pos = archiveName.Length() - prevExtensionLen;
if (pos > 1)
{
int dotPos = archiveName.ReverseFind('.');
if (dotPos == pos - 1)
archiveName = archiveName.Left(dotPos);
}
}
}
archiverIndex = indices[index];
const CArcInfoEx &arcInfo = codecs->Formats[archiverIndex];
prevFormat = archiverIndex;
if (arcInfo.KeepName)
archiveName = archiveNameSrc;
else
{
int dotPos = archiveName.ReverseFind('.');
int slashPos = MyMax(archiveName.ReverseFind('\\'), archiveName.ReverseFind('/'));
if (dotPos > slashPos)
archiveName = archiveName.Left(dotPos);
}
archiveName += L'.';
archiveName += arcInfo.GetMainExt();
}
continue;
}
if (askCode != kOkButtonIndex)
return E_ABORT;
break;
}
const CArcInfoEx &archiverInfoFinal = codecs->Formats[archiverIndex];
compressionInfo.ArcType = archiverInfoFinal.Name;
compressionInfo.Save();
NWorkDir::CInfo workDirInfo;
workDirInfo.Load();
FString fullArchiveName;
if (!MyGetFullPathName(us2fs(archiveName), fullArchiveName))
return E_FAIL;
CWorkDirTempFile tempFile;
RINOK(tempFile.CreateTempFile(fullArchiveName));
CScreenRestorer screenRestorer;
CProgressBox progressBox;
CProgressBox *progressBoxPointer = NULL;
screenRestorer.Save();
progressBoxPointer = &progressBox;
progressBox.Init(
// g_StartupInfo.GetMsgString(NMessageID::kWaitTitle),
g_StartupInfo.GetMsgString(NMessageID::kUpdating), 48);
NFind::CFileInfo fileInfo;
CMyComPtr<IOutFolderArchive> outArchive;
CMyComPtr<IInFolderArchive> archiveHandler;
if (fileInfo.Find(fullArchiveName))
{
if (fileInfo.IsDir())
throw "There is Directory with such name";
CAgent *agentSpec = new CAgent;
archiveHandler = agentSpec;
// CLSID realClassID;
CMyComBSTR archiveType;
RINOK(agentSpec->Open(NULL,
GetUnicodeString(fullArchiveName, CP_OEMCP), UString(),
// &realClassID,
&archiveType,
NULL));
if (archiverInfoFinal.Name.CompareNoCase((const wchar_t *)archiveType) != 0)
throw "Type of existing archive differs from specified type";
HRESULT result = archiveHandler.QueryInterface(
IID_IOutFolderArchive, &outArchive);
if (result != S_OK)
{
g_StartupInfo.ShowMessage(NMessageID::kUpdateNotSupportedForThisArchive);
return E_FAIL;
}
}
else
{
// HRESULT result = outArchive.CoCreateInstance(classID);
CAgent *agentSpec = new CAgent;
outArchive = agentSpec;
/*
HRESULT result = outArchive.CoCreateInstance(CLSID_CAgentArchiveHandler);
if (result != S_OK)
{
g_StartupInfo.ShowMessage(NMessageID::kUpdateNotSupportedForThisArchive);
return E_FAIL;
}
*/
}
CRecordVector<const wchar_t *> fileNamePointers;
fileNamePointers.Reserve(fileNames.Size());
for (i = 0; i < fileNames.Size(); i++)
fileNamePointers.Add(fileNames[i]);
outArchive->SetFolder(NULL);
outArchive->SetFiles(L"", &fileNamePointers.Front(), fileNamePointers.Size());
BYTE actionSetByte[NUpdateArchive::NPairState::kNumValues];
for (i = 0; i < NUpdateArchive::NPairState::kNumValues; i++)
actionSetByte[i] = (BYTE)actionSet->StateActions[i];
CUpdateCallback100Imp *updateCallbackSpec = new CUpdateCallback100Imp;
CMyComPtr<IFolderArchiveUpdateCallback> updateCallback(updateCallbackSpec );
updateCallbackSpec->Init(/* archiveHandler, */ progressBoxPointer);
RINOK(SetOutProperties(outArchive, compressionInfo.Level));
HRESULT result = outArchive->DoOperation(
codecs, archiverIndex,
tempFile.OutStream, actionSetByte,
NULL, updateCallback);
updateCallback.Release();
outArchive.Release();
if (result != S_OK)
{
ShowErrorMessage(result);
return result;
}
if (archiveHandler)
{
archiveHandler->Close();
}
if (!tempFile.MoveToOriginal(archiveHandler != NULL))
{
ShowLastErrorMessage();
return E_FAIL;
}
return S_OK;
}
HRESULT OpenArchive(
CCodecs *codecs,
IInStream *inStream,
const UString &fileName,
IInArchive **archiveResult,
int &formatIndex,
UString &defaultItemName,
IArchiveOpenCallback *openArchiveCallback)
{
*archiveResult = NULL;
UString extension;
{
int dotPos = fileName.ReverseFind(L'.');
if (dotPos >= 0)
extension = fileName.Mid(dotPos + 1);
}
CIntVector orderIndices;
int i;
int numFinded = 0;
for (i = 0; i < codecs->Formats.Size(); i++)
if (codecs->Formats[i].FindExtension(extension) >= 0)
orderIndices.Insert(numFinded++, i);
else
orderIndices.Add(i);
#ifndef _SFX
if (numFinded != 1)
{
CIntVector orderIndices2;
CByteBuffer byteBuffer;
const UInt32 kBufferSize = (200 << 10);
byteBuffer.SetCapacity(kBufferSize);
Byte *buffer = byteBuffer;
RINOK(inStream->Seek(0, STREAM_SEEK_SET, NULL));
UInt32 processedSize;
RINOK(ReadStream(inStream, buffer, kBufferSize, &processedSize));
for (UInt32 pos = 0; pos < processedSize; pos++)
{
for (int i = 0; i < orderIndices.Size(); i++)
{
int index = orderIndices[i];
const CArcInfoEx &ai = codecs->Formats[index];
const CByteBuffer &sig = ai.StartSignature;
if (sig.GetCapacity() == 0)
continue;
if (pos + sig.GetCapacity() > processedSize)
continue;
if (TestSignature(buffer + pos, sig, sig.GetCapacity()))
{
orderIndices2.Add(index);
orderIndices.Delete(i--);
}
}
}
orderIndices2 += orderIndices;
orderIndices = orderIndices2;
/* begin: extracted from 4.65 */
if (orderIndices.Size() >= 2)
{
int isoIndex = codecs->FindFormatForArchiveType(L"iso");
int udfIndex = codecs->FindFormatForArchiveType(L"udf");
int iIso = -1;
int iUdf = -1;
for (int i = 0; i < orderIndices.Size(); i++)
{
if (orderIndices[i] == isoIndex) iIso = i;
if (orderIndices[i] == udfIndex) iUdf = i;
}
if (iUdf == iIso + 1)
{
orderIndices[iUdf] = isoIndex;
orderIndices[iIso] = udfIndex;
}
}
/* end: extracted from 4.65 */
}
else if (extension == L"000" || extension == L"001")
{
CByteBuffer byteBuffer;
const UInt32 kBufferSize = (1 << 10);
byteBuffer.SetCapacity(kBufferSize);
Byte *buffer = byteBuffer;
RINOK(inStream->Seek(0, STREAM_SEEK_SET, NULL));
UInt32 processedSize;
RINOK(ReadStream(inStream, buffer, kBufferSize, &processedSize));
if (processedSize >= 16)
{
Byte kRarHeader[] = {0x52 , 0x61, 0x72, 0x21, 0x1a, 0x07, 0x00};
if (TestSignature(buffer, kRarHeader, 7) && buffer[9] == 0x73 && (buffer[10] && 1) != 0)
{
for (int i = 0; i < orderIndices.Size(); i++)
{
int index = orderIndices[i];
const CArcInfoEx &ai = codecs->Formats[index];
if (ai.Name.CompareNoCase(L"rar") != 0)
continue;
orderIndices.Delete(i--);
orderIndices.Insert(0, index);
break;
}
}
}
}
#endif
HRESULT badResult = S_OK;
for(i = 0; i < orderIndices.Size(); i++)
{
inStream->Seek(0, STREAM_SEEK_SET, NULL);
CMyComPtr<IInArchive> archive;
formatIndex = orderIndices[i];
RINOK(codecs->CreateInArchive(formatIndex, archive));
if (!archive)
continue;
#ifdef EXTERNAL_CODECS
{
CMyComPtr<ISetCompressCodecsInfo> setCompressCodecsInfo;
archive.QueryInterface(IID_ISetCompressCodecsInfo, (void **)&setCompressCodecsInfo);
if (setCompressCodecsInfo)
{
RINOK(setCompressCodecsInfo->SetCompressCodecsInfo(codecs));
}
}
#endif
HRESULT result = archive->Open(inStream, &kMaxCheckStartPosition, openArchiveCallback);
if (result == S_FALSE)
continue;
if(result != S_OK)
{
badResult = result;
if(result == E_ABORT)
break;
continue;
}
*archiveResult = archive.Detach();
const CArcInfoEx &format = codecs->Formats[formatIndex];
if (format.Exts.Size() == 0)
{
defaultItemName = GetDefaultName2(fileName, L"", L"");
}
else
{
int subExtIndex = format.FindExtension(extension);
if (subExtIndex < 0)
subExtIndex = 0;
defaultItemName = GetDefaultName2(fileName,
format.Exts[subExtIndex].Ext,
format.Exts[subExtIndex].AddExt);
}
return S_OK;
}
if (badResult != S_OK)
return badResult;
return S_FALSE;
}
HRESULT CArc::OpenStream(
CCodecs *codecs,
int formatIndex,
IInStream *stream,
ISequentialInStream *seqStream,
IArchiveOpenCallback *callback)
{
Archive.Release();
ErrorMessage.Empty();
const UString fileName = ExtractFileNameFromPath(Path);
UString extension;
{
int dotPos = fileName.ReverseFind(L'.');
if (dotPos >= 0)
extension = fileName.Mid(dotPos + 1);
}
CIntVector orderIndices;
if (formatIndex >= 0)
orderIndices.Add(formatIndex);
else
{
int i;
int numFinded = 0;
for (i = 0; i < codecs->Formats.Size(); i++)
if (codecs->Formats[i].FindExtension(extension) >= 0)
orderIndices.Insert(numFinded++, i);
else
orderIndices.Add(i);
if (!stream)
{
if (numFinded != 1)
return E_NOTIMPL;
orderIndices.DeleteFrom(1);
}
#ifndef _SFX
if (orderIndices.Size() >= 2 && (numFinded == 0 || extension.CompareNoCase(L"exe") == 0))
{
CIntVector orderIndices2;
CByteBuffer byteBuffer;
const size_t kBufferSize = (1 << 21);
byteBuffer.SetCapacity(kBufferSize);
RINOK(stream->Seek(0, STREAM_SEEK_SET, NULL));
size_t processedSize = kBufferSize;
RINOK(ReadStream(stream, byteBuffer, &processedSize));
if (processedSize == 0)
return S_FALSE;
const Byte *buf = byteBuffer;
CByteBuffer hashBuffer;
const UInt32 kNumVals = 1 << (kNumHashBytes * 8);
hashBuffer.SetCapacity(kNumVals);
Byte *hash = hashBuffer;
memset(hash, 0xFF, kNumVals);
Byte prevs[256];
if (orderIndices.Size() >= 256)
return S_FALSE;
int i;
for (i = 0; i < orderIndices.Size(); i++)
{
const CArcInfoEx &ai = codecs->Formats[orderIndices[i]];
const CByteBuffer &sig = ai.StartSignature;
if (sig.GetCapacity() < kNumHashBytes)
continue;
UInt32 v = HASH_VAL(sig, 0);
prevs[i] = hash[v];
hash[v] = (Byte)i;
}
processedSize -= (kNumHashBytes - 1);
for (UInt32 pos = 0; pos < processedSize; pos++)
{
for (; pos < processedSize && hash[HASH_VAL(buf, pos)] == 0xFF; pos++);
if (pos == processedSize)
break;
UInt32 v = HASH_VAL(buf, pos);
Byte *ptr = &hash[v];
int i = *ptr;
do
{
int index = orderIndices[i];
const CArcInfoEx &ai = codecs->Formats[index];
const CByteBuffer &sig = ai.StartSignature;
if (sig.GetCapacity() != 0 && pos + sig.GetCapacity() <= processedSize + (kNumHashBytes - 1) &&
TestSignature(buf + pos, sig, sig.GetCapacity()))
{
orderIndices2.Add(index);
orderIndices[i] = 0xFF;
*ptr = prevs[i];
}
else
ptr = &prevs[i];
i = *ptr;
}
while (i != 0xFF);
}
for (i = 0; i < orderIndices.Size(); i++)
{
int val = orderIndices[i];
if (val != 0xFF)
orderIndices2.Add(val);
}
orderIndices = orderIndices2;
}
else if (extension == L"000" || extension == L"001")
{
CByteBuffer byteBuffer;
const size_t kBufferSize = (1 << 10);
byteBuffer.SetCapacity(kBufferSize);
Byte *buffer = byteBuffer;
RINOK(stream->Seek(0, STREAM_SEEK_SET, NULL));
size_t processedSize = kBufferSize;
RINOK(ReadStream(stream, buffer, &processedSize));
if (processedSize >= 16)
{
Byte kRarHeader[] = {0x52 , 0x61, 0x72, 0x21, 0x1a, 0x07, 0x00};
if (TestSignature(buffer, kRarHeader, 7) && buffer[9] == 0x73 && (buffer[10] & 1) != 0)
{
for (int i = 0; i < orderIndices.Size(); i++)
{
int index = orderIndices[i];
const CArcInfoEx &ai = codecs->Formats[index];
if (ai.Name.CompareNoCase(L"rar") != 0)
continue;
orderIndices.Delete(i--);
orderIndices.Insert(0, index);
break;
}
}
}
}
if (orderIndices.Size() >= 2)
{
int isoIndex = codecs->FindFormatForArchiveType(L"iso");
int udfIndex = codecs->FindFormatForArchiveType(L"udf");
int iIso = -1;
int iUdf = -1;
for (int i = 0; i < orderIndices.Size(); i++)
{
if (orderIndices[i] == isoIndex) iIso = i;
if (orderIndices[i] == udfIndex) iUdf = i;
}
if (iUdf > iIso && iIso >= 0)
{
orderIndices[iUdf] = isoIndex;
orderIndices[iIso] = udfIndex;
}
}
#endif
}
for (int i = 0; i < orderIndices.Size(); i++)
{
if (stream)
{
RINOK(stream->Seek(0, STREAM_SEEK_SET, NULL));
}
CMyComPtr<IInArchive> archive;
FormatIndex = orderIndices[i];
RINOK(codecs->CreateInArchive(FormatIndex, archive));
if (!archive)
continue;
#ifdef EXTERNAL_CODECS
{
CMyComPtr<ISetCompressCodecsInfo> setCompressCodecsInfo;
archive.QueryInterface(IID_ISetCompressCodecsInfo, (void **)&setCompressCodecsInfo);
if (setCompressCodecsInfo)
{
RINOK(setCompressCodecsInfo->SetCompressCodecsInfo(codecs));
}
}
#endif
// OutputDebugStringW(codecs->Formats[FormatIndex].Name);
HRESULT result;
if (stream)
result = archive->Open(stream, &kMaxCheckStartPosition, callback);
else
{
CMyComPtr<IArchiveOpenSeq> openSeq;
archive.QueryInterface(IID_IArchiveOpenSeq, (void **)&openSeq);
if (!openSeq)
return E_NOTIMPL;
result = openSeq->OpenSeq(seqStream);
}
if (result == S_FALSE)
continue;
RINOK(result);
{
NCOM::CPropVariant prop;
archive->GetArchiveProperty(kpidError, &prop);
if (prop.vt != VT_EMPTY)
ErrorMessage = (prop.vt == VT_BSTR) ? prop.bstrVal : L"Unknown error";
}
Archive = archive;
const CArcInfoEx &format = codecs->Formats[FormatIndex];
if (format.Exts.Size() == 0)
DefaultName = GetDefaultName2(fileName, L"", L"");
else
{
int subExtIndex = format.FindExtension(extension);
if (subExtIndex < 0)
subExtIndex = 0;
const CArcExtInfo &extInfo = format.Exts[subExtIndex];
DefaultName = GetDefaultName2(fileName, extInfo.Ext, extInfo.AddExt);
}
return S_OK;
}
return S_FALSE;
}