bool
ThunkBuilder::buildIL()
{
TR::IlType *pWord = typeDictionary()->PointerTo(Word);
uint32_t numArgs = _numCalleeParams+1;
TR::IlValue **args = (TR::IlValue **) comp()->trMemory()->allocateHeapMemory(numArgs * sizeof(TR::IlValue *));
// first argument is the target address
args[0] = Load("target");
// followed by the actual arguments
for (uint32_t p=0; p < _numCalleeParams; p++)
{
uint32_t a=p+1;
args[a] = ConvertTo(_calleeParamTypes[p],
LoadAt(pWord,
IndexAt(pWord,
Load("args"),
ConstInt32(p))));
}
TR::IlValue *retValue = ComputedCall("thunkCallee", numArgs, args);
if (getReturnType() != NoType)
Return(retValue);
Return();
return true;
}
bool CGuid::ConvertTo(CString& csGuid)
{
// replacement for StringFromGUID2
ConvertTo();
csGuid = m_Buffer;
return true;
}
bool CGuid::ConvertTo(CComBSTR& bstrGuid)
{
// replacement for StringFromGUID2
ConvertTo();
bstrGuid = m_Buffer;
return true;
}
void DoShift( void )
{
stack_entry *left;
int shift;
left = StkEntry( 1 );
RValue( ExprSP );
ConvertTo( ExprSP, TK_INTEGER, TM_SIGNED, 0 );
shift = I32FetchTrunc( ExprSP->v.sint );
RValue( left );
switch( left->info.kind ) {
case TK_BOOL:
case TK_ENUM:
case TK_CHAR:
case TK_INTEGER:
if( shift >= 0 ) {
U64ShiftL( &left->v.uint, shift, &left->v.uint );
} else if( (left->info.modifier & TM_MOD_MASK) == TM_UNSIGNED ) {
U64ShiftR( &left->v.uint, -shift, &left->v.uint );
} else {
I64ShiftR( &left->v.sint, -shift, &left->v.sint );
}
break;
default:
Error( ERR_NONE, LIT_ENG( ERR_ILL_TYPE ) );
break;
}
CombineEntries( left, left, ExprSP );
}
void
ADIOSFileObject::GetTimes(std::string &varNm, std::vector<double> ×)
{
Open();
times.resize(0);
varIter vi = variables.find(varNm);
if (vi == variables.end())
{
debug5<<"Variable "<<varNm<<" not found."<<endl;
return;
}
ADIOSVar v = vi->second;
int tupleSz = adios_type_size(v.type, NULL);
uint64_t start[4] = {0,0,0,0}, count[4] = {0,0,0,0};
count[0] = v.count[0];
int ntuples = v.count[0];
void *readData = malloc(ntuples*tupleSz);
OpenGroup(v.groupIdx);
uint64_t retval = adios_read_var_byid(gps[v.groupIdx], v.varid, start, count, readData);
CloseGroup(v.groupIdx);
if (retval > 0)
{
times.resize(ntuples);
ConvertTo(×[0], ntuples, v.type, readData);
}
free(readData);
}
static void DoBinOp( stack_entry *left, stack_entry *right )
{
conv_class lclass;
conv_class rclass;
conv_class result_class;
type_info *result_info;
bool promote_left;
lclass = ConvIdx( &left->info );
rclass = ConvIdx( &right->info );
if( lclass == ERR || rclass == ERR ) {
Error( ERR_NONE, LIT( ERR_ILL_TYPE ) );
}
result_class = BinResult[ lclass ][ rclass ];
if( result_class == ERR ) {
Error( ERR_NONE, LIT( ERR_TYPE_CONVERSION ) );
}
if( left->info.kind == TK_ENUM ) {
result_info = &left->info;
} else if( right->info.kind == TK_ENUM ) {
result_info = &right->info;
} else {
result_info = &ResultInfo[ result_class ];
}
promote_left = FALSE;
if( lclass != result_class ) {
promote_left = TRUE;
ConvertTo( left, result_info->kind,
result_info->modifier, result_info->size );
}
if( rclass != result_class ) {
ConvertTo( right, result_info->kind,
result_info->modifier, result_info->size );
}
/* set up result type in left operand */
if( left->th != NULL && right->th != NULL ) {
/* if left side was promoted, use right's type. otherwise use left's */
if( promote_left ) {
MoveTH( right, left );
}
} else if( right->th != NULL ) {
MoveTH( right, left );
/* else use left->type */
}
}
unsigned_64 ReqU64Expr( void )
{
unsigned_64 rtn;
NormalExpr();
ConvertTo( ExprSP, TK_INTEGER, TM_UNSIGNED, sizeof( ExprSP->v.uint ) );
rtn = ExprSP->v.uint;
PopEntry();
return( rtn );
}
xreal ReqXRealExpr( void )
{
xreal v;
NormalExpr();
ConvertTo( ExprSP, TK_REAL, TM_NONE, sizeof( ExprSP->v.real ) );
v = ExprSP->v.real;
PopEntry();
return( v );
}
double TimerBase::ElapsedTimeAsDouble()
{
if (m_stuckAtZero)
return 0;
else if (m_started)
return ConvertTo(GetCurrentTimerValue() - m_start, m_timerUnit);
else
{
StartTimer();
return 0;
}
}
unsigned long Timer::ElapsedTime()
{
if (m_stuckAtZero)
return 0;
else if (m_started)
return ConvertTo(GetCurrentTimerValue() - m_start, m_timerUnit);
else
{
StartTimer();
return 0;
}
}
void ToItemMAD( stack_entry *entry, item_mach *tmp, mad_type_info *mti )
{
unsigned bytes;
mad_type_info src;
bytes = mti->b.bits / BITS_PER_BYTE;
switch( mti->b.kind ) {
case MTK_INTEGER:
ConvertTo( entry, TK_INTEGER, TM_UNSIGNED, bytes );
MADTypeInfoForHost( MTK_INTEGER, sizeof( entry->v.uint ), &src );
break;
case MTK_ADDRESS:
if( mti->a.seg.bits == 0 ) {
ConvertTo( entry, TK_ADDRESS, TM_NEAR, bytes );
MADTypeInfoForHost( MTK_ADDRESS, sizeof( entry->v.addr.mach.offset ), &src );
} else {
ConvertTo( entry, TK_ADDRESS, TM_FAR, bytes );
MADTypeInfoForHost( MTK_ADDRESS, sizeof( entry->v.addr.mach ), &src );
}
break;
case MTK_FLOAT:
ConvertTo( entry, TK_REAL, TM_NONE, bytes );
MADTypeInfoForHost( MTK_FLOAT, sizeof( entry->v.real ), &src );
break;
case MTK_XMM:
//MAD: nyi
ToItem( entry, tmp );
return;
case MTK_CUSTOM:
//MAD: nyi
ToItem( entry, tmp );
return;
}
if( MADTypeConvert( &src, &entry->v, mti, tmp, 0 ) != MS_OK ) {
ToItem( entry, tmp );
}
}
double TimerBase::ElapsedTimeAsDouble()
{
if (m_stuckAtZero)
return 0;
if (m_started)
{
TimerWord now = GetCurrentTimerValue();
if (m_last < now) // protect against OS bugs where time goes backwards
m_last = now;
return ConvertTo(m_last - m_start, m_timerUnit);
}
StartTimer();
return 0;
}
bool
ADIOSFileObject::ReadVariable(const std::string &nm,
int ts,
vtkFloatArray **array)
{
debug5<<"ADIOSFileObject::ReadVariable("<<nm<<" time= "<<ts<<")"<<endl;
Open();
varIter vi = variables.find(nm);
if (vi == variables.end())
{
debug5<<"Variable "<<nm<<" not found."<<endl;
return false;
}
ADIOSVar v = vi->second;
int tupleSz = adios_type_size(v.type, NULL);
*array = vtkFloatArray::New();
int ntuples = 1;
uint64_t start[4] = {0,0,0,0}, count[4] = {0,0,0,0};
v.GetReadArrays(ts, start, count, &ntuples);
(*array)->SetNumberOfTuples(ntuples);
float *data = (float *)(*array)->GetVoidPointer(0);
void *readData = (void *)data;
bool convertData = (v.type != adios_real);
if (convertData)
readData = malloc(ntuples*tupleSz);
debug5<<"ARR: adios_read_var:"<<endl<<v<<endl;
OpenGroup(v.groupIdx);
uint64_t retval = adios_read_var_byid(gps[v.groupIdx], v.varid, start, count, readData);
CloseGroup(v.groupIdx);
if (convertData)
{
if (retval > 0)
ConvertTo(data, ntuples, v.type, readData);
free(readData);
}
return (retval > 0);
}
CGuid::operator CComBSTR()
{
CComBSTR bstrGuid;
ConvertTo(bstrGuid);
return bstrGuid;
}
//----------------------------------------------------------------------------------------
bool OldDataRemapTable::Build(const std::wstring& bitMaskString, unsigned int sourceBitCount, bool specifyConversionTableState, bool auseConversionTableTo, bool auseConversionTableFrom)
{
//Convert bitMaskString to a binary value and load into bitMask
StringToIntBase2(bitMaskString, bitMask);
bitCountOriginal = sourceBitCount;
//Build properties about the bitmask
bitCountConverted = 0;
discardBottomBitCount = 0;
discardTopBitCount = 0;
bool foundFirstSetBit = false;
unsigned int bitMaskCopy = bitMask;
for(unsigned int i = 0; i < sourceBitCount; ++i)
{
bool bit = (bitMaskCopy & 0x01) != 0;
if(bit)
{
discardTopBitCount = 0;
++bitCountConverted;
foundFirstSetBit = true;
}
else
{
if(!foundFirstSetBit)
{
++discardBottomBitCount;
}
else
{
++discardTopBitCount;
}
}
bitMaskCopy >>= 1;
}
//Determine whether to use physical conversion tables
if(specifyConversionTableState)
{
useConversionTableFrom = auseConversionTableFrom;
useConversionTableTo = auseConversionTableTo;
}
else
{
//##FIX## Take out these magic numbers. The caller should have some say in what
//these limits should be. Provide a way for the caller to be able to specify
//memory usage maximums, or conversion table bitcount limits, and use those saved
//limits here. We can use these magic numbers as defaults for the limits.
useConversionTableTo = ((bitCountOriginal - (discardBottomBitCount + discardTopBitCount)) <= 20);
useConversionTableFrom = (bitCountConverted <= 20);
}
//Build the physical conversion tables
if(useConversionTableTo)
{
useConversionTableTo = false;
conversionTableToSize = (1 << (bitCountOriginal - (discardBottomBitCount + discardTopBitCount)));
conversionTableTo.resize(conversionTableToSize, 0);
unsigned int nextNumber = 0;
for(unsigned int i = 0; i < conversionTableToSize; ++i)
{
conversionTableTo[i] = ConvertTo(nextNumber);
nextNumber += (1 << discardBottomBitCount);
}
useConversionTableTo = true;
}
if(useConversionTableFrom)
{
useConversionTableFrom = false;
conversionTableFromSize = (1 << bitCountConverted);
conversionTableFrom.resize(conversionTableFromSize, 0);
for(unsigned int i = 0; i < conversionTableFromSize; ++i)
{
conversionTableFrom[i] = ConvertFrom(i);
}
useConversionTableFrom = true;
}
return true;
}
void
SweepTree::MakeNew(Shape *iSrc, int iBord, int iWeight, int iStartPoint)
{
AVLTree::MakeNew();
ConvertTo(iSrc, iBord, iWeight, iStartPoint);
}
static unsigned MechMisc( unsigned select, unsigned parm )
{
long value;
unsigned result = 0;
mad_type_info mti;
switch( select ) {
case 0:
ExprAddrDepth += parm;
result = ExprAddrDepth;
break;
case 1:
if( _IsOn( SW_EXPR_IS_CALL ) && ExprAddrDepth == 0 ) {
result = TRUE;
} else {
result = FALSE;
}
break;
case 2:
SkipCount += parm;
break;
case 3:
result = SkipCount;
break;
case 4:
//never called
break;
case 5:
if( ScanSavePtr >= MAX_SCANSAVE_PTRS )
Error( ERR_INTERNAL, LIT( ERR_TOO_MANY_SCANSAVE ) );
CurrScan[ScanSavePtr++] = ScanPos();
break;
case 6:
if( ScanSavePtr <= 0 ) Error( ERR_INTERNAL, LIT( ERR_TOO_MANY_SCANRESTORE ) );
ReScan( CurrScan[--ScanSavePtr] );
break;
case 7:
if( ScanSavePtr <= 0 ) Error( ERR_INTERNAL, LIT( ERR_TOO_MANY_SCANRESTORE ) );
--ScanSavePtr;
break;
case 8:
if( parm ) { /* start scan string */
scan_string = TRUE;
ReScan( ScanPos() );
} else { /* end scan string */
scan_string = FALSE;
ReScan( ScanPos() );
}
break;
case 9:
ReScan( ScanPos() + (int)parm );
break;
case 10:
AddChar();
break;
case 11:
AddCEscapeChar();
break;
case 12:
AddActualChar( '\0' );
break;
case 13:
ScanCCharNum = parm;
break;
case 14:
if( NestedCallLevel == MAX_NESTED_CALL - 1 ) {
Error( ERR_NONE, LIT( ERR_TOO_MANY_CALLS ) );
} else {
PgmStackUsage[ ++NestedCallLevel ] = 0;
}
break;
case 15:
RValue( ExprSP );
ConvertTo( ExprSP, TK_INTEGER, TM_SIGNED, 4 );
value = U32FetchTrunc( ExprSP->v.uint ) - 1;
PopEntry();
if( ExprSP->info.kind == TK_STRING ) {
if( value < 0 || value >= ExprSP->info.size ) {
Error( ERR_NONE, LIT( ERR_BAD_SUBSTRING_INDEX ) );
}
LocationAdd( &ExprSP->v.string.loc, value*8 );
ExprSP->info.size -= value;
ExprSP->v.string.ss_offset = value;
} else {
Error( ERR_NONE, LIT( ERR_ILL_TYPE ) );
}
break;
case 16:
RValue( ExprSP );
ConvertTo( ExprSP, TK_INTEGER, TM_SIGNED, 4 );
value = U32FetchTrunc( ExprSP->v.sint ) - 1;
PopEntry();
if( ExprSP->info.kind == TK_STRING ) {
value -= ExprSP->v.string.ss_offset;
if( value < 0 || value >= ExprSP->info.size ) {
Error( ERR_NONE, LIT( ERR_BAD_SUBSTRING_INDEX ) );
}
ExprSP->info.size = value;
} else {
Error( ERR_NONE, LIT( ERR_ILL_TYPE ) );
}
break;
case 17:
EvalSubstring = parm;
if( parm ) ExprSP->v.string.ss_offset = 0;
break;
case 18:
result = EvalSubstring;
break;
case 19:
FreePgmStack( TRUE );
break;
case 20:
switch( parm ) { // nyi - begin temp
case SSL_CASE_SENSITIVE:
_SwitchOn( SW_CASE_SENSITIVE );
break;
case SSL_SIDE_EFFECT:
_SwitchOn( SW_SIDE_EFFECT );
break;
//case SSL_32_BIT:
// _SwitchOn( SW_32_BIT );
// break;
}
break;
case 21:
switch( parm ) {
case SSL_CASE_SENSITIVE:
_SwitchOff( SW_CASE_SENSITIVE );
break;
case SSL_SIDE_EFFECT:
_SwitchOff( SW_SIDE_EFFECT );
break;
//case SSL_32_BIT:
// _SwitchOff( SW_32_BIT );
// break;
}
break;
case 22:
switch( parm ) {
case SSL_CASE_SENSITIVE:
result = _IsOn( SW_CASE_SENSITIVE );
break;
case SSL_SIDE_EFFECT:
result = _IsOn( SW_SIDE_EFFECT );
break;
case SSL_32_BIT:
GetMADTypeDefault( MTK_INTEGER, &mti );
result = (mti.b.bits >= 32);
break;
}
break;
case 23: // nyi - end temp
MarkArrayOrder( parm );
break;
case 24:
StartSubscript();
break;
case 25:
AddSubscript();
break;
case 26:
EndSubscript();
break;
}
return( result );
}
CGuid::operator CString()
{
CString csGuid;
ConvertTo(csGuid);
return csGuid;
}
CGuid::operator LPCTSTR()
{
ConvertTo();
return m_Buffer;
}
void InitIcons()
{
// all those flag icons storing in a large 24bit opaque bitmap to reduce file size
FIBITMAP *dib = LoadResource(IDB_FLAGSPNG, _T("PNG"));
if (dib == NULL)
return;
if (FIP->FI_GetBPP(dib) != ILC_COLOR32)
if (NULL == (dib = ConvertTo(dib, ILC_COLOR32, 0)))
return;
// create new dib
FIBITMAP *dib_ico = FIP->FI_Allocate(FIP->FI_GetWidth(dib), 16, ILC_COLOR32, 0, 0, 0);
if (dib_ico == NULL) {
FIP->FI_Unload(dib);
return;
}
UINT h = FIP->FI_GetHeight(dib_ico);
UINT w = FIP->FI_GetWidth(dib_ico);
UINT t = ((h - FIP->FI_GetHeight(dib)) / 2) + 1;
UINT b = t + FIP->FI_GetHeight(dib);
// copy dib to new dib_ico (centered)
if (FIP->FI_Paste(dib_ico, dib, 0, t - 1, 255 + 1)) {
FIP->FI_Unload(dib); dib = NULL;
// Calculate the number of bytes per pixel (3 for 24-bit or 4 for 32-bit)
int bytespp = FIP->FI_GetLine(dib_ico) / w;
// set alpha schannel
for (unsigned y = 0; y < h; y++) {
BYTE *bits = FIP->FI_GetScanLine(dib_ico, y);
for (unsigned x = 0; x < w; x++) {
bits[FI_RGBA_ALPHA] = (y < t || y >= b) ? 0 : 255;
// jump to next pixel
bits += bytespp;
}
}
}
else {
FIP->FI_Unload(dib);
FIP->FI_Unload(dib_ico);
return;
}
HBITMAP hScrBM = FIP->FI_CreateHBITMAPFromDIB(dib_ico);
FIP->FI_Unload(dib_ico);
if (!hScrBM)
return;
// create ImageList
HIMAGELIST himl = ImageList_Create(16, 16, ILC_COLOR32 | ILC_MASK, 0, nCountriesCount);
ImageList_Add(himl, hScrBM, NULL);
DeleteObject(hScrBM);
hScrBM = NULL;
if (himl != NULL) {
phIconHandles = (HANDLE*)mir_alloc(nCountriesCount*sizeof(HANDLE));
if (phIconHandles != NULL) {
char szId[20];
SKINICONDESC sid = { 0 };
sid.section.t = LPGENT("Country flags");
sid.pszName = szId; // name to refer to icon when playing and in db
sid.flags = SIDF_SORTED | SIDF_TCHAR;
for (int i=0; i < nCountriesCount; i++) {
sid.description.t = mir_a2t(LPGEN(countries[i].szName));
/* create identifier */
mir_snprintf(szId, _countof(szId), (countries[i].id == 0xFFFF) ? "%s0x%X" : "%s%i", "flags_", countries[i].id); /* buffer safe */
int index = CountryNumberToBitmapIndex(countries[i].id);
/* create icon */
sid.hDefaultIcon = ImageList_ExtractIcon(NULL, himl, index);
index = CountryNumberToIndex(countries[i].id);
phIconHandles[index] = IcoLib_AddIcon(&sid);
if (sid.hDefaultIcon != NULL)
DestroyIcon(sid.hDefaultIcon);
mir_free(sid.description.t); sid.description.t = NULL;
}
}
ImageList_Destroy(himl);
}
// create services
CreateServiceFunction(MS_FLAGS_LOADFLAGICON,ServiceLoadFlagIcon);
CreateServiceFunction(MS_FLAGS_CREATEMERGEDFLAGICON,ServiceCreateMergedFlagIcon);
}
