CPLErr NTFFileReader::ReadRasterColumn( int iColumn, float *pafElev )
{
/* -------------------------------------------------------------------- */
/* If we don't already have the scanline offset of the previous */
/* line, force reading of previous records to establish it. */
/* -------------------------------------------------------------------- */
if( panColumnOffset[iColumn] == 0 )
{
int iPrev;
for( iPrev = 0; iPrev < iColumn-1; iPrev++ )
{
if( panColumnOffset[iPrev+1] == 0 )
{
CPLErr eErr;
eErr = ReadRasterColumn( iPrev, NULL );
if( eErr != CE_None )
return eErr;
}
}
}
/* -------------------------------------------------------------------- */
/* If the dataset isn't open, open it now. */
/* -------------------------------------------------------------------- */
if( GetFP() == NULL )
Open();
/* -------------------------------------------------------------------- */
/* Read requested record. */
/* -------------------------------------------------------------------- */
NTFRecord *poRecord;
SetFPPos( panColumnOffset[iColumn], iColumn );
poRecord = ReadRecord();
if( iColumn < nRasterXSize-1 )
{
GetFPPos( panColumnOffset+iColumn+1, NULL );
}
/* -------------------------------------------------------------------- */
/* Handle LANDRANGER DTM columns. */
/* -------------------------------------------------------------------- */
if( pafElev != NULL && GetProductId() == NPC_LANDRANGER_DTM )
{
double dfVScale, dfVOffset;
dfVOffset = atoi(poRecord->GetField(56,65));
dfVScale = atoi(poRecord->GetField(66,75)) * 0.001;
for( int iPixel = 0; iPixel < nRasterXSize; iPixel++ )
{
pafElev[iPixel] = (float) (dfVOffset + dfVScale *
atoi(poRecord->GetField(84+iPixel*4,87+iPixel*4)));
}
}
/* -------------------------------------------------------------------- */
/* Handle PROFILE */
/* -------------------------------------------------------------------- */
else if( pafElev != NULL && GetProductId() == NPC_LANDFORM_PROFILE_DTM )
{
for( int iPixel = 0; iPixel < nRasterXSize; iPixel++ )
{
pafElev[iPixel] = (float)
(atoi(poRecord->GetField(19+iPixel*5,23+iPixel*5)) * GetZMult());
}
}
delete poRecord;
return CE_None;
}
enumError WriteZeroWDF ( SuperFile_t * sf, off_t off, size_t count )
{
ASSERT(sf);
ASSERT(sf->wc);
TRACE("#W# -----\n");
TRACE(TRACE_RDWR_FORMAT, "#W# WriteZeroWDF()",
GetFD(&sf->f), GetFP(&sf->f), (u64)off, (u64)off+count, count,
off < sf->max_virt_off ? " <" : "" );
TRACE(" - off = %llx,%llx,%llx\n",
(u64)sf->f.file_off, (u64)sf->f.max_off, (u64)sf->max_virt_off);
if (!count)
return ERR_OK;
// adjust the file size
const off_t data_end = off + count;
if ( sf->file_size < data_end )
sf->file_size = data_end;
ASSERT( sf->wc_used > 0 );
const int used_m1 = sf->wc_used - 1;
if ( off >= sf->max_virt_off )
return ERR_OK;
// search chunk header with a binary search
WDF_Chunk_t * wc = sf->wc;
int beg = 0, end = used_m1;
ASSERT( beg <= end );
while ( beg < end )
{
int idx = (beg+end)/2;
wc = sf->wc + idx;
if ( off < wc->file_pos )
end = idx-1;
else if ( idx < used_m1 && off >= wc[1].file_pos )
beg = idx + 1;
else
beg = end = idx;
}
wc = sf->wc + beg;
TRACE("#W# - FOUND #%03d: off=%09llx ds=%llx, off=%09llx\n",
beg, wc->file_pos, wc->data_size, (u64)off );
ASSERT( off >= wc->file_pos );
ASSERT( beg == used_m1 || off < wc[1].file_pos );
WDF_Chunk_t * last_wc = sf->wc + sf->wc_used;
for ( ; wc < last_wc || wc->file_pos < data_end; wc++ )
{
off_t end = wc->file_pos + wc->data_size;
TRACE("loop: wc=%llx,%llx,%llx off=%llx, end=%llx\n",
wc->file_pos, wc->data_off, wc->data_size, (u64)off, (u64)end );
if ( off >= end )
continue;
if ( off < wc->file_pos )
off = wc->file_pos;
if ( end > data_end )
end = data_end;
if ( off < end )
{
const enumError err
= WriteZeroAtF( &sf->f, wc->data_off+(off-wc->file_pos), end-off );
if (err)
return err;
}
}
return ERR_OK;
}
enumError ReadWDF ( SuperFile_t * sf, off_t off, void * buf, size_t count )
{
ASSERT(sf);
ASSERT(sf->wc);
ASSERT(sf->wc_used);
TRACE("#W# -----\n");
TRACE(TRACE_RDWR_FORMAT, "#W# ReadWDF()",
GetFD(&sf->f), GetFP(&sf->f), (u64)off, (u64)off+count, count, "" );
if ( off + count > sf->wh.file_size )
{
if (!sf->f.read_behind_eof)
{
if ( !sf->f.disable_errors )
ERROR0( ERR_READ_FAILED, "Read behind eof [%c,%llx+%zx]: %s\n",
sf->f.fp ? 'S' : sf->f.fd != -1 ? 'F' : '-',
(u64)off, count, sf->f.fname );
return ERR_READ_FAILED;
}
const off_t max_read = sf->wh.file_size > off
? sf->wh.file_size - off
: 0;
ASSERT( count > max_read );
if ( sf->f.read_behind_eof == 1 )
{
sf->f.read_behind_eof = 2;
if ( !sf->f.disable_errors )
ERROR0( ERR_WARNING, "Read behind eof -> zero filled [%c,%llx+%zx]: %s\n",
sf->f.fp ? 'S' : sf->f.fd != -1 ? 'F' : '-',
(u64)off, count, sf->f.fname );
}
size_t fill_count = count - (size_t)max_read;
count = (size_t)max_read;
memset((char*)buf+count,0,fill_count);
if (!count)
return ERR_OK;
}
// find chunk header
WDF_Chunk_t * wc = sf->wc;
const int used_m1 = sf->wc_used - 1;
int beg = 0, end = used_m1;
ASSERT( beg <= end );
while ( beg < end )
{
int idx = (beg+end)/2;
wc = sf->wc + idx;
if ( off < wc->file_pos )
end = idx-1;
else if ( idx < used_m1 && off >= wc[1].file_pos )
beg = idx + 1;
else
beg = end = idx;
}
wc = sf->wc + beg;
noTRACE("#W# - FOUND #%03d: off=%09llx ds=%llx, off=%09llx\n",
beg, wc->file_pos, wc->data_size, (u64)off );
ASSERT( off >= wc->file_pos );
ASSERT( beg == used_m1 || off < wc[1].file_pos );
char * dest = buf;
while ( count > 0 )
{
noTRACE("#W# %d/%d count=%zd off=%llx,%llx \n",
beg, sf->wc_used, count, (u64)off, (u64)wc->file_pos );
if ( off < wc->file_pos )
{
const u64 max_size = wc->file_pos - off;
const u32 fill_size = max_size < count ? (u32)max_size : count;
TRACE("#W# >FILL %p +%8zx = %p .. %x\n",
buf, dest-(ccp)buf, dest, fill_size );
memset(dest,0,fill_size);
count -= fill_size;
off += fill_size;
dest += fill_size;
if (!count)
break;
}
if ( off >= wc->file_pos && off < wc->file_pos + wc->data_size )
{
// we want a part of this
const u64 delta = off - wc->file_pos;
const u64 max_size = wc->data_size - delta;
const u32 read_size = max_size < count ? (u32)max_size : count;
TRACE("#W# >READ %p +%8zx = %p .. %x <- %10llx\n",
buf, dest-(ccp)buf, dest, read_size, wc->data_off+delta );
int stat = ReadAtF(&sf->f,wc->data_off+delta,dest,read_size);
if (stat)
return stat;
count -= read_size;
off += read_size;
dest += read_size;
if (!count)
break;
}
wc++;
if ( ++beg >= sf->wc_used )
{
TRACE("ERR_WDF_INVALID\n");
return ERR_WDF_INVALID;
}
}
TRACE("#W# - done, dest = %p\n",dest);
return ERR_OK;
}
enumError WriteWDF ( SuperFile_t * sf, off_t off, const void * buf, size_t count )
{
ASSERT(sf);
ASSERT(sf->wc);
TRACE("#W# -----\n");
TRACE(TRACE_RDWR_FORMAT, "#W# WriteWDF()",
GetFD(&sf->f), GetFP(&sf->f), (u64)off, (u64)off+count, count,
off < sf->max_virt_off ? " <" : "" );
TRACE(" - off = %llx,%llx, fs = %llx\n",
(u64)sf->f.file_off, (u64)sf->f.max_off, (u64)sf->file_size );
if (!count)
return ERR_OK;
// adjust the file size
const off_t data_end = off + count;
if ( sf->file_size < data_end )
sf->file_size = data_end;
ASSERT( sf->wc_used > 0 );
const int used_m1 = sf->wc_used - 1;
if ( off >= sf->max_virt_off )
{
// SPECIAL CASE:
// the current virtual file will be extended
// -> no need to search chunks
if ( off <= sf->max_virt_off + WDF_MIN_HOLE_SIZE )
{
// maybe an extend of the last chunk -> get the last chunk
WDF_Chunk_t * wc = sf->wc + used_m1;
if ( wc->data_off + wc->data_size == sf->f.max_off )
{
// yes, it is the last written chunk
const u32 skip = off - sf->max_virt_off;
// adjust max_virt_off
sf->max_virt_off = off + count;
const enumError err
= WriteAtF(&sf->f,skip+wc->data_off+wc->data_size,buf,count);
wc->data_size += skip + count;
return err;
}
}
// adjust max_virt_off
sf->max_virt_off = off + count;
// create a new chunk at end of file
WDF_Chunk_t * wc = NeedChunkWDF(sf,sf->wc_used);
wc->file_pos = off;
wc->data_off = sf->f.max_off;
wc->data_size = count;
return WriteAtF(&sf->f,wc->data_off,buf,count);
}
// search chunk header with a binary search
WDF_Chunk_t * wc = sf->wc;
int beg = 0, end = used_m1;
ASSERT( beg <= end );
while ( beg < end )
{
int idx = (beg+end)/2;
wc = sf->wc + idx;
if ( off < wc->file_pos )
end = idx-1;
else if ( idx < used_m1 && off >= wc[1].file_pos )
beg = idx + 1;
else
beg = end = idx;
}
wc = sf->wc + beg;
TRACE("#W# - FOUND #%03d: off=%09llx ds=%llx, off=%09llx\n",
beg, wc->file_pos, wc->data_size, (u64)off );
ASSERT( off >= wc->file_pos );
ASSERT( beg == used_m1 || off < wc[1].file_pos );
ccp src = buf;
while ( count > 0 )
{
TRACE("#W# %d/%d count=%zd off=%llx,%llx \n",
beg, sf->wc_used, count, (u64)off, wc->file_pos );
if ( off < wc->file_pos )
{
const u64 max_size = wc->file_pos - off;
const u32 wr_size = max_size < count ? (u32)max_size : count;
TRACE("#W# >CREATE#%02d %p +%8zx = %10llx .. +%4x\n",
beg, buf, src-(ccp)buf, (u64)off, wr_size );
// create a new chunk
wc = NeedChunkWDF(sf,beg);
wc->file_pos = off;
wc->data_off = sf->f.max_off;
wc->data_size = wr_size;
// write data & return
const enumError stat = WriteAtF(&sf->f,wc->data_off,src,wr_size);
if (stat)
return stat;
wc++;
beg++;
count -= wr_size;
off += wr_size;
src += wr_size;
if (!count)
break;
}
if ( off >= wc->file_pos && off < wc->file_pos + wc->data_size )
{
// we want a part of this
const u64 delta = off - wc->file_pos;
const u64 max_size = wc->data_size - delta;
const u32 wr_size = max_size < count ? (u32)max_size : count;
TRACE("#W# >OVERWRITE#%02d %p +%8zx = %10llx .. +%4x, delta=%lld\n",
beg, buf, src-(ccp)buf, (u64)off, wr_size, delta );
const enumError stat = WriteAtF(&sf->f,wc->data_off+delta,src,wr_size);
if (stat)
return stat;
count -= wr_size;
off += wr_size;
src += wr_size;
if (!count)
break;
}
wc++;
if ( ++beg >= sf->wc_used )
return WriteWDF(sf,off,src,count);
}
return ERR_OK;
}
bool RegistersDebuggerCommand::WriteReg(UINT iReg,
CONTEXT *pContext,
DebuggerShell *shell,
ICorDebugRegisterSet *pIRS)
{
WCHAR wszTemp[30];
_ASSERTE( pContext != NULL );
_ASSERTE(sizeof (double) == sizeof (CORDB_REGISTER));
_ASSERTE(m_nBase == 16 || m_nBase == 10);
#define WRITE_REG(_shell, _val, _name, _tmp, _base) \
(_shell)->Write(L"%s = %08s", (_name), _ui64tow((_val), (_tmp), (_base)));
switch( iReg )
{
case REGISTER_INSTRUCTION_POINTER:
WRITE_REG(shell, (ULONG)GetIP(pContext), g_RegNames[iReg], wszTemp, m_nBase);
break;
case REGISTER_STACK_POINTER:
WRITE_REG(shell, (ULONG)GetSP(pContext), g_RegNames[iReg], wszTemp, m_nBase);
break;
case REGISTER_FRAME_POINTER:
WRITE_REG(shell, (ULONG)GetFP(pContext), g_RegNames[iReg], wszTemp, m_nBase);
break;
case REGISTER_X86_EAX:
WRITE_REG(shell, pContext->Eax, g_RegNames[iReg], wszTemp, m_nBase);
break;
case REGISTER_X86_EBX:
WRITE_REG(shell, pContext->Ebx, g_RegNames[iReg], wszTemp, m_nBase);
break;
case REGISTER_X86_ECX:
WRITE_REG(shell, pContext->Ecx, g_RegNames[iReg], wszTemp, m_nBase);
break;
case REGISTER_X86_EDX:
WRITE_REG(shell, pContext->Edx, g_RegNames[iReg], wszTemp, m_nBase);
break;
case REGISTER_X86_ESI:
WRITE_REG(shell, pContext->Esi, g_RegNames[iReg], wszTemp, m_nBase);
break;
case REGISTER_X86_EDI:
WRITE_REG(shell, pContext->Edi, g_RegNames[iReg], wszTemp, m_nBase);
break;
case REGISTER_X86_FPSTACK_0:
case REGISTER_X86_FPSTACK_1:
case REGISTER_X86_FPSTACK_2:
case REGISTER_X86_FPSTACK_3:
case REGISTER_X86_FPSTACK_4:
case REGISTER_X86_FPSTACK_5:
case REGISTER_X86_FPSTACK_6:
case REGISTER_X86_FPSTACK_7:
{
shell->Write(L"%s = n/a ", g_RegNames[iReg]);
break;
}
case REGISTER_X86_EFL:
{
WRITE_SPECIAL_REGISTER( shell, pContext, CONTEXT_SEGMENTS, EFL, EFlags, m_nBase, wszTemp )
break;
}
case REGISTER_X86_CS:
{
WRITE_SPECIAL_REGISTER( shell, pContext, CONTEXT_SEGMENTS, CS, SegCs, m_nBase, wszTemp )
break;
}
case REGISTER_X86_EFLAGS_CY:
{
WRITE_SPECIAL_BIT_REGISTER( shell, pContext, CONTEXT_CONTROL, CY, CY )
break;
}
case REGISTER_X86_EFLAGS_PE:
{
WRITE_SPECIAL_BIT_REGISTER( shell, pContext, CONTEXT_CONTROL, PE, PE )
break;
}
case REGISTER_X86_EFLAGS_AC:
{
WRITE_SPECIAL_BIT_REGISTER( shell, pContext, CONTEXT_CONTROL, AC, AC )
break;
}
case REGISTER_X86_EFLAGS_ZR:
{
WRITE_SPECIAL_BIT_REGISTER( shell, pContext, CONTEXT_CONTROL, ZR, ZR )
break;
}
case REGISTER_X86_EFLAGS_PL:
{
WRITE_SPECIAL_BIT_REGISTER( shell, pContext, CONTEXT_CONTROL, PL, PL)
break;
}
case REGISTER_X86_EFLAGS_EI:
{
WRITE_SPECIAL_BIT_REGISTER( shell, pContext, CONTEXT_CONTROL, EI, EI )
break;
}
case REGISTER_X86_EFLAGS_UP:
{
WRITE_SPECIAL_BIT_REGISTER( shell, pContext, CONTEXT_CONTROL, UP, UP )
break;
}
case REGISTER_X86_EFLAGS_OV:
{
WRITE_SPECIAL_BIT_REGISTER( shell, pContext, CONTEXT_CONTROL, OV, OV )
break;
}
default:
{
return false;
}
}
return true;
}
