EStatusCode PFMFileReader::Read(const string& inPFMFilePath) { EStatusCode status = PDFHummus::eSuccess; mInternalReadStatus = PDFHummus::eSuccess; InputFile pfmFile; status = pfmFile.OpenFile(inPFMFilePath); if(status != PDFHummus::eSuccess) { TRACE_LOG1("PFMFileReader::Read, unable to open PFM file in %s",inPFMFilePath.c_str()); return status; } do { mReaderStream = pfmFile.GetInputStream(); status = ReadHeader(); if(status != PDFHummus::eSuccess) break; status = ReadExtension(); if(status != PDFHummus::eSuccess) break; status = ReadExtendedFontMetrics(); if(status != PDFHummus::eSuccess) break; }while(false); pfmFile.CloseFile(); return status; }
void ClassBuffer::SearchFile (const char* path, struct stat&) { InputFile* f = InputFile::open(path); if (f == nil) { return; } const char* buf; int len = f->read(buf); if (len <= 0) { return; } if (_verbose) { printf("searching file %s (%d)\n", path, len); } /* * stupid regular expression requires writable strings to guarantee * null-termination */ char* tbuf = new char[len + 1]; Memory::copy(buf, tbuf, len); tbuf[len] = '\0'; TextBuffer textbuf(tbuf, len, len); SearchTextBuffer(&textbuf, path); delete tbuf; f->close(); delete f; }
Optional<unsigned> CompilerInstance::getRecordedBufferID(const InputFile &input, bool &failed) { if (!input.buffer()) { if (Optional<unsigned> existingBufferID = SourceMgr.getIDForBufferIdentifier(input.file())) { return existingBufferID; } } std::pair<std::unique_ptr<llvm::MemoryBuffer>, std::unique_ptr<llvm::MemoryBuffer>> buffers = getInputBufferAndModuleDocBufferIfPresent(input); if (!buffers.first) { failed = true; return None; } // FIXME: The fact that this test happens twice, for some cases, // suggests that setupInputs could use another round of refactoring. if (serialization::isSerializedAST(buffers.first->getBuffer())) { PartialModules.push_back( {std::move(buffers.first), std::move(buffers.second)}); return None; } assert(buffers.second.get() == nullptr); // Transfer ownership of the MemoryBuffer to the SourceMgr. unsigned bufferID = SourceMgr.addNewSourceBuffer(std::move(buffers.first)); InputSourceCodeBufferIDs.push_back(bufferID); return bufferID; }
std::pair<std::unique_ptr<llvm::MemoryBuffer>, std::unique_ptr<llvm::MemoryBuffer>> CompilerInstance::getInputBufferAndModuleDocBufferIfPresent( const InputFile &input) { if (auto b = input.buffer()) { return std::make_pair(llvm::MemoryBuffer::getMemBufferCopy( b->getBuffer(), b->getBufferIdentifier()), nullptr); } // FIXME: Working with filenames is fragile, maybe use the real path // or have some kind of FileManager. using FileOrError = llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>>; FileOrError inputFileOrErr = llvm::MemoryBuffer::getFileOrSTDIN(input.file()); if (!inputFileOrErr) { Diagnostics.diagnose(SourceLoc(), diag::error_open_input_file, input.file(), inputFileOrErr.getError().message()); return std::make_pair(nullptr, nullptr); } if (!serialization::isSerializedAST((*inputFileOrErr)->getBuffer())) return std::make_pair(std::move(*inputFileOrErr), nullptr); if (Optional<std::unique_ptr<llvm::MemoryBuffer>> moduleDocBuffer = openModuleDoc(input)) { return std::make_pair(std::move(*inputFileOrErr), std::move(*moduleDocBuffer)); } return std::make_pair(nullptr, nullptr); }
static Packer* try_unpack(Packer *p, void *user) { if (p == NULL) return NULL; InputFile *f = (InputFile *) user; p->assertPacker(); try { p->initPackHeader(); f->seek(0,SEEK_SET); int r = p->canUnpack(); if (r > 0) { f->seek(0,SEEK_SET); return p; } if (r < 0) { // FIXME - could stop testing all other unpackers at this time // see canUnpack() in packer.h } } catch (const IOException&) { } catch (...) { delete p; throw; } delete p; return NULL; }
EStatusCode OpenTypeTest::TestFont() { EStatusCode status; InputFile otfFile; do { status = otfFile.OpenFile("C:\\PDFLibTests\\TestMaterials\\fonts\\BrushScriptStd.otf"); if(status != PDFHummus::eSuccess) { cout<<"cannot read bursh script font file\n"; break; } OpenTypeFileInput openTypeReader; status = openTypeReader.ReadOpenTypeFile(otfFile.GetInputStream()); if(status != PDFHummus::eSuccess) { cout<<"could not read open type file\n"; break; } // show just abcd and notdef status = SaveCharstringCode(0,0,&openTypeReader.mCFF); for(unsigned short i=66; i < 70 && PDFHummus::eSuccess == status; ++i) status = SaveCharstringCode(0,i,&openTypeReader.mCFF); }while(false); return status; }
std::string OutputFilesComputer::determineBaseNameOfOutput(const InputFile &input) const { std::string nameToStem = input.isPrimary() ? input.file() : ModuleNameArg ? ModuleNameArg->getValue() : FirstInput; return llvm::sys::path::stem(nameToStem).str(); }
void Program::LinkFile (const char* filename) { InputFile* file; if (units->Get(filename, file)) { file->Unlink(oldModList); } else { file = AddFile(filename); } InsertInf(file); }
StringRef SupplementaryOutputPathsComputer:: deriveDefaultSupplementaryOutputPathExcludingExtension( StringRef outputFilename, const InputFile &input) const { // Put the supplementary output file next to the output file if possible. if (!outputFilename.empty() && outputFilename != "-") return outputFilename; if (input.isPrimary() && input.file() != "-") return llvm::sys::path::filename(input.file()); return ModuleName; }
EStatusCode PreprocessorTest::RunTest(const string& inName, const string& inOriginalFile, const string& inOutputFile, const string& inComparisonFile) { EStatusCode status = eSuccess; StringToStringMap preprocessorDefinitions; StringList includeFolders; includeFolders.push_back(scSamplesBasePath); preprocessorDefinitions.insert(StringToStringMap::value_type("PREDEFINED_SYMBOL","2")); InputFile sourceFile; sourceFile.OpenFile(inOriginalFile); OutputFile outputFile; outputFile.OpenFile(inOutputFile); mCurrentStream = outputFile.GetOutputStream(); PreProcessor preProcessor; preProcessor.Setup(sourceFile.GetInputStream(),inOriginalFile,preprocessorDefinitions,includeFolders); preProcessor.AddListener(this); mStartRow = true; BoolAndString tokenizerResult = preProcessor.GetNextToken(); while(tokenizerResult.first) { if(!mStartRow) mCurrentStream->Write((const Byte*)" ",2); // 2 spaces, so we can clearly distinct tokens mCurrentStream->Write((const Byte*)tokenizerResult.second.c_str(),tokenizerResult.second.size()); mStartRow = false; tokenizerResult = preProcessor.GetNextToken(); } sourceFile.CloseFile(); outputFile.CloseFile(); mCurrentStream = NULL; SimpleFileComparer comparer; if(!comparer.Same(inOutputFile,inComparisonFile)) { cout<<"TokenizerTest::Run, failed in test named "<<inName<<". see result in "<<inOutputFile<<" and compare with the required result in "<<inComparisonFile<<"\n"; status = eFailure; } return status; }
EStatusCode PDFWriter::ModifyPDF(const std::string& inModifiedFile, EPDFVersion inPDFVersion, const std::string& inOptionalAlternativeOutputFile, const LogConfiguration& inLogConfiguration, const PDFCreationSettings& inPDFCreationSettings) { EStatusCode status = eSuccess; SetupLog(inLogConfiguration); SetupObjectsContext(inPDFCreationSettings); do { // either append to original file, or create a new copy and "modify" it. depending on users choice if(inOptionalAlternativeOutputFile.size() == 0 || (inOptionalAlternativeOutputFile == inModifiedFile)) { status = mOutputFile.OpenFile(inModifiedFile,true); if(status != eSuccess) break; } else { status = mOutputFile.OpenFile(inOptionalAlternativeOutputFile); if(status != eSuccess) break; // copy original to new output file InputFile modifiedFileInput; status = modifiedFileInput.OpenFile(inModifiedFile); if(status != eSuccess) break; OutputStreamTraits traits(mOutputFile.GetOutputStream()); status = traits.CopyToOutputStream(modifiedFileInput.GetInputStream()); if(status != eSuccess) break; } mObjectsContext.SetOutputStream(mOutputFile.GetOutputStream()); mDocumentContext.SetOutputFileInformation(&mOutputFile); // do setup for modification mIsModified = true; status = SetupStateFromModifiedFile(inModifiedFile,inPDFVersion); } while (false); return status; }
EStatusCode OpenTypeFileInput::ReadOpenTypeFile(const std::string& inFontFilePath, unsigned short inFaceIndex) { InputFile fontFile; EStatusCode status = fontFile.OpenFile(inFontFilePath); if(status != PDFHummus::eSuccess) { TRACE_LOG1("OpenTypeFileInput::ReadOpenTypeFile, cannot open true type font file at %s",inFontFilePath.c_str()); return status; } status = ReadOpenTypeFile(fontFile.GetInputStream(), inFaceIndex); fontFile.CloseFile(); return status; }
void Program::DoLink () { while (oldModList != nil) { InputFile* doomed = (InputFile*) oldModList; oldModList = (InputFile*)oldModList->nn; doomed->Unlink(oldModList); delete doomed; } Base* insertPoint = inf->nn; ctdt->Link(insertPoint); if (fullLink) { FullLink(); } else { Relink(); } }
int main(int argc, char **argv) { welcome(); defineverbose(); filenames.clear(); ClustalWInitializers(); clustalw::ClustalWResources *resources = clustalw::ClustalWResources::Instance(); resources->setPathToExecutable(string(argv[0])); setUserParameters(); InputFile start;// object reads from an input file and creates a new file start.run(); string offendingSeq; Clustal* clustalObj; clustalObj = new clustalw::Clustal(); int u = clustalObj->sequenceInput(false, &offendingSeq); string phylipName; clustalObj->align(&phylipName); AminoAcidFrequency Table; Table.openFile("TEST-OutputFile.aln"); vector<ProteinSequence> p1; p1 = start.getProteinData(); Table.generateAminoAcidTables(p1); p1.clear(); p1 = Table.getFinalSeqs(); DistanceMatrix dm; dm.createDistanceTableCodes(p1); dm.createSimilarityMatrixCodes(p1); dm.createDistanceTableColours(p1); dm.createSimilarityMatrixColours(p1); VerticalPosition vp; vp.run(p1); cout<< "\nPROCESS COMPLETED!\nThe following files were created:\n" << endl; for ( size_t i = 0; i < filenames.size(); i++ ) { cout << "\t" << i+1 << ". " << filenames[i] << endl; } return 0; }
void process (InputFile &file, const char *oname) { typedef typename imf_ttrait<T>::type type; constexpr PixelType ptype = imf_ttrait<T>::PIXEL_TYPE; Array2D<type> r, g, b; FrameBuffer fb; Box2i dw = file.header().dataWindow(); int w = dw.max.x - dw.min.x + 1; int h = dw.max.y - dw.min.y + 1; r.resizeErase(h, w); g.resizeErase(h, w); b.resizeErase(h, w); fb.insert("R", Slice(ptype, (char*)(&r[0][0] - dw.min.x - dw.min.y * w), sizeof(r[0][0]) * 1, sizeof(r[0][0]) * w, 1, 1, 0.0)); fb.insert("G", Slice(ptype, (char*)(&g[0][0] - dw.min.x - dw.min.y * w), sizeof(g[0][0]) * 1, sizeof(g[0][0]) * w, 1, 1, 0.0)); fb.insert("B", Slice(ptype, (char*)(&b[0][0] - dw.min.x - dw.min.y * w), sizeof(b[0][0]) * 1, sizeof(b[0][0]) * w, 1, 1, 0.0)); file.setFrameBuffer(fb); file.readPixels(dw.min.y, dw.max.y); FILE *pgm = fopen(oname, "wb"); float bw; fprintf(pgm, "P5\n"); fprintf(pgm, "%d %d\n", w, h); fprintf(pgm, "255\n"); // convert to gray scale for (int j = 0; j < h; j++) { for (int i = 0; i < w; i++) { bw = 0.30 * lin2srgb(r[j][i]) + 0.58 * lin2srgb(g[j][i]) + 0.12 * lin2srgb(b[j][i]); fputc((int)(bw * 255.0 + 0.5), pgm); } } fclose(pgm); }
void FrontendInputsAndOutputs::addInput(const InputFile &input) { const unsigned index = AllInputs.size(); AllInputs.push_back(input); if (input.isPrimary()) { PrimaryInputsInOrder.push_back(index); PrimaryInputsByName.insert(std::make_pair(AllInputs.back().file(), index)); } }
bool Functions::Photos::uploadProfilePhoto(OutboundPkt *out, const InputFile &file, const QString &caption, const InputGeoPoint &geoPoint, const InputPhotoCrop &crop) { out->appendInt(fncPhotosUploadProfilePhoto); if(!file.push(out)) return false; out->appendQString(caption); if(!geoPoint.push(out)) return false; if(!crop.push(out)) return false; return true; }
FileProperties::FileProperties(const InputFile& file) : _file(file) , _formatContext(&file.getFormatContext()) , _avFormatContext(&file.getFormatContext().getAVFormatContext()) , _streamsProperties() , _videoStreams() , _audioStreams() , _dataStreams() , _subtitleStreams() , _attachementStreams() , _unknownStreams() { if(_avFormatContext) detail::fillMetadataDictionnary(_avFormatContext->metadata, _metadatas); NoDisplayProgress progress; extractStreamProperties(progress, eAnalyseLevelHeader); }
EStatusCode parsePDF() { PDFParser parser; InputFile pdfFile; EStatusCode status = pdfFile.OpenFile(scBasePath + "XObjectContent.PDF"); if(status != eSuccess) return status; status = parser.StartPDFParsing(pdfFile.GetInputStream()); if(status != eSuccess) return status; showPDFinfo(parser); // Just wcout some info (no iteration) showPagesInfo(parser,pdfFile,status); return status; }
void readGZ2 (const char fileName[], Array2D<GZ> &pixels, int &width, int &height) { // // Read an image using class InputFile. Try to read one channel, // G, of type HALF, and one channel, Z, of type FLOAT. In memory, // the G and Z channels will be interleaved in a single buffer. // // - open the file // - allocate memory for the pixels // - describe the layout of the GZ pixel buffer // - read the pixels from the file // InputFile file (fileName); Box2i dw = file.header().dataWindow(); width = dw.max.x - dw.min.x + 1; height = dw.max.y - dw.min.y + 1; int dx = dw.min.x; int dy = dw.min.y; pixels.resizeErase (height, width); FrameBuffer frameBuffer; frameBuffer.insert ("G", // name Slice (IMF::HALF, // type (char *) &pixels[-dy][-dx].g, // base sizeof (pixels[0][0]) * 1, // xStride sizeof (pixels[0][0]) * width)); // yStride frameBuffer.insert ("Z", // name Slice (IMF::FLOAT, // type (char *) &pixels[-dy][-dx].z, // base sizeof (pixels[0][0]) * 1, // xStride sizeof (pixels[0][0]) * width)); // yStride file.setFrameBuffer (frameBuffer); file.readPixels (dw.min.y, dw.max.y); }
void makePreview (const char inFileName[], const char outFileName[], int previewWidth, float exposure, bool verbose) { if (verbose) cout << "generating preview image" << endl; Array2D <PreviewRgba> previewPixels; int previewHeight; generatePreview (inFileName, exposure, previewWidth, previewHeight, previewPixels); InputFile in (inFileName); Header header = in.header(); header.setPreviewImage (PreviewImage (previewWidth, previewHeight, &previewPixels[0][0])); if (verbose) cout << "copying " << inFileName << " to " << outFileName << endl; if (header.hasTileDescription()) { TiledOutputFile out (outFileName, header); out.copyPixels (in); } else { OutputFile out (outFileName, header); out.copyPixels (in); } if (verbose) cout << "done." << endl; }
void showPageContent(PDFParser& parser, RefCountPtr<PDFObject> contents, InputFile& pdfFile) { if(contents->GetType() == ePDFObjectArray) { PDFObjectCastPtr<PDFIndirectObjectReference> streamReferences; SingleValueContainerIterator<PDFObjectVector> itContents = ((PDFArray*)contents.GetPtr())->GetIterator(); // array of streams while(itContents.MoveNext()) { streamReferences = itContents.GetItem(); PDFObjectCastPtr<PDFStreamInput> stream = parser.ParseNewObject(streamReferences->mObjectID); showContentStream(stream.GetPtr(),pdfFile.GetInputStream(),parser); } } else { // stream showContentStream((PDFStreamInput*)contents.GetPtr(),pdfFile.GetInputStream(),parser); } }
bool CompilerInstance::setUpForInput(const InputFile &input) { bool failed = false; Optional<unsigned> bufferID = getRecordedBufferID(input, failed); if (failed) return true; if (!bufferID) return false; if (isInSILMode() || (isInputSwift() && llvm::sys::path::filename(input.file()) == "main.swift")) { assert(MainBufferID == NO_SUCH_BUFFER && "re-setting MainBufferID"); MainBufferID = *bufferID; } if (input.isPrimary()) { recordPrimaryInputBuffer(*bufferID); } return false; }
int main () { printf ("Results of custom_buffer_size_test:\n"); try { FileSystem::AddSearchPath ("data"); FileSystem::SetFileBufferSize ("speed-test.txt", 1024*1024); InputFile file ("speed-test.txt"); printf ("File buffer size: %u\n", file.BufferSize ()); } catch (std::exception& exception) { printf ("Exception: %s\n",exception.what ()); } return 0; }
void FrontendOptions::forAllOutputPaths( const InputFile &input, llvm::function_ref<void(StringRef)> fn) const { if (RequestedAction != FrontendOptions::ActionType::EmitModuleOnly && RequestedAction != FrontendOptions::ActionType::MergeModules) { if (InputsAndOutputs.isWholeModule()) InputsAndOutputs.forEachOutputFilename(fn); else fn(input.outputFilename()); } const SupplementaryOutputPaths &outs = input.getPrimarySpecificPaths().SupplementaryOutputs; const std::string *outputs[] = {&outs.ModuleOutputPath, &outs.ModuleDocOutputPath, &outs.ParseableInterfaceOutputPath, &outs.ObjCHeaderOutputPath}; for (const std::string *next : outputs) { if (!next->empty()) fn(*next); } }
bool isUpdated( const InputFile &in, const std::string &outHeaderName, const std::string &outImplName) { bool toret = false; InputFile out1( outHeaderName ); InputFile out2( outImplName ); if ( in.isOpen() && out1.isOpen() && out2.isOpen() ) { toret = ( out1.getTimeStamp() >= in.getTimeStamp() && out2.getTimeStamp() >= in.getTimeStamp() ) ; } return toret; }
FT_Stream FreeTypeWrapper::CreateFTStreamForPath(const std::string& inFilePath) { InputFile* inputFile = new InputFile; if(inputFile->OpenFile(inFilePath) != PDFHummus::eSuccess) return NULL; FT_Stream aStream = new FT_StreamRec(); aStream->base = NULL; aStream->size = (unsigned long)inputFile->GetFileSize(); aStream->pos = 0; aStream->descriptor.pointer = inputFile; aStream->pathname.pointer = NULL; aStream->read = InputFileReadSeek; aStream->close = InputFileClose; aStream->memory = NULL; aStream->cursor = NULL; aStream->limit = NULL; return aStream; }
EStatusCode PFBStreamTest::Run(const TestConfiguration& inTestConfiguration) { EStatusCode status; InputFile pfbFile; OutputFile decodedPFBFile; InputPFBDecodeStream decodeStream; do { pfbFile.OpenFile(RelativeURLToLocalPath(inTestConfiguration.mSampleFileBase,"TestMaterials/fonts/HLB_____.PFB")); decodedPFBFile.OpenFile(RelativeURLToLocalPath(inTestConfiguration.mSampleFileBase,"decodedPFBFile.txt")); status = decodeStream.Assign(pfbFile.GetInputStream()); if(status != PDFHummus::eSuccess) { cout<<"Failed to assign pfb input stream"; break; } OutputStreamTraits traits(decodedPFBFile.GetOutputStream()); status = traits.CopyToOutputStream(&decodeStream); if(status != PDFHummus::eSuccess) { cout<<"Failed to decode pfb stream"; break; } }while(false); decodeStream.Assign(NULL); pfbFile.CloseFile(); decodedPFBFile.CloseFile(); return status; }
Optional<std::string> OutputFilesComputer::deriveOutputFileFromInput(const InputFile &input) const { if (input.file() == "-" || HasTextualOutput) return std::string("-"); std::string baseName = determineBaseNameOfOutput(input); if (baseName.empty()) { // Assuming FrontendOptions::doesActionProduceOutput(RequestedAction) Diags.diagnose(SourceLoc(), diag::error_no_output_filename_specified); return None; } return deriveOutputFileFromParts("", baseName); }
int main(int argc, const char** argv){ #ifdef WIN32 setneuronhome(argv[0]); #endif if (!neuronhome()) { printf("no NEURONHOME\n"); return 1; } // printf("started hel2mos\n"); char buf[256]; sprintf(buf, "%s/lib/helpdict", neuronhome()); String sf(buf); InputFile* f = InputFile::open(sf); if (f == nil) { printf("Can't open %s\n", sf.string()); return 1; } const char* st; int flen = f->read(st); shelp = new CopyString(st, flen); f->close(); nrnbbs_connect(); nrnbbs_post("ochelp running"); start(); nrnbbs_notify("ochelp", help); #ifdef WIN32 nrnbbs_notify("neuron closed", help); #else nrnbbs_notify("neuron closed", quit); #endif help(""); nrnbbs_wait(&quit_); stop(); nrnbbs_take("ochelp running"); nrnbbs_disconnect(); return 0; }