sal/osl/os2/time.c

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: time.c,v $
  10  * $Revision: 1.5 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31
  32 #include "system.h"
  33
  34 #include <osl/diagnose.h>
  35 #include <osl/time.h>
  36
  37 /* FIXME: detection should be done in configure script */
  38 #if defined(MACOSX) || defined(FREEBSD) || defined(NETBSD) || defined(LINUX)
  39 #define STRUCT_TM_HAS_GMTOFF 1
  40
  41 #elif defined(SOLARIS)
  42 #define HAS_ALTZONE 1
  43 #endif
  44
  45 /*--------------------------------------------------
  46  * osl_getSystemTime
  47  *-------------------------------------------------*/
  48
  49 sal_Bool SAL_CALL osl_getSystemTime(TimeValue* TimeValue)
  50 {
  51     struct timeval tp;
  52
  53     /* FIXME: use higher resolution */
  54     gettimeofday(&tp, NULL);
  55
  56     TimeValue->Seconds = tp.tv_sec;
  57     TimeValue->Nanosec = tp.tv_usec * 1000;
  58
  59     return (sal_True);
  60 }
  61
  62
  63 /*--------------------------------------------------
  64  * osl_getDateTimeFromTimeValue
  65  *-------------------------------------------------*/
  66
  67 sal_Bool SAL_CALL osl_getDateTimeFromTimeValue( TimeValue* pTimeVal, oslDateTime* pDateTime )
  68 {
  69     struct tm *pSystemTime;
  70     struct tm tmBuf;
  71     time_t atime;
  72
  73     atime = (time_t)pTimeVal->Seconds;
  74
  75     /* Convert time from type time_t to struct tm */
  76     pSystemTime = gmtime_r( &atime, &tmBuf );
  77
  78
  79     /* Convert struct tm to struct oslDateTime */
  80     if ( pSystemTime != NULL )
  81     {
  82         pDateTime->NanoSeconds  =       pTimeVal->Nanosec;
  83         pDateTime->Seconds              =       pSystemTime->tm_sec;
  84         pDateTime->Minutes              =       pSystemTime->tm_min;
  85         pDateTime->Hours                =       pSystemTime->tm_hour;
  86         pDateTime->Day                  =       pSystemTime->tm_mday;
  87         pDateTime->DayOfWeek    =       pSystemTime->tm_wday;
  88         pDateTime->Month                =       pSystemTime->tm_mon + 1;
  89         pDateTime->Year                 =       pSystemTime->tm_year  + 1900;
  90
  91         return sal_True;
  92     }
  93
  94     return sal_False;
  95 }
  96
  97 /*--------------------------------------------------
  98  * osl_getTimeValueFromDateTime
  99  *--------------------------------------------------*/
 100
 101 sal_Bool SAL_CALL osl_getTimeValueFromDateTime( oslDateTime* pDateTime, TimeValue* pTimeVal )
 102 {
 103     struct tm   aTime;
 104     time_t              nSeconds;
 105
 106     /* Convert struct oslDateTime to struct tm */
 107     aTime.tm_sec  = pDateTime->Seconds;
 108     aTime.tm_min  = pDateTime->Minutes;
 109     aTime.tm_hour = pDateTime->Hours;
 110     aTime.tm_mday = pDateTime->Day;
 111     aTime.tm_wday = pDateTime->DayOfWeek;
 112
 113     if ( pDateTime->Month > 0 )
 114         aTime.tm_mon = pDateTime->Month - 1;
 115     else
 116         return sal_False;
 117
 118     if ( pDateTime->Year >= 1900 )
 119         aTime.tm_year = pDateTime->Year - 1900;
 120     else
 121         return sal_False;
 122
 123     aTime.tm_isdst = -1;
 124     aTime.tm_wday  = 0;
 125     aTime.tm_yday  = 0;
 126
 127     /* Convert time to calendar value */
 128     nSeconds = mktime( &aTime );
 129
 130     /*
 131      * mktime expects the struct tm to be in local timezone, so we have to adjust
 132      * the returned value to be timezone neutral.
 133      */
 134
 135     if ( nSeconds != (time_t) -1 )
 136     {
 137         time_t bias;
 138
 139         /* timezone corrections */
 140         tzset();
 141
 142 #if defined(STRUCT_TM_HAS_GMTOFF)
 143         /* members of struct tm are corrected by mktime */
 144         bias = 0 - aTime.tm_gmtoff;
 145
 146 #elif defined(HAS_ALTZONE)
 147         /* check if daylight saving time is in effect */
 148         bias = aTime.tm_isdst > 0 ? altzone : timezone;
 149 #else
 150         /* exspect daylight saving time to be one hour */
 151         bias = aTime.tm_isdst > 0 ? timezone - 3600 : timezone;
 152 #endif
 153
 154         pTimeVal->Seconds = nSeconds;
 155         pTimeVal->Nanosec = pDateTime->NanoSeconds;
 156
 157         if ( nSeconds > bias )
 158             pTimeVal->Seconds -= bias;
 159
 160         return sal_True;
 161     }
 162
 163     return sal_False;
 164 }
 165
 166
 167 /*--------------------------------------------------
 168  * osl_getLocalTimeFromSystemTime
 169  *--------------------------------------------------*/
 170
 171 sal_Bool SAL_CALL osl_getLocalTimeFromSystemTime( TimeValue* pSystemTimeVal, TimeValue* pLocalTimeVal )
 172 {
 173     struct tm *pLocalTime;
 174     struct tm tmBuf;
 175     time_t bias;
 176     time_t atime;
 177
 178     atime = (time_t) pSystemTimeVal->Seconds;
 179     pLocalTime = localtime_r( &atime, &tmBuf );
 180
 181 #if defined(STRUCT_TM_HAS_GMTOFF)
 182     /* members of struct tm are corrected by mktime */
 183     bias = 0 - pLocalTime->tm_gmtoff;
 184
 185 #elif defined(HAS_ALTZONE)
 186     /* check if daylight saving time is in effect */
 187     bias = pLocalTime->tm_isdst > 0 ? altzone : timezone;
 188 #else
 189     /* exspect daylight saving time to be one hour */
 190     bias = pLocalTime->tm_isdst > 0 ? timezone - 3600 : timezone;
 191 #endif
 192
 193     if ( (sal_Int64) pSystemTimeVal->Seconds > bias )
 194     {
 195         pLocalTimeVal->Seconds = pSystemTimeVal->Seconds - bias;
 196         pLocalTimeVal->Nanosec = pSystemTimeVal->Nanosec;
 197
 198         return sal_True;
 199     }
 200
 201     return sal_False;
 202 }
 203
 204 /*--------------------------------------------------
 205  * osl_getSystemTimeFromLocalTime
 206  *--------------------------------------------------*/
 207
 208 sal_Bool SAL_CALL osl_getSystemTimeFromLocalTime( TimeValue* pLocalTimeVal, TimeValue* pSystemTimeVal )
 209 {
 210     struct tm *pLocalTime;
 211     struct tm tmBuf;
 212     time_t bias;
 213     time_t atime;
 214
 215     atime = (time_t) pLocalTimeVal->Seconds;
 216
 217     /* Convert atime, which is a local time, to it's GMT equivalent. Then, get
 218      * the timezone offset for the local time for the GMT equivalent time. Note
 219      * that we cannot directly use local time to determine the timezone offset
 220      * because GMT is the only reliable time that we can determine timezone
 221      * offset from.
 222      */
 223
 224     atime = mktime( gmtime_r( &atime, &tmBuf ) );
 225     pLocalTime = localtime_r( &atime, &tmBuf );
 226
 227 #if defined(STRUCT_TM_HAS_GMTOFF)
 228     /* members of struct tm are corrected by mktime */
 229     bias = 0 - pLocalTime->tm_gmtoff;
 230
 231 #elif defined(HAS_ALTZONE)
 232     /* check if daylight saving time is in effect */
 233     bias = pLocalTime->tm_isdst > 0 ? altzone : timezone;
 234 #else
 235     /* exspect daylight saving time to be one hour */
 236     bias = pLocalTime->tm_isdst > 0 ? timezone - 3600 : timezone;
 237 #endif
 238
 239     if ( (sal_Int64) pLocalTimeVal->Seconds + bias > 0 )
 240     {
 241         pSystemTimeVal->Seconds = pLocalTimeVal->Seconds + bias;
 242         pSystemTimeVal->Nanosec = pLocalTimeVal->Nanosec;
 243
 244         return sal_True;
 245     }
 246
 247     return sal_False;
 248 }
 249
 250
 251
 252 static struct timeval startTime;
 253 static sal_Bool bGlobalTimer = sal_False;
 254
 255 sal_uInt32 SAL_CALL osl_getGlobalTimer()
 256 {
 257   struct timeval currentTime;
 258   sal_uInt32 nSeconds;
 259
 260   // FIXME: not thread safe !!
 261   if ( bGlobalTimer == sal_False )
 262   {
 263       gettimeofday( &startTime, NULL );
 264       bGlobalTimer=sal_True;
 265   }
 266
 267   gettimeofday( &currentTime, NULL );
 268
 269   nSeconds = (sal_uInt32)( currentTime.tv_sec - startTime.tv_sec );
 270
 271   return ( nSeconds * 1000 ) + (long) (( currentTime.tv_usec - startTime.tv_usec) / 1000 );
 272 }