CPLErr WEBPDataset::IRasterIO( GDALRWFlag eRWFlag, int nXOff, int nYOff, int nXSize, int nYSize, void *pData, int nBufXSize, int nBufYSize, GDALDataType eBufType, int nBandCount, int *panBandMap, int nPixelSpace, int nLineSpace, int nBandSpace ) { if((eRWFlag == GF_Read) && (nBandCount == nBands) && (nXOff == 0) && (nXOff == 0) && (nXSize == nBufXSize) && (nXSize == nRasterXSize) && (nYSize == nBufYSize) && (nYSize == nRasterYSize) && (eBufType == GDT_Byte) && (nPixelSpace == nBands) && (nLineSpace == (nPixelSpace*nXSize)) && (nBandSpace == 1) && (pData != NULL) && (panBandMap != NULL) && (panBandMap[0] == 1) && (panBandMap[1] == 2) && (panBandMap[2] == 3) && (nBands == 3 || panBandMap[3] == 4)) { Uncompress(); memcpy(pData, pabyUncompressed, nBands * nXSize * nYSize); return CE_None; } return GDALPamDataset::IRasterIO(eRWFlag, nXOff, nYOff, nXSize, nYSize, pData, nBufXSize, nBufYSize, eBufType, nBandCount, panBandMap, nPixelSpace, nLineSpace, nBandSpace); }
Bool CSharu::GetFileData(SFileInfo *pFileInfo, const MY_FILE_ENTRY_BASE *pBaseEntry) { PByte pbBuffer; UInt32 BufferSize; SMyPackIndex *pIndex; pIndex = (SMyPackIndex *)pBaseEntry; BufferSize = max(pIndex->CompressedSize.LowPart, pIndex->Size.LowPart); if (BufferSize == 0) { pbBuffer = NULL; goto EMPTY_FILE; } pbBuffer = (PByte)Alloc(BufferSize); if (pbBuffer == NULL) return False; if (file.Seek(file.FILE_SEEK_BEGIN, pIndex->Offset.LowPart, (PLong)&pIndex->Offset.HighPart) == False) return False; if (file.Read(pbBuffer, pIndex->CompressedSize.LowPart) == False) return False; if (pIndex->CompressedSize.LowPart < 0x1000000) { if (Hash(pbBuffer, pIndex->CompressedSize.LowPart) != pIndex->Hash) { Free(pbBuffer); return False; } } if (TEST_BITS(pIndex->Flags, UNPACKER_ENTRY_FLAG_ENCRYPTED)) Decrypt(pbBuffer, pIndex->CompressedSize.LowPart, m_Key); if (TEST_BITS(pIndex->Flags, UNPACKER_ENTRY_FLAG_COMPRESSED)) { PByte pbTemp = (PByte)Alloc(pIndex->CompressedSize.LowPart); if (pbTemp == NULL) { Free(pbBuffer); return False; } memcpy(pbTemp, pbBuffer, pIndex->CompressedSize.LowPart); Uncompress(pbTemp, pIndex->CompressedSize.LowPart, pbBuffer); Free(pbTemp); } EMPTY_FILE: pFileInfo->FileType = UNPACKER_FILE_TYPE_BIN; pFileInfo->lpExtraData = NULL; pFileInfo->BinData.pbBuffer = pbBuffer; pFileInfo->BinData.BufferSize = pIndex->Size.LowPart; return True; }
inline size_t Read(void* ptr, size_t len) { size_t ret = 0; do { ret = Uncompressed_.Read(ptr, len); } while (!ret && Uncompress()); return ret; }
CPLErr WEBPDataset::IRasterIO( GDALRWFlag eRWFlag, int nXOff, int nYOff, int nXSize, int nYSize, void *pData, int nBufXSize, int nBufYSize, GDALDataType eBufType, int nBandCount, int *panBandMap, GSpacing nPixelSpace, GSpacing nLineSpace, GSpacing nBandSpace, GDALRasterIOExtraArg* psExtraArg ) { if((eRWFlag == GF_Read) && (nBandCount == nBands) && (nXOff == 0) && (nYOff == 0) && // TODO: X -> Y on this was correct? (nXSize == nBufXSize) && (nXSize == nRasterXSize) && (nYSize == nBufYSize) && (nYSize == nRasterYSize) && (eBufType == GDT_Byte) && (pData != NULL) && (panBandMap[0] == 1) && (panBandMap[1] == 2) && (panBandMap[2] == 3) && (nBands == 3 || panBandMap[3] == 4)) { if( Uncompress() != CE_None ) return CE_Failure; if( nPixelSpace == nBands && nLineSpace == (nPixelSpace*nXSize) && nBandSpace == 1 ) { memcpy(pData, pabyUncompressed, nBands * nXSize * nYSize); } else { for(int y = 0; y < nYSize; ++y) { GByte* pabyScanline = pabyUncompressed + y * nBands * nXSize; for(int x = 0; x < nXSize; ++x) { for(int iBand=0;iBand<nBands;iBand++) reinterpret_cast<GByte *>( pData )[(y * nLineSpace) + (x * nPixelSpace) + iBand * nBandSpace] = pabyScanline[x * nBands + iBand]; } } } return CE_None; } return GDALPamDataset::IRasterIO(eRWFlag, nXOff, nYOff, nXSize, nYSize, pData, nBufXSize, nBufYSize, eBufType, nBandCount, panBandMap, nPixelSpace, nLineSpace, nBandSpace, psExtraArg); }
bool FImageWrapperBase::GetRaw( const ERGBFormat::Type InFormat, int32 InBitDepth, const TArray<uint8>*& OutRawData ) { LastError.Empty(); Uncompress(InFormat, InBitDepth); if (LastError.IsEmpty()) { OutRawData = &RawData; } return LastError.IsEmpty(); }
int main(int argc,char *argv[]){ int choice; Welcome(); scanf("%d",&choice); switch(choice) { case 0:Compress(); break; case 1:Uncompress(); break; case 2: exit(0); break; default :printf(" йДхКспнС"); } }
unsigned int MkZipCompressor::Uncompress (const unsigned char* srcArray, unsigned int srcSize, MkByteArray& destBuffer, unsigned int destBufRate) { if ((srcArray == 0) || (srcSize == 0)) return 0; // compressedSize를 destBufRate배하거나 unsigned int의 최대 수를 버퍼사이즈로 잡음 bool onMaxBufferSize = (srcSize >= (0xffffffff / destBufRate)); unsigned int bufSize = (onMaxBufferSize) ? 0xffffffff : (srcSize * destBufRate); uLongf destSize = static_cast<uLongf>(bufSize); unsigned char* destArray = new unsigned char[destSize]; int rlt = uncompress(destArray, &destSize, srcArray, srcSize); unsigned int newSize; if (rlt == Z_OK) { newSize = static_cast<unsigned int>(destSize); destBuffer.Clear(); destBuffer.Fill(newSize); destBuffer.Overwrite(0, MkByteArrayDescriptor(destArray, newSize)); delete [] destArray; } else if (rlt == Z_BUF_ERROR) { // 버퍼 용량 부족 delete [] destArray; if (onMaxBufferSize) { newSize = 0; // 4G 버퍼로도 안됨. 실패 } else { newSize = Uncompress(srcArray, srcSize, destBuffer, destBufRate * 2); // 두배로 버퍼를 키워 재시도 } } else { // Z_MEM_ERROR, Z_DATA_ERROR newSize = 0; delete [] destArray; } return newSize; }
static Boolean SearchRecord ( MemHandle handle, /* handle of record to search */ Char* pattern, /* pattern to search for */ Boolean onlyOne /* are we looking only for a single match? */ ) { Boolean multiple; Boolean done; MemHandle uncompressHandle; Header* record; UInt16 uniqueID; Char* text; Int16 size; Boolean match; multiple = Prefs()->searchFlags & SEARCH_MULTIPLE; if ( multiple ) { ParseSearchString( pattern ); if ( ! numSearchTerms ) return false; } done = false; record = MemHandleLock( handle ); uniqueID = record->uid; lastSearchedRecordId = uniqueID; uncompressHandle = NULL; if ( record->type == DATATYPE_PHTML_COMPRESSED ) { ErrTry { uncompressHandle = Uncompress( record ); text = MemHandleLock( uncompressHandle ); size = MemPtrSize( text ); ResetLastUncompressedPHTML(); } ErrCatch( UNUSED_PARAM( err ) ) { MemHandleUnlock( handle ); return false; } ErrEndCatch }
// // Loop for ever, and wait for new jobs. // The general principle used is repeating (starting with locked mutex): // wait(condition) // pop a job from the job queue // unlock(mutex) // Do the job. // lock(mutex) // put result in outgoing queue. // // This means that the actual job is done with no locked semaphores. Because of that, it is important that no data is // manipulated that can also be accessed from the main process. void ChunkProcess::Task(void) { std::unique_lock<std::mutex> lock(fMutex); // This will lock the mutex // The condition variable will not have any effect if not waiting for it. And that may happen // as the mutex is unlocked in the loop now and then. bool waitForCondition = true; // Stay in a loop forever, waiting for new messages to play while(1) { if (waitForCondition) fCondLock.wait(lock); waitForCondition = true; // Wait for condition next iteration if (fTerminate) { // Used to request that the child thread terminates. fMutex.unlock(); break; } if (!fComputeObjectsInput.empty()) { // Take out the chunk from the fifo chunk *ch = getNextChunk(fComputeObjectsInput); if (ch == 0) continue; if (ch->fScheduledForLoading) { ch->fScheduledForComputation = false; continue; // Ignore a recomputation, as the chunk will be loaded by new data anyway, later followed by a new computation } fMutex.unlock(); // Unlock the mutex while doing some heavy work // printf("ChunkProcess phase 1, size %d, chunk %d,%d,%d\n", fComputeObjectsInput.size()+1, ch->cc.x, ch->cc.y, ch->cc.z); auto co = ChunkObject::Make(ch, false, 0, 0, 0); co->FindSpecialObjects(ch); // This will find light sources, and should be done before FindTriangles(). fMutex.lock(); ASSERT(ch->fScheduledForComputation); co->fChunk = ch; fComputedObjectsOutput.insert(std::move(co)); // Add it to the list of recomputed chunks waitForCondition = false; // Try another iteration } if (!fNewChunksInput.empty()) { auto nc = getNextChunkBlock(fNewChunksInput); chunk *pc = nc->fChunk; // It may be that this chunk was also scheduled for recomputation. If so, the Uncompress() below that calls SetDirty() will not // schedule a new recomputation again. ASSERT(pc->fScheduledForLoading); fMutex.unlock(); // Unlock the mutex while doing some work // printf("ChunkProcess phase 2, size %d\n", fNewChunksInput.size()+1); nc->Uncompress(); // Save chunk in cache ChunkCache::cachunk chunkdata; chunkdata.cc = pc->cc; chunkdata.flag = nc->flag; chunkdata.fCheckSum = nc->fChecksum; chunkdata.fOwner = nc->fOwner; chunkdata.compressSize = nc->compressSize; chunkdata.compressedChunk = nc->fCompressedChunk.get(); ChunkCache::fgChunkCache.SaveChunkInCache(&chunkdata); // TODO: Use a ChunkProcess::ChunkBlocks as argument instead fMutex.lock(); ASSERT(nc->fChunk == pc); fNewChunksOutput.insert(nc); // Add it to the list of loaded chunks waitForCondition = false; // Try another iteration } } }
bool Compression::Uncompress(const String &zipFile, const String &targetDirectory) { return Uncompress(zipFile, targetDirectory, "*"); }
// управление ВМ, key - номер клавиши пульта // 0 - OK int VCR::IrcKeyTrn (int fdout, int key) { int stat, buf, delay; word *sbuf, *nbuf, *pbuf; #define IKTBNUM 5 stat = Uncompress(key); if (stat) return (stat); stat = 1; //write (fdout, Sbuffer, modesize * 2); sbuf = nbuf = pbuf = (word*) malloc (312*12 * 2 * IKTBNUM); bzero (sbuf, 312*12 * 2 * IKTBNUM); buf = 0; delay = 0; while (stat) { if (VCR_1950 ()) stat = 0; bcopy (Sbuffer, nbuf, modesize * 2); // copy first part nbuf += modesize; // move pointer to begin second part // если следующий буфер будет больше или конец if (nbuf+modesize > sbuf+312*12*IKTBNUM || stat == 0) { // новый размер будет больше размера буфера int ctmp = 0, wtmp, cbuf; // расчитаем количество заполненых буферов cbuf = (nbuf - sbuf) / (312 * 12); // размер для вывода wtmp = 312*12*2 * cbuf; #ifdef DEBUG_IRCOUT printf ("cbuf: %d, wtmp: %d\n", cbuf, wtmp); #endif // выводим for (pbuf = sbuf; wtmp && (ctmp != -1);) { do { /// ctmp = write (fdout, pbuf, 312*12*2); ctmp = SendIRCCommand ((byte*)pbuf, 312*12*2); } while (ctmp != 312*12*2 && ctmp != -1); pbuf += ctmp/2; wtmp -= ctmp; } // оставшуюся информацию wtmp = nbuf - sbuf - cbuf*312*12; wtmp *= 2; #ifdef DEBUG_IRCOUT printf ("wtmp: %d\n", wtmp); #endif // если конец выводим if (stat == 0 && wtmp) { do { /// ctmp = write (fdout, pbuf, wtmp); ctmp = SendIRCCommand ((byte*)pbuf, wtmp); } while (ctmp != wtmp && ctmp != -1); nbuf = sbuf; } else { // перенесем в начало bcopy (pbuf, sbuf, wtmp); // и запомним nbuf = sbuf + wtmp/2; } } // end if } // end while free (sbuf); // подождем delay = svcr->a[0x8be] / 50; if (!delay) delay++; printf ("IrcKeyTrn: Sleep %d/%d sec\n", svcr->a[0x8be], delay); sleep (delay); return (0); };
// управление ВМ, key - номер клавиши пульта // 0 - OK int VCR::IrcKeyTrn (int fdout, int key) { int stat, delay = 0, crc32 = 0; word *sbuf, *nbuf, *pbuf; #define IKTBNUM 11 if ((stat = Uncompress (key)) != 0) return (stat); stat = 1; //write (fdout, Sbuffer, modesize * 2); sbuf = nbuf = pbuf = (word*) malloc (SSIZE_IRC_FRAME * IKTBNUM); bzero (sbuf, SSIZE_IRC_FRAME * IKTBNUM); while (stat) { if (VCR_1950 ()) stat = 0; bcopy (Sbuffer, nbuf, modesize * 2); // copy first part //imemcpy (nbuf, Sbuffer, modesize * 2); // copy first part nbuf += modesize; // move pointer to begin second part // если следующий буфер будет больше или конец if (nbuf+modesize > sbuf + (SSIZE_IRC_FRAME/2) * IKTBNUM || stat == 0) { // новый размер будет больше размера буфера // int bsend = 0; // расчитаем количество заполненых буферов int fullfr = (nbuf - sbuf) / (SSIZE_IRC_FRAME/2); // размер для вывода int szfullfr = SSIZE_IRC_FRAME * fullfr; #ifdef DEBUG_IRCOUT printf ("fullfr: %d, szfullfr: %d\n", fullfr, szfullfr); #endif // выводим /* for (pbuf = sbuf; szfullfr && (bsend != -1);) { do { /// bsend = write (fdout, pbuf, 312*12*2); bsend = SendIRCCommand ((byte*)pbuf, SSIZE_IRC_FRAME); } while (bsend != SSIZE_IRC_FRAME && bsend != -1); pbuf += bsend/2; szfullfr -= bsend; } */ pbuf = sbuf; SendIRCCommand ((byte*)pbuf, szfullfr); for (int i = 0; i < szfullfr; i++) crc32 += *((byte*)((int)pbuf + i)); pbuf += szfullfr/2; // оставшуюся информацию int last = nbuf - sbuf - (fullfr * (SSIZE_IRC_FRAME/2)); last *= 2; #ifdef DEBUG_IRCOUT printf ("last: %d\n", last); #endif // если конец выводим if (stat == 0 && last) { /* do { /// bsend = write (fdout, pbuf, last); bsend = SendIRCCommand ((byte*)pbuf, last); } while (bsend != last && bsend != -1); */ SendIRCCommand ((byte*)pbuf, last); for (int i = 0; i < last; i++) crc32 += *((byte*)((int)pbuf + i)); #ifdef DEBUG_IRCOUT printf ("send last\n"); #endif nbuf = sbuf; } else { // перенесем в начало bcopy (pbuf, sbuf, last); //imemcpy (sbuf, pbuf, last); // и запомним nbuf = sbuf + last/2; } } // end if } // end while free (sbuf); // подождем delay = svcr->a[0x8be] / 50; if (!delay) delay++; printf ("IrcKeyTrn: Sleep %d/%d sec\n", svcr->a[0x8be], delay); printf ("crc32: %X\n", crc32); sleep (delay); return 0; };
FILE * FindManualFile(ManpageGlobals * man_globals, int section_num, int entry_num) { FILE * file; char path[BUFSIZ], page[BUFSIZ], section[BUFSIZ], *temp; char filename[BUFSIZ]; char * entry = manual[section_num].entries[entry_num]; int len_cat = strlen(CAT); #if defined(ISC) || defined(__SCO__) || defined(__UNIXWARE__) int i; #endif temp = CreateManpageName(entry, 0, 0); snprintf(man_globals->manpage_title, sizeof(man_globals->manpage_title), "The current manual page is: %s.", temp); XtFree(temp); ParseEntry(entry, path, section, page); /* * Look for uncompressed files first. */ #if defined(__OpenBSD__) || defined(__NetBSD__) /* look in machine subdir first */ snprintf(filename, sizeof(filename), "%s/%s%s/%s/%s", path, CAT, section + len_cat, MACHINE, page); if ( (file = fopen(filename,"r")) != NULL) return(file); #endif snprintf(filename, sizeof(filename), "%s/%s%s/%s", path, CAT, section + len_cat, page); if ( (file = fopen(filename,"r")) != NULL) return(file); /* * Then for compressed files in an uncompressed directory. */ #if !defined(ISC) && !defined(__UNIXWARE__) #if defined(__OpenBSD__) || defined(__NetBSD__) /* look in machine subdir first */ snprintf(filename, sizeof(filename), "%s/%s%s/%s/%s.%s", path, CAT, section + len_cat, MACHINE, page, COMPRESSION_EXTENSION); if ( (file = Uncompress(man_globals, filename)) != NULL) return(file); #endif snprintf(filename, sizeof(filename), "%s/%s%s/%s.%s", path, CAT, section + len_cat, page, COMPRESSION_EXTENSION); if ( (file = Uncompress(man_globals, filename)) != NULL) return(file); #ifdef GZIP_EXTENSION else { #if defined(__OpenBSD__) || defined(__NetBSD__) /* look in machine subdir first */ snprintf(filename, sizeof(filename), "%s/%s%s/%s/%s.%s", path, CAT, section + len_cat, MACHINE, page, GZIP_EXTENSION); if ( (file = Uncompress(man_globals, filename)) != NULL) return(file); #endif snprintf(filename, sizeof(filename), "%s/%s%s/%s.%s", path, CAT, section + len_cat, page, GZIP_EXTENSION); if ( (file = Uncompress(man_globals, filename)) != NULL) return(file); } #endif #ifdef BZIP2_EXTENSION #if defined(__OpenBSD__) || defined(__NetBSD__) /* look in machine subdir first */ snprintf(filename, sizeof(filename), "%s/%s%s/%s/%s.%s", path, CAT, section + len_cat, MACHINE, page, BZIP2_EXTENSION); if ( (file = Uncompress(man_globals, filename)) != NULL) return(file); #endif { sprintf(filename, "%s/%s%s/%s.%s", path, CAT, section + len_cat, page, BZIP2_EXTENSION); if ( (file = Uncompress(man_globals, filename)) != NULL) return(file); } #endif #ifdef LZMA_EXTENSION { sprintf(filename, "%s/%s%s/%s.%s", path, CAT, section + len_cat, page, LZMA_EXTENSION); if ( (file = Uncompress(man_globals, filename)) != NULL) return(file); } #endif #else for(i = 0; i < strlen(COMPRESSION_EXTENSIONS); i++) { snprintf(filename, sizeof(filename), "%s/%s%s/%s.%c", path, CAT, section + len_cat, page, COMPRESSION_EXTENSIONS[i]); uncompress_format = uncompress_formats[i]; #ifdef DEBUG printf("Trying .%c ...\n", COMPRESSION_EXTENSIONS[i]); #endif if ( (file = Uncompress(man_globals, filename)) != NULL) return(file); } #endif /* * And lastly files in a compressed directory. * * The directory is not actually compressed it is just named man#.Z * and all files in it are compressed without the .Z extension. * HP does it this way (really :-). */ snprintf(filename, sizeof(filename), "%s/%s%s.%s/%s", path, CAT, section + len_cat, COMPRESSION_EXTENSION, page); if ( (file = Uncompress(man_globals, filename)) != NULL) return(file); /* * We did not find any preformatted manual pages, try to format it. */ return(Format(man_globals, entry)); }
Bool CSharu::Open(PCWChar pszFileName) { ReleaseAll(); if (file.Open(pszFileName) == False) return False; Bool ret; UInt32 Version, Key; SPackHeader header; SPackHashTableHeader *pHashTable; static Char Seed[] = "8hr48uky,8ugi8ewra4g8d5vbf5hb5s6"; UNREFERENCED_PARAMETER(pHashTable); if (file.Seek(file.FILE_SEEK_END, -(Long)sizeof(header)) == False) return False; if (file.Read(&header, sizeof(header)) == False) return False; Version = *(PUInt32)&header.tag[11]; if (Version > TAG3('3.0') || Version < TAG3('1.0')) return False; header.tag[11] = 0; if (StrICompareA(header.tag, "FilePackVer")) return False; Key = Hash(header.Data, sizeof(header.Data)) & 0x0FFFFFFF; Decrypt(header.Seed, sizeof(header.Seed), Key); if (Version == TAG3('3.0') && memcmp(header.Seed, Seed, sizeof(header.Seed))) return False; // what the f**k is it #if 0 pHashTable = (SPackHashTableHeader *)Alloc(header.HashTableSize); if (pHashTable == NULL) return False; if (file.Seek(file.FILE_SEEK_END, -(Long)(sizeof(header) + header.HashTableSize)) == False) return False; if (file.Read(pHashTable, header.HashTableSize) == False) return False; Version = *(PUInt32)&pHashTable->HashVer[7]; do { ret = False; if (Version < TAG3('1.2') || Version > TAG3('1.3')) break; pHashTable->HashVer[7] = 0; if (lstrcmpiA(pHashTable->HashVer, "HashVer") || pHashTable->SubTableNum != 0x100) break; Decrypt(&pHashTable->Data, pHashTable->CompressedSize, 0x428); UInt32 DecompressSize; LPVoid lpDecrypted = Alloc(pHashTable->Data.DecompressSize); if (lpDecrypted == NULL) break; DecompressSize = Uncompress(&pHashTable->Data, pHashTable->CompressedSize, lpDecrypted); CFileDisk f; if (f.Open(L"K:\\galgame\\¥×¥ê¥ó¥»¥¹¥é¥Ð©`!\\GameData\\test.bin", f.W, f.N)) { f.Write(pHashTable, sizeof(*pHashTable) - sizeof(pHashTable->Data)); f.Write(lpDecrypted, DecompressSize); } Free(lpDecrypted); } while (0); Free(pHashTable); return False; #endif if (Version == TAG3('1.0')) Key = 0xC4; ret = InitIndex(&header, Key); return ret; }
bool PostScript::FindGraphicsFile (/*[in]*/ const char * lpszFileName, /*[out]*/ PathName & result) { if (*lpszFileName == '`') { if (pDviImpl->TryGetTempFile(lpszFileName, result)) { return (true); } else if (strncmp(lpszFileName + 1, "gunzip -c ", 10) == 0) { Uncompress (lpszFileName + 11, result); return (true); } else if (strncmp(lpszFileName + 1, "bunzip2 -c ", 11) == 0) { Uncompress (lpszFileName + 12, result); return (true); } else if (! AllowShellCommand(lpszFileName + 1)) { tracePS->WriteFormattedLine ("libdvi", T_("Ignoring shell command %s"), Q_(lpszFileName + 1)); return (false); } else { char szTempFileName[_MAX_PATH]; Utils::CopyString (szTempFileName, _MAX_PATH, PathName().SetToTempFile().Get()); string command; command = lpszFileName + 1; command += " > "; command += Q_(szTempFileName); MIKTEX_ASSERT (pDviImpl != 0); PathName docDir = pDviImpl->GetDviFileName(); docDir.RemoveFileSpec(); StdoutReader reader; bool done = Process::ExecuteSystemCommand(command.c_str(), 0, &reader, docDir.Get()); if (! done) { // <fixme>hard-coded string</fixme> File::Delete (szTempFileName); FATAL_MIKTEX_ERROR ("PostScript::FindGraphicsFile", T_("Execution of an embedded shell ") T_("command failed for some reason!"), 0); } pDviImpl->RememberTempFile (lpszFileName + 1, szTempFileName); result = szTempFileName; return (true); } } else if (IsZFileName(lpszFileName)) { if (pDviImpl->TryGetTempFile(lpszFileName, result)) { return (true); } Uncompress (lpszFileName, result); return (true); } else { return (pDviImpl->FindGraphicsFile(lpszFileName, result)); } }