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;
}
