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