void
mm_io_c::skip(int64 num_bytes) {
uint64_t pos = getFilePointer();
setFilePointer(pos + num_bytes);
if ((pos + num_bytes) != getFilePointer())
throw mtx::mm_io::end_of_file_x();
}
uint32_t RelocationTable::read(BinaryInputFile* binaryInputFile){
binaryInputFile->setInPointer(getFilePointer());
uint32_t numberOfRelocations = sizeInBytes / relocationSize;
for (uint32_t i = 0; i < numberOfRelocations; i++){
if (elfFile->is64Bit() && type == ElfRelType_rel){
relocations.append(new Relocation64(getFilePointer() + (i * Size__64_bit_Relocation), i));
} else if (elfFile->is64Bit() && type == ElfRelType_rela){
relocations.append(new RelocationAddend64(getFilePointer() + (i * Size__64_bit_Relocation_Addend), i));
} else if (!elfFile->is64Bit() && type == ElfRelType_rel){
relocations.append(new Relocation32(getFilePointer() + (i * Size__32_bit_Relocation), i));
} else if (!elfFile->is64Bit() && type == ElfRelType_rela){
relocations.append(new RelocationAddend32(getFilePointer() + (i * Size__32_bit_Relocation_Addend), i));
} else {
PRINT_ERROR("Relocation type %d is invalid", type);
}
relocations[i]->read(binaryInputFile);
}
ASSERT(relocations.size() == numberOfRelocations);
verify();
return sizeInBytes;
}
void
mm_write_cache_io_c::setFilePointer(int64 offset,
seek_mode mode) {
int64_t new_pos
= seek_beginning == mode ? offset
: seek_end == mode ? get_size() - offset
: getFilePointer() + offset;
if (new_pos == static_cast<int64_t>(getFilePointer()))
return;
flush_cache();
mm_proxy_io_c::setFilePointer(offset, mode);
}
void
mm_io_c::save_pos(int64_t new_pos) {
m_positions.push(getFilePointer());
if (-1 != new_pos)
setFilePointer(new_pos);
}
void UncompressedStream::write(void* ptr, size_t size) {
size_t result = fwrite(ptr, 1, size, getFilePointer());
if (result != size)
throw BagIOException((format("Error writing to file: writing %1% bytes, wrote %2% bytes") % size % result).str());
advanceOffset(size);
}
void UncompressedStream::read(void* ptr, size_t size) {
size_t nUnused = (size_t) getUnusedLength();
char* unused = getUnused();
if (nUnused > 0) {
// We have unused data from the last compressed read
if (nUnused == size) {
// Copy the unused data into the buffer
memcpy(ptr, unused, nUnused);
clearUnused();
}
else if (nUnused < size) {
// Copy the unused data into the buffer
memcpy(ptr, unused, nUnused);
// Still have data to read
size -= nUnused;
// Read the remaining data from the file
int result = fread((char*) ptr + nUnused, 1, size, getFilePointer());
if ((size_t) result != size)
throw BagIOException((format("Error reading from file + unused: wanted %1% bytes, read %2% bytes") % size % result).str());
advanceOffset(size);
clearUnused();
}
else {
// nUnused_ > size
memcpy(ptr, unused, size);
setUnused(unused + size);
setUnusedLength(nUnused - size);
}
}
// No unused data - read from stream
int result = fread(ptr, 1, size, getFilePointer());
if ((size_t) result != size)
throw BagIOException((format("Error reading from file: wanted %1% bytes, read %2% bytes") % size % result).str());
advanceOffset(size);
}
uint32_t SymbolTable::read(BinaryInputFile* binaryInputFile){
binaryInputFile->setInPointer(getFilePointer());
setFileOffset(binaryInputFile->currentOffset());
uint32_t totalBytesRead = 0;
uint32_t numberOfSymbols = sizeInBytes / symbolSize;
for (uint32_t i = 0; i < numberOfSymbols; i++){
if (elfFile->is64Bit()){
symbols.append(new Symbol64(this, getFilePointer() + (i * Size__64_bit_Symbol), i));
} else {
symbols.append(new Symbol32(this, getFilePointer() + (i * Size__32_bit_Symbol), i));
}
totalBytesRead += symbols[i]->read(binaryInputFile);
}
ASSERT(sizeInBytes == totalBytesRead && "size read from file does not match theorietical size of Symbol Table");
return sizeInBytes;
}
int64_t
mm_io_c::get_size() {
if (-1 == m_cached_size) {
save_pos();
setFilePointer(0, seek_end);
m_cached_size = getFilePointer();
restore_pos();
}
return m_cached_size;
}
void
mm_write_buffer_io_c::setFilePointer(int64 offset,
seek_mode mode) {
int64_t new_pos
= seek_beginning == mode ? offset
: seek_end == mode ? m_proxy_io->get_size() - offset
: getFilePointer() + offset;
if (new_pos == static_cast<int64_t>(getFilePointer()))
return;
flush_buffer();
if (m_debug_seek) {
int64_t previous_pos = mm_proxy_io_c::getFilePointer();
mxdebug(boost::format("seek from %1% to %2% diff %3%\n") % previous_pos % new_pos % (new_pos - previous_pos));
}
mm_proxy_io_c::setFilePointer(offset, mode);
}
void BZ2Stream::startRead() {
bzfile_ = BZ2_bzReadOpen(&bzerror_, getFilePointer(), verbosity_, 0, getUnused(), getUnusedLength());
switch (bzerror_) {
case BZ_OK: break;
default: {
BZ2_bzReadClose(&bzerror_, bzfile_);
throw BagException("Error opening file for reading compressed stream");
}
}
clearUnused();
}
void BZ2Stream::startWrite() {
bzfile_ = BZ2_bzWriteOpen(&bzerror_, getFilePointer(), block_size_100k_, verbosity_, work_factor_);
switch (bzerror_) {
case BZ_OK: break;
default: {
BZ2_bzWriteClose(&bzerror_, bzfile_, 0, NULL, NULL);
throw BagException("Error opening file for writing compressed stream");
}
}
setCompressedIn(0);
}
void BufferedIndexInput::readBytes(uint8_t* b, const int32_t len){
if (len < bufferSize) {
for (int32_t i = 0; i < len; ++i) // read byte-by-byte
b[i] = readByte();
} else { // read all-at-once
int64_t start = getFilePointer();
seekInternal(start);
readInternal(b, len);
bufferStart = start + len; // adjust stream variables
bufferPosition = 0;
bufferLength = 0; // trigger refill() on read
}
}
void RawSection::dump(BinaryOutputFile* binaryOutputFile, uint32_t offset){
if (getType() != PebilClassType_RawSection && getType() != PebilClassType_no_type &&
getType() != PebilClassType_DwarfSection && getType() != PebilClassType_DwarfLineInfoSection){
PRINT_ERROR("You should implement the dump function for class type %d", getType());
}
if (getSectionHeader()->hasBitsInFile() && getSizeInBytes()){
char* sectionOutput = getFilePointer();
binaryOutputFile->copyBytes(sectionOutput, getSizeInBytes(), offset);
for (uint32_t i = 0; i < dataReferences.size(); i++){
dataReferences[i]->dump(binaryOutputFile,offset);
}
}
}
/**
* 读多个字节
*/
void CIndexInput::readBytes(byte* b,size_t len)
{
if (len < m_bufferSize)
{
for (size_t i = 0; i < len; i++)
// read byte-by-byte
b[i] = (byte) readByte();
}
else
{
// read all-at-once
int64_t start = getFilePointer();
seekInternal(start);
readInternal((char*)b,len);
m_bufferStart = start + len; // adjust stream variables
m_bufferPosition = 0;
m_bufferLength = 0; // trigger refill() on read
}
}
/* The main function for running the ECG program. */
int runECG() {
openFile();
//printf("Peak nr. Line R peak\n");
buffered_filtered_data = makeBuffer(SIZE_FILTERED_DATA);
buffered_raw_data = makeBuffer(SIZE_RAW_DATA);
buffered_LP_data = makeBuffer(SIZE_LP_DATA);
buffered_HP_data = makeBuffer(SIZE_HP_DATA);
buffered_derivative_square_data = makeBuffer(SIZE_DERIVATIVESQUARE_DATA);
buffered_peak_lines = makeBuffer(SIZE_PEAKS);
initQRS();
while (getFilePointer() != EOF) {
insert(&buffered_filtered_data, filter());
detectPeaks();
line++;
}
freeBuffers(&buffered_raw_data, &buffered_LP_data, &buffered_HP_data,
&buffered_derivative_square_data, &buffered_filtered_data,
&buffered_peak_lines);
return 0;
}
struct File *readFile(char* params){
char** pointer;
int len = getFilePointer(params,pointer);
struct File *file;
file = (struct File*)malloc(sizeof(struct File));
file->filename = (char*)malloc(strLen(params));
memCopy(params,file->filename,strLen(params));
file->filesize = len;
int i;
struct StringListNode *line = (struct StringListNode*) malloc(sizeof(struct StringListNode));
file->firstLine = line;
line->prev = 0;
line->next = 0;
int lineStart = 0;
// split the file into separate lines
for(i = 0; i < len; i++){
if((*pointer)[i] == '\n' || i == len-1){
line->str = (char*) malloc(i-lineStart+2);
memCopy((*pointer+lineStart), line->str, i-lineStart+1);
(line->str)[i-lineStart+1] = 0;
//set up the next line
struct StringListNode *tline;
tline = (struct StringListNode*) malloc(sizeof(struct StringListNode));
tline->prev = line;
line->next = tline;
line = tline;
lineStart = i+1;
}
if(i == len-1){
//nix the next line, since there isn't one
line = line->prev;
free(line->next, sizeof(struct StringListNode));
line->next = 0;
}
}
return file;
}
void MultiFileReader::setBufferPointer()
{
m_llBufferPointer = getFilePointer();
}
