char *L2PNet_inet_ntoa( struct in_addr in ) { char b[10]; char *p = l2pnet_static_inet_ntoa_buffer; _itoa( in.S_un.S_addr & 0xFF, b, 10 ); strcpy( p, b ); _itoa( (in.S_un.S_addr >> 8) & 0xFF, b, 10 ); strcat( p, "." ); strcat( p, b ); _itoa( (in.S_un.S_addr >> 16) & 0xFF, b, 10 ); strcat( p, "." ); strcat( p, b ); _itoa( (in.S_un.S_addr >> 24) & 0xFF, b, 10 ); strcat( p, "." ); strcat( p, b ); return l2pnet_static_inet_ntoa_buffer; }
void CDiagRec::setNTError(DWORD errorMsgLang, const char *FuncName) { LPVOID lpMsgBuf; DWORD error; char buffer[10]; error = GetLastError(); FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, error, errorMsgLang, (LPTSTR) &lpMsgBuf, 0, NULL); setDiagRec(DRIVER_ERROR, IDS_NT_ERROR, error, (char *)lpMsgBuf, NULL, SQL_ROW_NUMBER_UNKNOWN, SQL_COLUMN_NUMBER_UNKNOWN, 2, FuncName, _itoa(error,buffer,10)); LocalFree(lpMsgBuf); }
void LCDPrintNumWithPoint(UCHAR inX, UCHAR inY, UCHAR inNum) // prints a int to the screen. convert the int to string and prints it with Point in the middle { char str[4]; _itoa(inNum, &str[0], 10); if (inNum < 10) { LCDPutNum(inX, inY, 0); LCDPutChar(inX + 1, inY, LCD_POINT); LCDPutNum(inX + 2, inY, str[0]-48); } else { LCDPutNum(inX, inY, str[0]-48); LCDPutChar(inX + 1, inY, LCD_POINT); LCDPutNum(inX + 2, inY, str[1]-48); } }
void BK16USODevice::init(unsigned char* frame) { if (Debug::BK16_DEBUG_OUT){ char str[800]; std::cout << "BK16USODevice::init "; for (int i = 0; i < frame[3] + frame[4] * 256 + 7; i++) std::cout << _itoa(frame[i], str, 16) << " "; std::cout << std::endl; } fInit = true; frame[0] = frame[1]; frame[1] = address; frame[2] = COMMAND_INIT; frame[3] = 0; frame[4] = 0; }
/// <summary> /// Constructor with integer initialization /// </summary> /// <param name="integer_value">Integer value for the initialization</param> CLargeInteger::CLargeInteger( const int integer_value ) { // convert integer value to char array char ch_value[64] = {0}; char *ptr = _itoa(integer_value, ch_value, 10); // Sign check fSign = ( integer_value < 0 ) ? -1 : 1; ptr = ( integer_value < 0 ) ? ++ptr : ptr; // Copy char array fpchNumber_len = strlen(ptr); fpchNumber = (char*) calloc (fpchNumber_len + 1, 1); strcpy(fpchNumber, ptr); // initialization of value for printable array fpchPrintableVal = 0; }
void HISTORY::registerBookmarkSet(int slot, BOOKMARK& backupCopy, int oldCurrentBranch) { // create new snapshot SNAPSHOT snap; snap.init(currMovieData, taseditorConfig.enableHotChanges); // fill description: modification type + keyframe of the Bookmark snap.modificationType = MODTYPE_BOOKMARK_0 + slot; strcat(snap.description, modCaptions[snap.modificationType]); snap.startFrame = snap.endFrame = snap.keyFrame = bookmarks.bookmarksArray[slot].snapshot.keyFrame; char framenum[11]; strcat(snap.description, " "); _itoa(snap.keyFrame, framenum, 10); strcat(snap.description, framenum); if (taseditorConfig.enableHotChanges) snap.inputlog.copyHotChanges(&getCurrentSnapshot().inputlog); addItemToHistoryLog(snap, oldCurrentBranch, backupCopy); project.setProjectChanged(); }
wchar_t * __cdecl _itow ( int val, wchar_t *buf, int radix ) { char astring[INT_SIZE_LENGTH]; _itoa (val, astring, radix); #if defined(_NTSUBSET_) mbstowcs(buf, astring, INT_SIZE_LENGTH); #else MultiByteToWideChar (CP_ACP, MB_PRECOMPOSED, astring, -1, buf, INT_SIZE_LENGTH); #endif return (buf); }
int FileSystem::writeFS( Inode inode ) { int dataBlockNum = searchUnassignedBlockNum(); // 데이터블럭 번호 할당 int inodeNum = searchUnassignedInodeNum(); // 아이노드 번호 할당 char *buffer = new char[2]; _itoa( dataBlockNum, buffer ); int inodeBlockNum = checkInodeBlockNum( inodeNum ); // 아이노드 번호가 32이상인지 확인 if ( inodeBlockNum == 4 ) // 아이노드 번호가 32이하 이면 블럭번호 4에 저장 { inodeBlock[0].setMode( inodeNum, inode.mode ); inodeBlock[0].setSize( inodeNum, inode.size ); inodeBlock[0].setTime( inodeNum, inode.time ); inodeBlock[0].setCtime( inodeNum, inode.ctime ); inodeBlock[0].setMtime( inodeNum, inode.mtime ); inodeBlock[0].setLinksCount( inodeNum, inode.linksCount ); inodeBlock[0].setBlocks( inodeNum, inode.blocks ); inodeBlock[0].setDataBlockList( inodeNum, buffer ); } else if ( inodeBlockNum == 5 ) // 이상이면 블럭번호 5에 저장 { inodeBlock[1].setMode( inodeNum - 32, inode.mode ); inodeBlock[1].setSize( inodeNum - 32, inode.size ); inodeBlock[1].setTime( inodeNum - 32, inode.time ); inodeBlock[1].setCtime( inodeNum - 32, inode.ctime ); inodeBlock[1].setMtime( inodeNum - 32, inode.mtime ); inodeBlock[1].setLinksCount( inodeNum - 32, inode.linksCount ); inodeBlock[1].setBlocks( inodeNum - 32, inode.blocks ); inodeBlock[1].setDataBlockList( inodeNum - 32, buffer ); } blockBitmap[dataBlockNum] = '1'; // 블럭 비트맵 갱신 inodeBitmap[inodeNum] = '1'; // 아이노드 비트맵 갱신 blockDescriptorTable.setUnassignedBlockNum( atoi( blockDescriptorTable.getUnassignedBlockNum() ) - 1 ); // unassignedBlockNum - 1 blockDescriptorTable.setUnassignedInodeNum( atoi( blockDescriptorTable.getUnassignedInodeNum() ) - 1 ); // unassignedInodeNum - 1 delete[] buffer; return inodeNum; }
extern "C" void odbc_SQLSvc_EndTransaction_ccf_ ( CEE_tag_def cmptag_ , const struct odbc_SQLSvc_EndTransaction_exc_ *exception_ , const ERROR_DESC_LIST_def *sqlWarning ) { SRVR_CALL_CONTEXT *srvrCallContext = (SRVR_CALL_CONTEXT *)cmptag_; CConnect *pConnection = (CConnect *)srvrCallContext->sqlHandle; pConnection->setExceptionErrors(exception_->exception_nr, exception_->exception_detail); switch (exception_->exception_nr) { case CEE_SUCCESS: if (sqlWarning->_length > 0) pConnection->setDiagRec(sqlWarning); break; case odbc_SQLSvc_EndTransaction_SQLError_exn_: pConnection->setDiagRec(&exception_->u.SQLError); break; case odbc_SQLSvc_EndTransaction_ParamError_exn_: pConnection->setDiagRec(SERVER_ERROR, IDS_PROGRAM_ERROR, exception_->exception_nr, exception_->u.ParamError.ParamDesc, NULL, SQL_ROW_NUMBER_UNKNOWN, SQL_COLUMN_NUMBER_UNKNOWN, 1, pConnection->getSrvrIdentity()); break; case odbc_SQLSvc_EndTransaction_SQLInvalidHandle_exn_: break; case odbc_SQLSvc_EndTransaction_InvalidConnection_exn_: pConnection->setDiagRec(SERVER_ERROR, IDS_08_S01); break; case odbc_SQLSvc_EndTransaction_TransactionError_exn_: char tmpNumBuffer[16]; _itoa (exception_->exception_detail, tmpNumBuffer, 10); pConnection->setDiagRec(SERVER_ERROR, IDS_TRANSACTION_ERROR, exception_->exception_nr, tmpNumBuffer, NULL, SQL_ROW_NUMBER_UNKNOWN, SQL_COLUMN_NUMBER_UNKNOWN, 1, pConnection->getSrvrIdentity()); break; default: pConnection->sendCDInfo(exception_->exception_nr); pConnection->setDiagRec(exception_->exception_nr, ENDTRANSACT_PROCNAME, pConnection->getSrvrIdentity()); break; } } // odbc_SQLSvc_EndTransaction_ccf_()
//Protocol chain is list of integers "0".."n", with network protocol named "p" INT_PTR Proto_CallContactService(WPARAM wParam,LPARAM lParam) //note that this is ChainSend() too, due to a quirk of function definitions { CCSDATA *ccs=(CCSDATA*)lParam; int i; char str[10]; DBVARIANT dbv; INT_PTR ret; PROTOACCOUNT* pa; if ( wParam == (WPARAM)(-1)) return 1; for ( i = wParam;; i++ ) { _itoa( i, str, 10 ); if ( DBGetContactSettingString( ccs->hContact, "_Filter", str, &dbv )) break; if (( ret = CallProtoService( dbv.pszVal, ccs->szProtoService, i+1, lParam )) != CALLSERVICE_NOTFOUND ) { //chain was started, exit mir_free( dbv.pszVal ); return ret; } mir_free( dbv.pszVal ); } if ( DBGetContactSettingString( ccs->hContact, "Protocol", "p", &dbv )) return 1; pa = Proto_GetAccount( dbv.pszVal ); if ( pa == NULL || pa->ppro == NULL ) ret = 1; else { if ( pa->bOldProto ) ret = CallProtoServiceInt( ccs->hContact, dbv.pszVal, ccs->szProtoService, (WPARAM)(-1), ( LPARAM)ccs ); else ret = CallProtoServiceInt( ccs->hContact, dbv.pszVal, ccs->szProtoService, ccs->wParam, ccs->lParam ); if ( ret == CALLSERVICE_NOTFOUND ) ret = 1; } mir_free(dbv.pszVal); return ret; }
int fnGetProtoIndexByPos(PROTOCOLDESCRIPTOR **proto, int protoCnt, int Pos) { char buf[10]; _itoa(Pos, buf, 10); DBVARIANT dbv; if (!db_get_s(NULL, "Protocols", buf, &dbv)) { for (int p = 0; p < protoCnt; p++) { if (mir_strcmp(proto[p]->szName, dbv.pszVal) == 0) { db_free(&dbv); return p; } } db_free(&dbv); } return -1; }
char* number (int x) { int i, j, k; char buff[16]; static char string[12] = " "; _itoa (x, buff, 10); k = strlen (buff); i = k + (k-1)/3; string[i--] = 0; j = 0; while (1) { string[i--] = buff[--k]; if (i < 0) break; if (++j % 3 == 0) string[i--] = ','; } return (string); }
// // Strings can be appended with short integers // inline FixedLengthString& operator << (short int Value) { char Source[30]; _itoa(Value, Source, 10); int Length=strlen(Source)+1; if( CurrentSize+Length>MaximumLength ) Length=MaximumLength-CurrentSize; memcpy( Text+CurrentSize, Source, Length ); CurrentSize+=Length-1; *(Text+CurrentSize)=0; return *this; }
void Exporter::validateData() { info += "\r\n"; removeRedundantMaterials(); buildBoneHierarchy(); // Calculate bone id (prevents mixing wrong types) boneId = 0; for(unsigned int i = 0; i < bones.size(); ++i) { // Sum of child index * parent index for(unsigned int j = 0; j < i; ++j) if(bones[i].getParentName() == bones[j].getName()) boneId += i*j; } if(model.getObjects().size() > 1) { model.buildObjectHierarchy(); printInfo("Resorted object hierarchy"); } if(model.getHelpers().size() > 1) { model.buildHelperHierarchy(); printInfo("Resorted helper hierarchy"); } if(boneId >= 0) { char number[20] = { 0 }; _itoa(boneId, number, 10); info += "\r\n"; printInfo("Calculated bone id: " + std::string(number)); } model.setCollisionFlags(); // !!!!!!!!!!!!!!!!!! //if(boneId <= 0) // model.chopObjects(); }
void CreateDumbyFiles(const std::string& name, int numFiles, int numKBytes) { if(numFiles <= 0 || numKBytes <= 0) return; std::stringstream ss; ss << name << "_" << numKBytes << "KB_File_"; char* temp = new char[numKBytes * 1024]; char buff[33]; for(int i = 0; i < numFiles; ++i) { _itoa(i + 1, buff, 10); std::ofstream file(ss.str() + buff + ".dat", std::ios::out | std::ios::trunc); file.write(temp, numKBytes * 1024); file.close(); } }
int makestr(char *type,char *data,char *rtdata) { size_t i=0; char *s=new char[4]; char str[200]=""; char *temp=rtdata; i=strlen(data); _itoa((int)i,s,10); i=i+strlen(s)+2; strcat(str,":"); strcat(str,type); strcat(str,s); strcat(str,":"); strcat(str,data); strncpy(temp,str,strlen(str)); temp[i+1]='\0'; delete [] s; return 0; }
//结构体初始化 位域操作 void main() { struct _tagStruct1 { int a = 1; int b = 2; } istr1; // istr1.a = 2; printf("结构体=%d\n", istr1.a); struct _tagStruct2 { int a : 1; int b : 2; } istr2; istr2.a = 1; printf("结构体=%d\n", istr2.a); typedef struct AA { unsigned char b1 : 5; unsigned char b2 : 5; unsigned char b3 : 5; unsigned char b4 : 5; unsigned char b5 : 5; }AA1; struct test1 { char a : 1; char : 2; long b : 3; char c : 2; }AA;//12 printf("daxiao = %d",sizeof(AA));// 但实际上只用了25位,即4个字节, int number = 12345; char string[25]; _itoa(number, string, 2); printf("integer = %d string = %s\n", number, string); def_connect(2); }
string CGnutellaFileTransferDlg::FormatWithCommas(unsigned int num) { string ret; char buf[32]; char buf2[sizeof(buf)*2]; memset(buf,0,sizeof(buf)); memset(buf2,0,sizeof(buf2)); _itoa(num,buf,10); char *ptr=&buf[strlen(buf)-1]; // last char char *ptr2=&buf2[sizeof(buf2)-2]; // last char int i=0; while(1) { if(i>0) { if(i%3==0) { *ptr2=','; ptr2--; } } *ptr2=*ptr; if(ptr==buf) { break; } ptr--; ptr2--; i++; } *ptr2=*ptr; ret=ptr2; return ret; }
NoiseSockets::NoiseSockets(HWND hwnd,CCriticalSection *connection_data_critical_section,vector<ConnectionData> *connection_data,FileSharingManager* fsm) { p_fs_manager = fsm; m_hwnd=hwnd; p_connection_data_critical_section=connection_data_critical_section; p_connection_data=connection_data; m_num_bogus_connections=0; m_num_good_connections=0; int num_reserved_events=ReturnNumberOfReservedEvents(); int num_socket_events=ReturnNumberOfSocketEvents(); // Init the parent pointers and message window handles for(int i=0;i<num_socket_events;i++) { m_sockets[i].InitParent(this); } // Create the reserved events for(i=0;i<num_reserved_events;i++) { m_events[i]=WSACreateEvent(); if(m_events[i]==WSA_INVALID_EVENT) { char msg[1024]; strcpy(msg,"Could not create a valid reserved event "); _itoa(i,&msg[strlen(msg)],10); ::MessageBox(NULL,msg,"Error",MB_OK); } } // Fully initialize events array for(i=0;i<num_socket_events;i++) { m_events[num_reserved_events+i]=m_sockets[i].ReturnEventHandle(); } p_noise_data_buf=NULL; InitNoiseData(); }
void bta_sys_prompt(NPP instance, const char *error) { struct _bta_prompt_info *p = (struct _bta_prompt_info *)bta_malloc(sizeof(struct _bta_prompt_info)+strlen(error)+1); _bta_sys_info = p; p->pin = ((bta_info *)instance->pdata)->pin; p->parent= ((bta_info*)instance->pdata)->window; strcpy_s(p->error, strlen(error)+1, error); p->instance=instance; HINSTANCE hinstance = (HINSTANCE)GetWindowLong(p->parent, GWL_HINSTANCE); p->hfont = (HFONT)GetStockObject(ANSI_VAR_FONT); p->cursor[0]=LoadCursor(NULL, IDC_ARROW); p->cursor[1]=LoadCursor(NULL, IDC_IBEAM); WNDCLASS wndclass; if( GetClassInfo(hinstance, L"BetterThanAdsPrompt", &wndclass)==0 ) { wndclass.lpszClassName=L"BetterThanAdsPrompt"; wndclass.lpszMenuName=NULL; wndclass.cbClsExtra=0; wndclass.cbWndExtra=0; wndclass.hIcon = LoadIcon(NULL, IDI_APPLICATION); wndclass.hCursor=p->cursor[0]; wndclass.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH); wndclass.lpfnWndProc=_bta_sys_prompt_callback; wndclass.style=CS_HREDRAW|CS_VREDRAW; wndclass.hInstance=hinstance; if( !RegisterClass(&wndclass) ) { char ibuf[20]; _itoa(GetLastError(),ibuf,10); logmsg("ERROR registering window class!\n Error code: "); logmsg(ibuf); logmsg("\n"); return; } } DWORD threadid; HANDLE promptThreadHandle = CreateThread( NULL, 0, (LPTHREAD_START_ROUTINE)_bta_sys_prompt, p, 0, &threadid); }
THRCOMP ThGenIps(_anchor proc_anchor) { void *ptr; char *p; char string[256]; int value, i; long size, count; char *type; port_ent port_tab[3]; //char buffer[256]; value = dfsdfpt(proc_anchor, 3, port_tab,"COUNT","OUT","PREFIX"); value = dfsrecv(proc_anchor, &ptr, &port_tab[0], 0, &size, &type); if (value > 0) { printf("THGENIPS: No number specified\n"); // dfsputs(proc_anchor, buffer); return(8); } memcpy(string,ptr,size); string[size] = '\0'; count = atol(string); value = dfsdrop(proc_anchor, &ptr); strcpy(string, "Testing "); value = dfsrecv(proc_anchor, &ptr, &port_tab[2], 0, &size, &type); if (value == 0) { memcpy(string,ptr,size); string[size] = '\0'; value = dfsdrop(proc_anchor, &ptr); } // dfstest(proc_anchor); for (i = 0; i < count; i++) { value = dfscrep(proc_anchor, &ptr, 32,"G"); strcpy((char *) ptr, string); p = strchr((char *) ptr, '\0'); _itoa(i, p, 10); value = dfssend(proc_anchor, &ptr, &port_tab[1], 0); } return(0); }
static bool BuildConnStr ( char* pStrConn, Word pMaxLen, pODBCConn pConn, struct ODBCKV* KVInput, Word iKVInputPairs, struct ODBCKV* KVFileDSN, Word iKVFileDSNPairs ) { Word iPos = 0; Char p[32]; // arbitary for string port number as string // initializations memset ( pStrConn, 0, pMaxLen ); // convert port number to string _itoa ( pConn->ServerPort, p, 10 ); // transfer all strings from struct if ( !AddKVToConnStr ( "DRIVER", "{KylinODBCDriver}", &iPos, pStrConn, pMaxLen ) ) { __ODBCLOG ( _ODBCLogMsg ( LogLevel_DEBUG, "AddKVToConnStr failed in %s", "Driver" ) ); return FALSE; } if ( !AddKVToConnStr ( "SERVER", pConn->Server, &iPos, pStrConn, pMaxLen ) ) { __ODBCLOG ( _ODBCLogMsg ( LogLevel_DEBUG, "AddKVToConnStr failed in %s", "Server" ) ); return FALSE; } if ( !AddKVToConnStr ( "PROJECT", pConn->Project, &iPos, pStrConn, pMaxLen ) ) { __ODBCLOG ( _ODBCLogMsg ( LogLevel_DEBUG, "AddKVToConnStr failed in %s", "Project" ) ); return FALSE; } if ( !AddKVToConnStr ( "PORT", p, &iPos, pStrConn, pMaxLen ) ) { __ODBCLOG ( _ODBCLogMsg ( LogLevel_DEBUG, "AddKVToConnStr failed in %s", "Port" ) ); return FALSE; } if ( !AddKVToConnStr ( "UID", pConn->UserName, &iPos, pStrConn, pMaxLen ) ) { __ODBCLOG ( _ODBCLogMsg ( LogLevel_DEBUG, "AddKVToConnStr failed in %s", "Uid" ) ); return FALSE; } if ( !AddKVToConnStr ( "PWD", pConn->Password, &iPos, pStrConn, pMaxLen ) ) { __ODBCLOG ( _ODBCLogMsg ( LogLevel_DEBUG, "AddKVToConnStr failed in %s", "Pwd" ) ); return FALSE; } return TRUE; }
void MultiCursorAppCpp::initGL(int argc, char* argv[]) { glutInit(&argc, argv); WinIDs = new int[TKinect2Display.size()]; for (size_t i = 0; i < TKinect2Display.size(); ++i) { glutInitWindowPosition(i*20, 0); //glutInitWindowPosition(windowOffsetX[i], 0); glutInitWindowSize(VEC_WIN_WIDTH[i], VEC_WIN_HEIGHT[i]); glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE); char winName[8]; _itoa((int)i, winName, 10); WinIDs[i] = glutCreateWindow(winName); //// Register callback functions //glutReshapeFunc(sreshape); glutDisplayFunc(sdisplay); glutIdleFunc(sidle); glutKeyboardFunc(skeyboard); glutMouseFunc(smouse); glClearColor(1.0, 1.0, 1.0, 1.0); /* Camera setup */ glViewport(0, 0, kinectBasics.widthDepth, kinectBasics.heightDepth); glLoadIdentity(); if (i == 0){ /* GLのウィンドウをフルスクリーンに */ //GLのデバイスコンテキストハンドル取得 glutSetWindow(WinIDs[i]); HDC glDc = wglGetCurrentDC(); //ウィンドウハンドル取得 HWND hWnd = WindowFromDC(glDc); //ウィンドウの属性と位置変更 SetWindowLong(hWnd, GWL_STYLE, WS_POPUP); SetWindowPos(hWnd, HWND_TOP, windowOffsetX[i], 0, VEC_WIN_WIDTH[i], VEC_WIN_HEIGHT[i], SWP_SHOWWINDOW); } } }
void _vfprintf(void (* f)(int), const char *fmt, va_list va) { const char *p; char c, w; int val; while ((c = *fmt++) != '\0') { if (c != '%') { f(c); } else { c = *fmt++; w = 0; if (c == '0') { c = *fmt++; if (c >= '0' && c <= '8') { w = c - '0'; c = *fmt++; } } switch (c) { case 'd': val = va_arg(va, int); if (val < 0) { f('-'); val = -val; } _itoa((unsigned)val, f, 10, w); break; case 'X' : _itoa((unsigned)va_arg(va, int), f, 16, w); break; case 's' : p = va_arg(va, const char *); while (*p != '\0') f(*p++); break; } } } }
bool Twindow::TwidgetSubclassTbr::onEdit(void) { int idff=self->getTbrIdff(id,bind); TffdshowParamInfo info; memset(&info,0,sizeof(info)); if (self->deci->getParamInfo(idff,&info)!=S_OK) { return false; } int min,max,val; getEditMinMaxVal(info,&min,&max,&val); char_t valS[20]; _itoa(val,valS,10); char_t query[100]; tsprintf(query,self->_(0,_l("Enter value in range from %i to %i")),min,max); if (!self->inputString(self->_(0,_l("Edit trackbar value")),query,valS,20)) { return false; } storeEditValue(info,min,max,valS); return true; }
// ************************************************************************************************* // @fn display_eggtimer // @brief eggtimer user routine. // @param u8 line LINE2 // u8 update DISPLAY_LINE_UPDATE_PARTIAL, DISPLAY_LINE_UPDATE_FULL // @return none // ************************************************************************************************* void display_eggtimer(u8 line, u8 update) { u8 * str; // Partial line update only if (update == DISPLAY_LINE_UPDATE_PARTIAL) { // Check draw flag to minimize workload switch(sEggtimer.drawFlag) { case 3: // Hours changed str = _itoa(sEggtimer.hours, 2, 0); display_chars(LCD_SEG_L2_5_4, str, SEG_ON); case 2: // Minutes changed str = _itoa(sEggtimer.minutes, 2, 0); display_chars(LCD_SEG_L2_3_2, str, SEG_ON); case 1: // Seconds changed str = _itoa(sEggtimer.seconds, 2, 0); display_chars(LCD_SEG_L2_1_0, str, SEG_ON); } sEggtimer.drawFlag = 0; // Clear draw flag } // Redraw whole line else if (update == DISPLAY_LINE_UPDATE_FULL) { // Display HH:MM:SS str = _itoa(sEggtimer.hours, 2, 0); display_chars(LCD_SEG_L2_5_4, str, SEG_ON); str = _itoa(sEggtimer.minutes, 2, 0); display_chars(LCD_SEG_L2_3_2, str, SEG_ON); str = _itoa(sEggtimer.seconds, 2, 0); display_chars(LCD_SEG_L2_1_0, str, SEG_ON); display_symbol(LCD_SEG_L2_COL1, SEG_ON); display_symbol(LCD_SEG_L2_COL0, SEG_ON); if (sEggtimer.state != EGGTIMER_STOP) { // Blink if running or alarm triggered display_symbol(LCD_ICON_RECORD, SEG_ON_BLINK_ON); } else { // Solid on if not running display_symbol(LCD_ICON_RECORD, SEG_ON_BLINK_OFF); } } else if (update == DISPLAY_LINE_CLEAR) { // Stop blinking icon only if eggtimer isn't running if (sEggtimer.state == EGGTIMER_STOP) display_symbol(LCD_ICON_RECORD, SEG_OFF); } }
BOOL KCameraOptionDialog::OnInitDialog() { char szText[128]; if (!m_pPlayer) return FALSE; if (m_pPlayer->IsFreeCamera()) m_nFreeCamera = 1; else m_nFreeCamera = 0; m_nCameraType = s_CameraTypeConvertTable[m_pPlayer->GetCameraType()]; UpdateData(FALSE); _itoa(m_pPlayer->GetBindID(), szText, 10); m_editBindID.SetWindowTextA(szText); float fAAA = (m_pPlayer->GetAngle() * 180) / M_PI; gcvt(fAAA,5,szText); m_editAngle.SetWindowTextA(szText); return TRUE; }
void AssertFSz(BOOLFLAG fAssertion, int nline, char* szFile, char* szMsg) { if (!fAssertion) { char szAssertBuf[MAXASSERTBUF]; char szTempBuf[MAXTEMPBUF]; _itoa(nline,szTempBuf,10); strcpy(szAssertBuf,"Assertion Failure in line "); szTempBuf[MAXTEMPBUF - 1]= '\0'; strcat(szAssertBuf,szTempBuf); strcat(szAssertBuf," of file "); szFile[_MAX_PATH -1] = '\0'; strcat(szAssertBuf,szFile); if (szMsg) { szMsg[MAXASSERTBUF / 2] = '\0'; strcat(szAssertBuf,"\n"); strcat(szAssertBuf,szMsg); } strcat(szAssertBuf,"\n"); #if !defined(_CONSOLE) strcat(szAssertBuf,"Press OK to continue, Cancel to Debug"); if (MessageBox( NULL, szAssertBuf, "Assertion Failure", MB_APPLMODAL | MB_ICONSTOP | MB_OKCANCEL) == IDCANCEL) { DebugBreak(); } #else /* !defined(_CONSOLE) */ printf("%s\n",szAssertBuf); DebugBreak(); #endif /* defined(_CONSOLE) */ } }
bool BinOArchive::operator()(ContainerInterface& ser, const char* name, const char* label) { openNode(name, false); unsigned int size = (unsigned int)ser.size(); if(size < SIZE16) stream_.write((unsigned char)size); else if(size < 0x10000){ stream_.write(SIZE16); stream_.write((unsigned short)size); } else{ stream_.write(SIZE32); stream_.write(size); } if(strlen(name)){ if(size > 0){ int i = 0; do { char buffer[16]; #ifdef _MSC_VER _itoa(i++, buffer, 10); #else sprintf(buffer, "%d", i++); #endif ser(*this, buffer, ""); } while (ser.next()); } closeNode(name, false); } else{ if(size > 0) do ser(*this, "", ""); while (ser.next()); } return true; }
/*:::::*/ FBCALL FBSTRING *fb_IntToStr ( int num ) { FBSTRING *dst; /* alloc temp string */ dst = fb_hStrAllocTemp( NULL, sizeof( int ) * 3 ); if( dst != NULL ) { /* convert */ #ifdef HOST_MINGW _itoa( num, dst->data, 10 ); #else sprintf( dst->data, "%d", num ); #endif fb_hStrSetLength( dst, strlen( dst->data ) ); } else dst = &__fb_ctx.null_desc; return dst; }