/// This function reads data from file
void readFile( std::string t_filepath )
{
std::ifstream a_csvread( t_filepath.c_str() );
if(!a_csvread.is_open())
std::cout << "Error at opening file: " << t_filepath << std::endl;
else {
// file is available
// read file header
HeaderData a_header;
readHeader( a_csvread, a_header );
std::cout << a_header.m_versionString << ": " << a_header.m_major << "." << a_header.m_minor << std::endl;
std::cout << a_header.m_numberOfDataString << ": " << a_header.m_numberOfDataItems << std::endl;
// read file data
for( CenterPoint a_data; readData( a_csvread, a_data ); ) { // Nice for-loop
std::cout << a_data.m_name << ", x=" << a_data.m_x << ", y=" << a_data.m_y << std::endl;
}
a_csvread.close();
}
}
bool Foam::IOobject::headerOk()
{
bool ok = true;
Istream* isPtr = objectStream();
// If the stream has failed return
if (!isPtr)
{
if (objectRegistry::debug)
{
Info
<< "IOobject::headerOk() : "
<< "file " << objectPath() << " could not be opened"
<< endl;
}
ok = false;
}
else
{
// Try reading header
if (!readHeader(*isPtr))
{
if (objectRegistry::debug)
{
IOWarningIn("IOobject::headerOk()", (*isPtr))
<< "failed to read header of file " << objectPath()
<< endl;
}
ok = false;
}
}
delete isPtr;
return ok;
}
bool BasePersistenceManager::initLoad(const Common::String &filename) {
if (DID_FAIL(readHeader(filename))) {
cleanup();
return STATUS_FAILED;
}
_saving = false;
if (_savedName == "" || scumm_stricmp(_savedName.c_str(), _gameRef->getName()) != 0) {
debugC(kWintermuteDebugSaveGame, "ERROR: Saved game name doesn't match current game");
cleanup();
return STATUS_FAILED;
}
// if save is newer version than we are, fail
if (_savedVerMajor > DCGF_VER_MAJOR ||
(_savedVerMajor == DCGF_VER_MAJOR && _savedVerMinor > DCGF_VER_MINOR) ||
(_savedVerMajor == DCGF_VER_MAJOR && _savedVerMinor == DCGF_VER_MINOR && _savedVerBuild > DCGF_VER_BUILD)
) {
debugC(kWintermuteDebugSaveGame, "ERROR: Saved game version is newer than current game");
debugC(kWintermuteDebugSaveGame, "ERROR: Expected %d.%d.%d got %d.%d.%d", DCGF_VER_MAJOR, DCGF_VER_MINOR, DCGF_VER_BUILD, _savedVerMajor, _savedVerMinor, _savedVerBuild);
cleanup();
return STATUS_FAILED;
}
// if save is older than the minimal version we support
if (_savedVerMajor < SAVEGAME_VER_MAJOR ||
(_savedVerMajor == SAVEGAME_VER_MAJOR && _savedVerMinor < SAVEGAME_VER_MINOR) ||
(_savedVerMajor == SAVEGAME_VER_MAJOR && _savedVerMinor == SAVEGAME_VER_MINOR && _savedVerBuild < SAVEGAME_VER_BUILD)
) {
debugC(kWintermuteDebugSaveGame, "ERROR: Saved game is too old and cannot be used by this version of game engine");
debugC(kWintermuteDebugSaveGame, "ERROR: Expected %d.%d.%d got %d.%d.%d", DCGF_VER_MAJOR, DCGF_VER_MINOR, DCGF_VER_BUILD, _savedVerMajor, _savedVerMinor, _savedVerBuild);
cleanup();
return STATUS_FAILED;
}
return STATUS_OK;
}
FfhReader::FfhReader(const std::string& filename) :
HistogramReader(filename)
{
readHeader();
auto it = images.find("IntensityNormalisation");
if (it != images.end())
{
intensity_normalisation = it->second;
auto size = intensity_normalisation.size();
std::vector<int> dims = { 1, size.height, size.width };
intensity_normalisation = intensity_normalisation.reshape(0, 3, &dims[0]);
// For old-style uncorrected (for #frames) normalisation maps, correct based on maximum
if (intensity_normalisation.type() == CV_16U)
{
double mn, mx;
cv::minMaxIdx(intensity_normalisation, &mn, &mx);
intensity_normalisation.convertTo(intensity_normalisation, CV_32F, 1.0 / mx, 0);
}
}
}
SaveStateList SaveFileManager::list(const Common::String &target) {
Common::SaveFileManager *saveFileMan = g_system->getSavefileManager();
Common::StringArray files = saveFileMan->listSavefiles(target + ".###");
SaveStateList saveList;
for (Common::StringArray::const_iterator fileName = files.begin(); fileName != files.end(); ++fileName) {
Common::InSaveFile *saveFile = saveFileMan->openForLoading(*fileName);
if (saveFile == nullptr || saveFile->err()) {
continue;
}
BladeRunner::SaveFileHeader header;
readHeader(*saveFile, header);
int slotNum = atoi(fileName->c_str() + fileName->size() - 3);
saveList.push_back(SaveStateDescriptor(slotNum, header._name));
}
Common::sort(saveList.begin(), saveList.end(), SaveStateDescriptorSlotComparator());
return saveList;
}
void Decoder::decode(std::string inFileName,std::string outFileName,bool mode)
{
//open input file
std::string inName(inFileName);
if (inName.rfind(".ebast",inName.size()-6) == std::string::npos) {
std::cerr << "This isn't a ebast File" << std::endl;
exit(1);
}
inFile.open(inFileName, std::ios::in | std::ios::binary);
if (!inFile.is_open()) {
std::cerr << "Unable to read File" << std::endl;
exit(1);
}
//open output file
std::string outName(outFileName);
outName += ".txt";
if(std::ifstream(outName.c_str()))
{
std::cerr<<outName<<" already exists!"<<std::endl;
exit(1);
}
outFile.open(outName.c_str(),std::ios::out | std::ios::binary);
if (!outFile.is_open()) {
std::cerr << "Unable to create File" << std::endl;
exit(1);
}
//reading frequency table from file
huffmanTree->setRoot(readHeader());
if (mode) {
print(huffmanTree->getRoot());
}
//make file
makeFile();
}
int IfdMakerNote::read(const byte* buf,
long len,
long start,
ByteOrder byteOrder,
long shift)
{
// Remember the offset
offset_ = start - shift;
// Set byte order if none is set yet
if (byteOrder_ == invalidByteOrder) byteOrder_ = byteOrder;
// Read and check the header (and set offset adjustment)
int rc = readHeader(buf + start, len - start, byteOrder);
if (rc == 0) {
rc = checkHeader();
}
// Adjust shift
long newShift = absShift_ ? shift + shift_ : start + shift_;
// Read the makernote IFD
if (rc == 0) {
rc = ifd_.read(buf, len, start + start_, byteOrder_, newShift);
}
if (rc == 0) {
// IfdMakerNote currently does not support multiple IFDs
if (ifd_.next() != 0) {
#ifndef SUPPRESS_WARNINGS
std::cerr << "Warning: Makernote IFD has a next pointer != 0 ("
<< ifd_.next()
<< "). Ignored.\n";
#endif
}
}
#ifdef DEBUG_MAKERNOTE
hexdump(std::cerr, buf + start, len - start);
if (rc == 0) ifd_.print(std::cerr);
#endif
return rc;
} // IfdMakerNote::read
void GameApp::BuildLevel()
{
ifstream infile("tilemap.txt");
string line;
while (getline(infile, line))
{
if (line == "[header]")
{
if (!readHeader(infile))
{
return;
}
}
else if (line == "[layer]")
{
readLayerData(infile);
}
else if (line == "[Object Layer 1]")
{
readEntityData(infile);
}
}
}
void ModelBinaryLoader::loadBinaryFile(std::string p_FilePath)
{
clearData();
std::ifstream input(p_FilePath, std::istream::in | std::istream::binary);
if(!input)
{
throw std::runtime_error("File could not be opened: " + p_FilePath);
}
m_FileHeader = readHeader(&input);
m_Material = readMaterial(m_FileHeader.m_NumMaterial,&input);
if(m_FileHeader.m_Animated)
{
m_AnimationVertexBuffer = readVertexBufferAnimation(m_FileHeader.m_NumVertex, &input);
calculateBoundingVolume(m_AnimationVertexBuffer);
}
else
{
m_VertexBuffer = readVertexBuffer(m_FileHeader.m_NumVertex, &input);
calculateBoundingVolume(m_VertexBuffer);
}
m_MaterialBuffer = readMaterialBuffer(m_FileHeader.m_NumMaterialBuffer, &input);
}
bool MP3Stream::seek(const Timestamp &where) {
if (where == _length) {
_state = MP3_STATE_EOS;
return true;
} else if (where > _length) {
return false;
}
const uint32 time = where.msecs();
mad_timer_t destination;
mad_timer_set(&destination, time / 1000, time % 1000, 1000);
if (_state != MP3_STATE_READY || mad_timer_compare(destination, _totalTime) < 0)
initStream();
while (mad_timer_compare(destination, _totalTime) > 0 && _state != MP3_STATE_EOS)
readHeader();
decodeMP3Data();
return (_state != MP3_STATE_EOS);
}
int
recvFrom
(Peer *peer, byte *headerBuf, byte *dataBuf)
{
int headerSize = readHeader(peer, headerBuf, HEADERSIZE);
if(headerSize == 0 )
{
printf("Non Header \n");
return 0;
}
int length = byteToInt(headerBuf, 8);
int dataSize = readData(peer , dataBuf, length );
printf("[ from %s ] type : %d, redesc : %d length : %d data : %s \n",
peer->ip, byteToInt(headerBuf,0),
byteToInt(headerBuf, 4),
byteToInt(headerBuf, 8),
dataBuf);
return (headerSize + dataSize);
}
void decompress(InputStream& inputStream, OutputBuffer& output, header* pHeader) {
header h;
if (pHeader) {
h = *pHeader;
} else {
readHeader(inputStream, h);
}
uint8* pInputBuffer = new uint8[h.fileSize];
uint8* pOutputBuffer = new uint8[h.fileSize];
ArithmeticDecoder decoder(inputStream);
StructuredModel model(h.increments);
model.decode(decoder, pInputBuffer, h.tempSize);
iMTF(pInputBuffer, h.tempSize);
iBWT(pInputBuffer, pOutputBuffer, h.tempSize, h.first);
iRLE(pOutputBuffer, pInputBuffer, h.tempSize);
output.setBuffer(pInputBuffer, h.fileSize);
delete[] pOutputBuffer;
}
int readFile (char *filename, int *rows, int *cols, PIXEL** bitmap)
{
int fd, ret;
unsigned int start;
if(filename) {
if((fd = open(filename, O_RDONLY)) < 0) {
perror("Can't open bmp file to read");
return -1;
}
} else fd = STDIN_FILENO;
ret = readHeader (fd, rows, cols, &start);
if(ret) return ret;
*bitmap = (PIXEL*)malloc(sizeof(PIXEL)*(*rows)*(*cols));
ret = readBits (fd, *bitmap, *rows, *cols, start);
if(ret) return ret;
if(filename) close(fd);
return 0;
}
void MDNS::getResponses() {
QueryHeader header = readHeader(buffer);
if ((header.flags & 0x8000) == 0 && header.qdcount > 0) {
uint8_t count = 0;
while (count++ < header.qdcount && buffer->available() > 0) {
Label * label = matcher->match(labels, buffer);
if (buffer->available() >= 4) {
uint16_t type = buffer->readUInt16();
uint16_t cls = buffer->readUInt16();
if (label != NULL) {
label->matched(type, cls);
}
} else {
status = "Buffer underflow at index " + buffer->getOffset();
}
}
}
}
bool Table::rewind()
{
xmlTextReaderPtr reader = NULL;
if ( (reader = xmlNewTextReaderFilename(getName().c_str())) == NULL)
{
cout<<endl<<"Essai d'ouvrir "<< getName() <<endl;
cout << "erreur fatale " << endl;
return (false);
}
xmlTextReaderRead(reader);
// initialisation du xmlReader
setXmlReader(reader);
// Utilise readHeader()
readHeader();
// le tuple courant est 0
currentTuple = 0;
return (true);
}
//---------------------------------------------------------------------
uint32 StreamSerialiser::peekNextChunkID()
{
checkStream();
if (eof())
return 0;
// Have we figured out the endian mode yet?
if (mReadWriteHeader)
readHeader();
if (mEndian == ENDIAN_AUTO)
OGRE_EXCEPT(Exception::ERR_INVALID_STATE,
"Endian mode has not been determined, did you disable header without setting?",
"StreamSerialiser::peekNextChunkID");
size_t homePos = mStream->tell();
uint32 ret;
read(&ret);
mStream->seek(homePos);
return ret;
}
static void
readTemplate(template_t *t, tfile_t *tf)
{
int magic;
readScalar(magic, tf);
assert(magic == TMPL_MAGIC); /* Already checked by caller */
readHeader(t, tf);
readScalar(t->tm_flags, tf);
t->tm_flags |= TMPL_TF_IMPORTED;
readScalar(t->tm_alignment, tf);
readScalar(t->tm_minsize, tf);
readTemplateRefs(t, tf);
if (tf->tf_errors) {
/* Failed to import all structs we ref. Bail out now. */
return;
}
readAttributes(t, tf);
if (isRedirectTmpl(t)) {
readTmplRedirection(t, tf);
}
readTmplFormat(t, tf);
}
/* Write what is in the memPage to the pageNumth block.
* The value of curPagePos was set to pageNum after writing.
*/
RC
writeBlock (int pageNum, SM_FileHandle *fHandle, SM_PageHandle memPage)
{
FILE *fp;
int totalNumPages;
char *buff;
if (access(fHandle->fileName, R_OK) < 0) return RC_FILE_NOT_FOUND;
fp = fopen(fHandle->fileName, "r+");
buff = (char*)malloc(sizeof(char)*PAGE_SIZE);
if ((totalNumPages = readHeader(fp)) < 1) return RC_FILE_R_W_ERROR;
//check if pageNum is valid
if ((pageNum >= totalNumPages) || (pageNum < 0)) return RC_READ_NON_EXISTING_PAGE;
//read till the (pageNum - 1)th page
int i;
for (i = 0; i < pageNum; i++) {
fread(buff, sizeof(char)*PAGE_SIZE, 1, fp);
}
//write memPage to the pageNum
if (fwrite(memPage, sizeof(char)*PAGE_SIZE, 1, fp) < 1) return RC_WRITE_FAILED;
// printf("WRITED TO DISK (page-%i): %s\n", pageNum, memPage);
// printf("#### Writed page (%d) to disk! ####\n", pageNum);
fHandle->curPagePos = pageNum;
free(buff);
fclose(fp);
return RC_OK;
}
/* If the file has less than numberOfPages pages, then increase the size to numberOfPages.
* The increasing is done by appending (numberOfPages - totalNumPages) empty blocks
* at the end of file.
*/
RC
ensureCapacity (int numberOfPages, SM_FileHandle *fHandle)
{
FILE *fp;
int totalNumPages, i;
char *buff;
if (access(fHandle->fileName, R_OK) < 0) return RC_FILE_NOT_FOUND;
fp = fopen(fHandle->fileName, "r+");
buff = (char*)malloc(sizeof(char)*PAGE_SIZE);
if ((totalNumPages = readHeader(fp)) < 1) return RC_FILE_R_W_ERROR;
if (numberOfPages > totalNumPages) {
for (i = 0; i < (numberOfPages - totalNumPages); i++) {
appendEmptyBlock(fHandle);
}
}
// log file info to console
struct stat fileStat;
if(stat(fHandle->fileName,&fileStat) < 0)
return RC_FILE_R_W_ERROR;
// printf("\n\n**ENSURE LOG**\n");
// printf("************************************\n");
// printf("File Name: \t\t%s\n",fHandle->fileName);
// printf("File Size: \t\t%lld bytes\n",fileStat.st_size);
// printf("Total # Pages: \t%d\n",fHandle->totalNumPages);
free(buff);
fclose(fp);
return RC_OK;
}
RecordStorage::RecordStorage(int32_t maxRecordSize, char* fileName, int32_t id_msb, int32_t id_lsb, Stream* debugStream) {
closed = false;
debug = debugStream;
// if(debug != NULL)
// {
// debug->print("Record Storage: ");
// debug->println(fileName);
// debug->print("Record Size: ");
// debug->println(maxRecordSize);
// }
file_name = fileName;
error_code = 0;
header = NULL;
// magic = HEADER_MAGIC_NUMBER;
if (SD.exists(fileName) ) {
// if(debug != NULL)
// {
// debug->print("Record File Size: ");
// debug->println(store.size());
// }
readHeader();
if(header->maxRecordSize != maxRecordSize)
{
error_code = error_code | ERROR_ROW_SIZE_MISMATCH;
}
} else {
header = (RecordHeader*) calloc(sizeof(RecordHeader), 1);
header->magicNumber = HEADER_MAGIC_NUMBER;
header->maxRecordSize = maxRecordSize;
header->uploaded = 0;
header->id_lsb = id_lsb;
header->id_msb = id_msb;
writeHeader();
}
}
RlfAnimation::RlfAnimation(const Common::String &fileName, bool stream)
: _stream(stream),
_readStream(NULL),
_lastFrameRead(0),
_frameCount(0),
_width(0),
_height(0),
_frameTime(0),
_frames(0),
_nextFrame(0),
_frameBufferByteSize(0) {
Common::File *_file = new Common::File;
if (!_file->open(fileName)) {
warning("RLF animation file %s could not be opened", fileName.c_str());
return;
}
_readStream = _file;
if (!readHeader()) {
warning("%s is not a RLF animation file. Wrong magic number", fileName.c_str());
return;
}
_currentFrameBuffer.create(_width, _height, Graphics::createPixelFormat<565>());
_frameBufferByteSize = _width * _height * sizeof(uint16);
if (!stream) {
_frames = new Frame[_frameCount];
// Read in each frame
for (uint i = 0; i < _frameCount; ++i) {
_frames[i] = readNextFrame();
}
}
}
G12Buffer* PPMLoader::g12BufferCreateFromPGM(const string& name, MetaData *meta)
{
// open file for reading in binary mode
FILE *fp = fopen(name.c_str(), "rb");
if (fp == nullptr)
return nullptr;
// PPM headers variable declaration
unsigned long h, w;
uint8_t type;
uint16_t maxval;
if (!readHeader(fp, &h, &w, &maxval, &type, meta) || (type != 5 && type != 6))
{
fclose(fp);
return nullptr;
}
bool calcWhite = false;
int white = 0;
// if no metadata is present, create some
// if metadata is null, don't
if (meta != nullptr)
{
// create an alias to metadata
MetaData &metadata = *meta;
// get significant bit count
if (metadata["bits"].empty())
{
metadata["bits"].push_back(1);
}
while (maxval >> int(metadata["bits"][0]))
{
metadata["bits"][0]++;
}
if (metadata["white"].empty())
calcWhite = true;
}
int main(int argc, char ** argv)
{
if(argc != 3)
{
printf("ERROR! There should be three input arguments, the object file, the input file and the output file");
return EXIT_FAILURE;
}
FILE * ftpr;
ftpr = fopen(argv[1],"r");
if(ftpr == NULL)
{
printf("\n Error! The input file could not be opened");
return EXIT_FAILURE;
}
fclose(ftpr);
HuffNode * Huffmannroot = NULL;
int filetype = readHeader(argv[1]);
if(filetype == 0)
{
Huffmannroot = create_Huffmanntree(argv[1]);
}
else
{
Huffmannroot = create_HufftreeBit(argv[1]);
}
FILE * ftpr2 = fopen(argv[2],"w");
if(ftpr2 == NULL)
{
printf("Error! The output filename argument could not be opened.");
return EXIT_FAILURE;
}
Huff_postOrderPrint(Huffmannroot, ftpr2);
tree_destroy(Huffmannroot);
fclose(ftpr2);
return EXIT_SUCCESS;
}
bool
CImageGIF::
readHeader(CFile *file, CImagePtr &image)
{
file->rewind();
try {
CImageGIFHeader header;
readHeader(file, image, &header);
//------
image->setType(CFILE_TYPE_IMAGE_GIF);
image->setSize(header.width, header.height);
}
catch (...) {
CImage::errorMsg("Failed to read GIF file");
return false;
}
return true;
}
int History::save(QString user, QDateTime date, QString* lpszData) {
lmcSettings settings;
QString path = historyFile();
QDir dir = QFileInfo(path).dir();
if(!dir.exists())
dir.mkpath(dir.absolutePath());
if(!QFile::exists(path))
create(path);
QFile file(path);
if(!file.open(QIODevice::ReadWrite))
return -1;
QDataStream stream(&file);
DBHeader header = readHeader(&stream);
if(header.marker.compare(HC_DBMARKER) != 0) {
file.close();
return -1;
}
qint64 dataPos = insertData(&stream, lpszData);
qint64 newIndex = insertIndex(&stream, dataPos, user, date);
updateIndex(&stream, header.last, newIndex);
header.count++;
header.first = (header.first == 0) ? newIndex : header.first;
header.last = newIndex;
writeHeader(&stream, &header);
file.close();
return 0;
}
int HttpClient::skipResponseHeaders()
{
isChunk = 0;
header_line = "";
// Just keep reading until we finish reading the headers or time out
unsigned long timeoutStart = millis();
// Whilst we haven't timed out & haven't reached the end of the headers
while ((!endOfHeadersReached()) &&
( (millis() - timeoutStart) < iHttpResponseTimeout ))
{
if (available())
{
(void)readHeader();
// We read something, reset the timeout counter
timeoutStart = millis();
}
else
{
// We haven't got any data, so let's pause to allow some to
// arrive
delay(kHttpWaitForDataDelay);
}
}
if (endOfHeadersReached())
{
// Success
return HTTP_SUCCESS;
}
else
{
// We must've timed out
return HTTP_ERROR_TIMED_OUT;
}
}
QList<MsgInfo> History::getList(void) {
QList<MsgInfo> list;
lmcSettings settings;
QString path = historyFile();
if(!QFile::exists(path))
return list;
QFile file(path);
if(!file.open(QIODevice::ReadOnly))
return list;
QDataStream stream(&file);
DBHeader header = readHeader(&stream);
qint64 next = header.first;
QString marker;
qint64 offset;
qint64 date;
QString name;
while(next != 0) {
stream.device()->seek(next);
MsgInfo info;
stream >> marker;
stream >> next;
stream >> offset;
stream >> date;
stream >> name;
list.append(MsgInfo(name, QDateTime::fromMSecsSinceEpoch(date), offset));
}
return list;
}
bool ProjectManagerXML::Open(const wxString &filename, const wxString &syslabels_path)
{
bool ret;
wxXmlDocument xml_doc;
ret = xml_doc.Load(filename);
if (ret)
{
readHeader(xml_doc);
readFileProperties(xml_doc);
if (process->SetupSystemLabels())
{
process->LoadSystemLabels(syslabels_path);
}
readDasmData(xml_doc);
readCodeLine(xml_doc);
readLabel(xml_doc, process->io_labels, SECTION_IOLABEL_STR);
readLabel(xml_doc, process->var_labels, SECTION_VARLABEL_STR);
readLabel(xml_doc, process->prog_labels, SECTION_PROGRAMLABEL_STR);
readLabel(xml_doc, process->constant_labels, SECTION_CONSTANTLABEL_STR);
}
return ret;
}
// Constructor
STORAGE::Filesystem::Filesystem(const char* fname) : file(fname), shuttingDown(false) {
resetStats();
MVCC = false;
// Set up file directory if the backing file is new.
if (file.isNew()) {
logEvent(EVENT, "Backing file is new");
dir = new FileDirectory();
writeFileDirectory(dir);
} else {
logEvent(EVENT, "Backing file exists, populating lookup table");
dir = readFileDirectory();
std::ostringstream os;
os << dir->numFiles;
logEvent(EVENT, "Number of stored files is " + os.str());
// Populate lookup table
for (File i = 0; i < dir->numFiles; ++i) {
dir->headers[i] = readHeader(i);
std::string name(dir->headers[i].name);
lookup[name] = i;
}
}
}
bool
CGIFImage::
readHeader(CFile *file, CGenImage *image)
{
file->rewind();
try {
CGIFImageHeader header;
readHeader(file, image, &header);
//------
image->setType(CFILE_TYPE_IMAGE_GIF);
image->setSize(header.width, header.height);
}
catch (...) {
CTHROW("Failed to read GIF file");
return false;
}
return true;
}
