const char_t* micro_time::format(char_t* buffer, uint64_t time) { const char_t kStartNumber = (char_t)('0'); // uint64_t milli_sec = to_millisecond(time); uint64_t sec = milli_sec / 1000; milli_sec = milli_sec % 1000; time_t now = m_gStartTime_std + sec; struct tm today; LOCALTIME(today, now); /* store tens of hour */ buffer[0] = (char_t)(today.tm_hour / 10 + kStartNumber); /* store units of hour */ buffer[1] = (char_t)(today.tm_hour % 10 + kStartNumber); /* store tens of minute */ buffer[2]= (char_t)(today.tm_min / 10 + kStartNumber); /* store units of minute */ buffer[3]= (char_t)(today.tm_min % 10 + kStartNumber); /* store tens of second */ buffer[4]= (char_t)(today.tm_sec / 10 + kStartNumber); /* store units of second */ buffer[5]= (char_t)(today.tm_sec % 10 + kStartNumber); // millisecond buffer[6]= (char_t)('.'); buffer[7]= (char_t)(milli_sec / 1000 + kStartNumber); buffer[8]= (char_t)((milli_sec/ 100) % 10 + kStartNumber); buffer[9]= (char_t)(milli_sec % 10 + kStartNumber); // XXX buffer[10] = 0; return buffer; }
void vcmosRefresh() { static time_t tprev = 0; time_t tcurr; struct tm *ptm; t_nubit8 century,year,month,mday,wday,hour,min,sec; tcurr = time(NULL); if (tcurr == tprev) return; else tprev = tcurr; ptm = LOCALTIME(&tcurr); century = (t_nubit8)(19 + ptm->tm_year / 100); year = (t_nubit8)(ptm->tm_year % 100); month = (t_nubit8)(ptm->tm_mon + 0x01); mday = (t_nubit8)(ptm->tm_mday); wday = (t_nubit8)(ptm->tm_wday + 0x01); hour = (t_nubit8)(ptm->tm_hour); min = (t_nubit8)(ptm->tm_min); sec = (t_nubit8)(ptm->tm_sec); vcmos.reg[VCMOS_RTC_SECOND] = Hex2BCD(sec); vcmos.reg[VCMOS_RTC_MINUTE] = Hex2BCD(min); vcmos.reg[VCMOS_RTC_HOUR] = Hex2BCD(hour); vcmos.reg[VCMOS_RTC_DAY_WEEK] = Hex2BCD(wday); vcmos.reg[VCMOS_RTC_DAY_MONTH] = Hex2BCD(mday); vcmos.reg[VCMOS_RTC_MONTH] = Hex2BCD(month); vcmos.reg[VCMOS_RTC_YEAR] = Hex2BCD(year); vcmos.reg[VCMOS_RTC_CENTURY] = Hex2BCD(century); }
void rust_localtime(int64_t sec, int32_t nsec, rust_tm *timeptr) { struct tm tm; time_t s = sec; LOCALTIME(&s, &tm); const char* zone = NULL; #if defined(__WIN32__) int32_t gmtoff = -timezone; wchar_t wbuffer[64] = {0}; char buffer[256] = {0}; // strftime("%Z") can contain non-UTF-8 characters on non-English locale (issue #9418), // so time zone should be converted from UTF-16 string. // Since wcsftime depends on setlocale() result, // instead we convert it using MultiByteToWideChar. if (strftime(buffer, sizeof(buffer) / sizeof(char), "%Z", &tm) > 0) { // ANSI -> UTF-16 MultiByteToWideChar(CP_ACP, 0, buffer, -1, wbuffer, sizeof(wbuffer) / sizeof(wchar_t)); // UTF-16 -> UTF-8 WideCharToMultiByte(CP_UTF8, 0, wbuffer, -1, buffer, sizeof(buffer), NULL, NULL); zone = buffer; } #else int32_t gmtoff = tm.tm_gmtoff; zone = tm.tm_zone; #endif tm_to_rust_tm(&tm, timeptr, gmtoff, zone, nsec); }
static const char* VisualCppTimeString() { time_t the_time = time(NULL); struct tm the_local_time; static char dateTime[80]; LOCALTIME(&the_local_time, &the_time); strftime(dateTime, 80, "%Y-%m-%dT%H:%M:%S", &the_local_time); return dateTime; }
// millisecond const char_t* micro_time::format_with_ymd(char_t* buffer, uint64_t time) { const char_t kStartNumber = (char_t)('0'); // uint64_t milli_sec = to_millisecond(time); uint64_t sec = milli_sec / 1000; milli_sec = milli_sec % 1000; time_t now = m_gStartTime_std + sec; struct tm today; LOCALTIME(today, now); // XXX int year = today.tm_year + 1900; int month = today.tm_mon + 1; /* store thousands of year */ buffer[0] = (char_t)(year / 1000 + kStartNumber); /* store hundreds of year */ buffer[1] = (char_t)((year/ 100) % 10 + kStartNumber); /* store tens of year */ buffer[2] = (char_t)((year/ 10) % 10 + kStartNumber); /* store units of year */ buffer[3] = (char_t)(year % 10 + kStartNumber); /* store tens of month */ buffer[4] = (char_t)(month / 10 + kStartNumber); /* store units of month */ buffer[5] = (char_t)(month % 10 + kStartNumber); /* store tens of day */ buffer[6] = (char_t)(today.tm_mday / 10 + kStartNumber); /* store units of day */ buffer[7] = (char_t)(today.tm_mday % 10 + kStartNumber); buffer[8] = (char_t)('-'); /* store tens of hour */ buffer[9] = (char_t)(today.tm_hour / 10 + kStartNumber); /* store units of hour */ buffer[10] = (char_t)(today.tm_hour % 10 + kStartNumber); /* store tens of minute */ buffer[11]= (char_t)(today.tm_min / 10 + kStartNumber); /* store units of minute */ buffer[12]= (char_t)(today.tm_min % 10 + kStartNumber); /* store tens of second */ buffer[13]= (char_t)(today.tm_sec / 10 + kStartNumber); /* store units of second */ buffer[14]= (char_t)(today.tm_sec % 10 + kStartNumber); // millisecond buffer[15]= (char_t)('.'); buffer[16]= (char_t)(milli_sec / 1000 + kStartNumber); buffer[17]= (char_t)((milli_sec/ 100) % 10 + kStartNumber); buffer[18]= (char_t)(milli_sec % 10 + kStartNumber); // XXX buffer[19] = 0; return buffer; }
uint32_t DayTime::day_sec(uint32_t time_sec) { time_t now = (time_t)time_sec; struct tm today; LOCALTIME(today, now); return today.tm_hour * 60 * 60 + today.tm_min * 60 + today.tm_sec; }
uint32_t DayTime::to_string(uint32_t sec) { //time_t now = micro_time::m_gStartTime_std + sec; time_t now = sec; struct tm today; LOCALTIME(today, now); return today.tm_hour * 10000 + today.tm_min * 100 + today.tm_sec; }
uint32_t DayTime::to_string(uint64_t time) { uint64_t milli_sec = micro_time::to_millisecond(time); uint64_t sec = milli_sec / 1000; time_t now = micro_time::m_gStartTime_std + sec; struct tm today; LOCALTIME(today, now); return today.tm_hour * 10000 + today.tm_min * 100 + today.tm_sec; }
void rust_localtime(int64_t sec, int32_t nsec, rust_tm *timeptr) { struct tm tm; time_t s = sec; LOCALTIME(&s, &tm); #if defined(__WIN32__) int32_t gmtoff = -timezone; #else int32_t gmtoff = tm.tm_gmtoff; #endif tm_to_rust_tm(&tm, timeptr, gmtoff, nsec); }
extern "C" CDECL void rust_localtime(int64_t *sec, int32_t *nsec, rust_tm *timeptr) { tm tm; time_t s = *sec; LOCALTIME(&s, &tm); #if defined(__WIN32__) int32_t gmtoff = -timezone; char zone[64]; strftime(zone, sizeof(zone), "%Z", &tm); #else int32_t gmtoff = tm.tm_gmtoff; const char *zone = tm.tm_zone; #endif tm_to_rust_tm(&tm, timeptr, gmtoff, zone, *nsec); }
int32_t rust_time_localtime(int64_t sec, int32_t nsec, rust_time_tm *timeptr) { struct tm tm; time_t s = sec; if (LOCALTIME(&s, &tm) == NULL) { return 0; } #if defined(__WIN32__) int32_t utcoff = -timezone; #elif defined(__native_client__) int32_t utcoff = _timezone; #else int32_t utcoff = tm.tm_gmtoff; #endif tm_to_rust_tm(&tm, timeptr, utcoff, nsec); return 1; }
bool_t DayTime::get_localtime(uint32_t* year, uint32_t* mon, uint32_t* day , uint32_t* hour, uint32_t* min, uint32_t* sec , uint32_t srcTime) { /* */ time_t now = srcTime; struct tm today; LOCALTIME(today, now); if (year) { *(year) = today.tm_year + 1900; } if (mon) { *(mon) = today.tm_mon + 1; } if (day) { *(day) = today.tm_mday; } if (hour) { *(hour) = today.tm_hour; } if (min) { *(min) = today.tm_min; } if (sec) { *(sec) = today.tm_sec; } return TRUE; }
/*! ************************************************************************************* * \brief System trace log output in Wels * * \param pCtx instance pointer * \param kiLevel log iLevel ( WELS_LOG_QUIET, ERROR, WARNING, INFO, DEBUG ) * \param kpFmtStr formated string to mount * \param argv pData string argument * * \return NONE * * \note N/A ************************************************************************************* */ void WelsLogDefault( void *pCtx, const int32_t kiLevel, const str_t *kpFmtStr, va_list argv ) { sWelsEncCtx *pEncCtx = (sWelsEncCtx *)pCtx; iWelsLogLevel iVal = (kiLevel & g_iLevelLog); if ( 0 == iVal || NULL == pEncCtx ) // such iLevel not enabled { return; } else { str_t pBuf[WELS_LOG_BUF_SIZE+1] = {0}; const int32_t kiBufSize = sizeof(pBuf) / sizeof(pBuf[0]) - 1; int32_t iCurUsed = 0; int32_t iBufUsed = 0; int32_t iBufLeft = kiBufSize - iBufUsed; if ( pEncCtx ){ time_t l_time; #if defined(WIN32) #if defined(_MSC_VER) #if _MSC_VER >= 1500 struct tm t_now; #else//VC6 struct tm* t_now; #endif//_MSC_VER >= 1500 #endif//_MSC_VER #else//__GNUC__ struct tm* t_now; #endif//WIN32 #if defined( WIN32 ) struct _timeb tb; time(&l_time); #ifdef _MSC_VER #if _MSC_VER >= 1500 LOCALTIME(&t_now, &l_time); #else t_now = LOCALTIME(&l_time); if ( NULL == t_now ) { return; } #endif//_MSC_VER >= 1500 #endif//_MSC_VER FTIME(&tb); #elif defined( __GNUC__ ) struct timeval tv; time(&l_time); t_now = (struct tm *)LOCALTIME(&l_time); gettimeofday(&tv,NULL); #endif//WIN32 if (iBufLeft > 0){ #ifdef _MSC_VER #if _MSC_VER >= 1500 iCurUsed = SNPRINTF( &pBuf[iBufUsed], iBufLeft, iBufLeft, "[0x%p @ ", pEncCtx ); // confirmed_safe_unsafe_usage #else iCurUsed = SNPRINTF( &pBuf[iBufUsed], iBufLeft, "[0x%p @ ", pEncCtx ); // confirmed_safe_unsafe_usage #endif//_MSC_VER >= 1500 #endif//_MSC_VER if (iCurUsed >= 0){ iBufUsed += iCurUsed; iBufLeft -= iCurUsed; } } else{ return; } if ( iBufLeft > 0 ){ iCurUsed = GetCodeName( &pBuf[iBufUsed], iBufLeft ); if ( iCurUsed > 0 ){ iBufUsed += iCurUsed; iBufLeft -= iCurUsed; } pBuf[iBufUsed] = ' '; ++ iBufUsed; -- iBufLeft; iCurUsed = GetLibName( &pBuf[iBufUsed], iBufLeft ); if ( iCurUsed > 0 ){ iBufUsed += iCurUsed; iBufLeft -= iCurUsed; } pBuf[iBufUsed] = ' '; ++ iBufUsed; -- iBufLeft; pBuf[iBufUsed] = 'v'; ++ iBufUsed; -- iBufLeft; iCurUsed = GetVerNum( &pBuf[iBufUsed], iBufLeft ); if ( iCurUsed > 0 ){ iBufUsed += iCurUsed; iBufLeft -= iCurUsed; } pBuf[iBufUsed] = ' '; ++ iBufUsed; -- iBufLeft; } if (iBufLeft > 0){ #if defined(WIN32) && defined(_MSC_VER) && (_MSC_VER >= 1500) iCurUsed = strftime(&pBuf[iBufUsed], iBufLeft, "%y-%m-%d %H:%M:%S", &t_now); #else iCurUsed = strftime(&pBuf[iBufUsed], iBufLeft, "%y-%m-%d %H:%M:%S", t_now); #endif//WIN32.. if (iCurUsed > 0){ iBufUsed += iCurUsed; iBufLeft -= iCurUsed; } } else{ return; } if (iBufLeft > 0){ #if defined (WIN32) #ifdef _MSC_VER #if _MSC_VER >= 1500 iCurUsed = SNPRINTF(&pBuf[iBufUsed], iBufLeft, iBufLeft, ".%03.3u]: ", tb.millitm); // confirmed_safe_unsafe_usage #else iCurUsed = SNPRINTF(&pBuf[iBufUsed], iBufLeft, ".%3.3u]: ", tb.millitm); // confirmed_safe_unsafe_usage #endif//_MSC_VER >= 1500 #endif//_MSC_VER #elif defined (__GNUC__) iCurUsed = SNPRINTF(&pBuf[iBufUsed], iBufLeft, ".%3.3u]: ", tv.tv_usec/1000); // confirmed_safe_unsafe_usage #endif//WIN32 if (iCurUsed >= 0){ iBufUsed += iCurUsed; iBufLeft -= iCurUsed; } } else{ return; } } // fixed stack corruption issue on vs2008 if ( iBufLeft > 0 ){ int32_t i_shift = 0; str_t *pStr = NULL; pStr = GetLogTag( kiLevel, &i_shift ); if ( NULL != pCtx){ int32_t iLenTag = STRNLEN( pStr, 8 ); // confirmed_safe_unsafe_usage STRCAT( &pBuf[iBufUsed], iBufLeft, pStr ); // confirmed_safe_unsafe_usage iBufUsed += iLenTag; pBuf[iBufUsed] = ' '; iBufUsed++; ++iLenTag; iBufLeft -= iLenTag; } } if (iBufLeft > 0){ #if defined(WIN32) && defined(_MSC_VER) && (_MSC_VER >= 1500) int32_t len = 0; len = _vscprintf( kpFmtStr, argv ) // _vscprintf doesn't count + 1; // terminating '\0' iCurUsed = VSPRINTF(&pBuf[iBufUsed], len, kpFmtStr, argv); // confirmed_safe_unsafe_usage #else iCurUsed = VSPRINTF(&pBuf[iBufUsed], kpFmtStr, argv); // confirmed_safe_unsafe_usage #endif//WIN32.. if (iCurUsed > 0){ iBufUsed += iCurUsed; iBufLeft -= iCurUsed; } } #ifdef ENABLE_TRACE_FILE if (NULL != pEncCtx && NULL != pEncCtx->pFileLog){ if ( pEncCtx->uiSizeLog > MAX_TRACE_LOG_SIZE){ if (0 == fseek(pEncCtx->pFileLog, 0L, SEEK_SET)) pEncCtx->uiSizeLog = 0; } if ( iBufUsed > 0 && iBufUsed < WELS_LOG_BUF_SIZE ) { iCurUsed = fwrite(pBuf, 1, iBufUsed, pEncCtx->pFileLog); fflush( pEncCtx->pFileLog ); if ( iCurUsed == iBufUsed ) pEncCtx->uiSizeLog += iBufUsed; } } else{ #if defined(WIN32) && defined(_DEBUG) OutputDebugStringA(pBuf); #endif } #endif//ENABLE_TRACE_FILE } }
bool_t FileCollectorImpl::searchAllFile(collector_log_type_e collector_log_type ,CollectRule* pCollectRule, file_collect_callback_t pfn_cb, void* context) { ASSERT(pCollectRule); ASSERT(pfn_cb); // now struct tm today; time_t now = time(NULL); LOCALTIME(today, now); WIN32_FIND_DATA find_file_data; //__try { HANDLE find_handle = FindFirstFile(pCollectRule->find_dir, &find_file_data); if (find_handle != INVALID_HANDLE_VALUE) { do { // Don't count current or parent directories. if ((STRCMP(find_file_data.cFileName, _STR("..")) == 0) || (STRCMP(find_file_data.cFileName, _STR(".")) == 0)) continue; if (find_file_data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) { continue; } /* long result = CompareFileTime(&find_file_data.ftCreationTime, // NOLINT &comparison_filetime); // File was created after or on comparison time if ((result == 1) || (result == 0)) ++file_count; */ // is we need file //uint32_t nMatchLen = STRLEN(find_file_data.cFileName); if (TRUE == pCollectRule->regExExclude.didCompile() && TRUE == pCollectRule->regExExclude.isMatchOnly(find_file_data.cFileName) ) { continue; } if (FALSE == pCollectRule->regExInclude.isMatchOnly(find_file_data.cFileName)) { continue; } // test file // char_t strPath[MAX_PATH + 1] = {0}; // SNPRINTF(strPath, MAX_PATH, MAX_PATH, "%s/%s", pCollectRule->dir, find_file_data.cFileName); // AutoReleaseFile autoRelFile(OpenFile(strPath, strAttrOpenRead)); // if (NULL == autoRelFile) { continue; } // find map FileNode* pFileNode; if (MEM_NINI_LOG == collector_log_type) { pFileNode = findFileNode(pCollectRule->mml_hash, find_file_data.cFileName); } else { pFileNode = findFileNode(pCollectRule->hash, find_file_data.cFileName); } if (NULL == pFileNode) { if (TRUE == m_bAfterToDay) { // time control SYSTEMTIME nCreateTime; SYSTEMTIME stUTC; if (FALSE == FileTimeToSystemTime(&(find_file_data.ftCreationTime), &stUTC) || FALSE == SystemTimeToTzSpecificLocalTime(NULL, &stUTC, &nCreateTime) ) { continue; } if (nCreateTime.wYear != today.tm_year + 1900 || nCreateTime.wMonth != today.tm_mon + 1 || nCreateTime.wDay != today.tm_mday ) { continue; } } // char_t strPath[MAX_PATH + 1] = {0}; // SNPRINTF(strPath, MAX_PATH, MAX_PATH, "%s/%s", pCollectRule->dir, find_file_data.cFileName); // AutoReleaseFile AutoRelFile(::OpenFile(strPath, strAttrOpenRead)); // if (NULL == AutoRelFile) { continue; } // pFileNode = new FileNode(pCollectRule->dir , MEM_NINI_LOG == collector_log_type ? pCollectRule->GetMMLDir() : NULL , find_file_data.cFileName); if (NULL == pFileNode) { continue; } // update file info FindData2FileInfo(&pFileNode->FileInfo(), find_file_data); // add to map addFileNode(pCollectRule->hash, pFileNode->LocalName(), pFileNode); // new file if (RC_S_OK != (pfn_cb)(/*this, */pFileNode, context)) { break; } } else { ASSERT(pFileNode); // update file info PlatformFileInfo& fileInfo = pFileNode->FileInfo(); FindData2FileInfo(&fileInfo, find_file_data); if (pFileNode->GetSendSize() < fileInfo.size) { // new data if (RC_S_OK != (pfn_cb)(/*this, */pFileNode, context)) { break; } } } } while (FindNextFile(find_handle, &find_file_data)); FindClose(find_handle); } } // __except(EXCEPTION_EXECUTE_HANDLER) { // // return TRUE; // } return TRUE; }
/** Converts a GMT timestamp to local datetime struct Adjusts to TZ if possible **/ int local_datetime(TIMESTAMP ts, DATETIME *dt) { int64 n; TIMESTAMP rem = 0; TIMESTAMP local; int tsyear; #ifdef USE_TS_CACHE /* allow caching */ static TIMESTAMP old_ts =0; static DATETIME old_dt; #endif if( ts == TS_NEVER || ts==TS_ZERO ) return 0; if( dt==NULL || ts<TS_ZERO || ts>TS_MAX ) /* no buffer or timestamp out of range */ { output_error("local_datetime(ts=%lli,...): invalid local_datetime request",ts); return 0; } #ifdef USE_TS_CACHE /* check cache */ if (old_ts == ts && old_ts!=0) memcpy(dt,&old_dt,sizeof(DATETIME)); else old_ts = 0; #endif local = LOCALTIME(ts); tsyear = timestamp_year(local, &rem); if (rem < 0) { // DPC: note that as of 3.0, the clock is initialized by default, so this error can only // occur when an invalid timestamp is being converted to local time. It should no // longer occur as a result of a missing clock directive. //THROW("local_datetime(ts=%lli, ...): invalid timestamp cannot be converted to local time", ts); /* TROUBLESHOOT This is the result of an internal core or module coding error which resulted in an invalid UTC clock time being converted to local time. */ output_error("local_datetime(ts=%lli,...): invalid local_datetime request",ts); return 0; } if(ts < TS_ZERO && ts > TS_MAX){ /* timestamp out of range */ return 0; } if(ts == TS_NEVER){ return 0; } /* ts is valid */ dt->timestamp = ts; /* DST? */ dt->is_dst = (tzvalid && isdst(ts)); /* compute year */ dt->year = tsyear; /* yearday and weekday */ dt->yearday = (unsigned short)(rem / DAY); dt->weekday = (unsigned short)((local / DAY + DOW0 + 7) % 7); /* compute month */ dt->month = 0; n = daysinmonth[0] * DAY; while(rem >= n){ rem -= n; /* subtract n ticks from ts */ dt->month++; /* add to month */ if(dt->month == 12){ dt->month = 0; ++dt->year; } n = (daysinmonth[dt->month] + ((dt->month == 1 && ISLEAPYEAR(dt->year)) ? 1:0)) * 86400 * TS_SECOND; if(n < 86400 * 28){ /**/ output_fatal("Breaking an infinite loop in local_datetime! (ts = %"FMT_INT64"ds", ts); /* TROUBLESHOOT An internal protection against infinite loops in the time calculation module has encountered a critical problem. This is often caused by an incorrectly initialized timezone system, a missing timezone specification before a timestamp was used, or a missing timezone localization in your system. Correct the timezone problem and try again. */ return 0; } } dt->month++; /* Jan=1 */ /* compute day */ dt->day = (unsigned short)(rem / DAY + 1); rem %= DAY; /* compute hour */ dt->hour = (unsigned short)(rem / HOUR); rem %= HOUR; /* compute minute */ dt->minute = (unsigned short)(rem / MINUTE); rem %= MINUTE; /* compute second */ dt->second = (unsigned short)rem / TS_SECOND; rem %= SECOND; /* compute nanosecond */ dt->nanosecond = (unsigned int)(rem * 1e9); /* determine timezone */ strncpy(dt->tz, tzvalid ? (dt->is_dst ? tzdst : tzstd) : "GMT", sizeof(dt->tz)); /* timezone offset in seconds */ dt->tzoffset = tzoffset - (isdst(dt->timestamp)?3600:0); #ifdef USE_TS_CACHE /* cache result */ old_ts = ts; memcpy(&old_dt,dt,sizeof(old_dt)); #endif return 1; }