code.delx.au - gnu-emacs/blob - src/systime.h

   1 /* systime.h - System-dependent definitions for time manipulations.
   2    Copyright (C) 1992 Free Software Foundation, Inc.
   3
   4 This file is part of GNU Emacs.
   5
   6 GNU Emacs is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 1, or (at your option)
   9 any later version.
  10
  11 GNU Emacs is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Emacs; see the file COPYING.  If not, write to
  18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19
  20 #if defined (HAVE_TIMEVAL) && !defined (NEED_TIME_H)
  21 /* NEED_TIME_H is necessary because some versions of HP/UX shouldn't
  22    have this included; time.h should do the trick instead.  */
  23
  24 #include <sys/time.h>
  25
  26 #else
  27
  28 /* _h_BSDTYPES is checked because on ISC unix, socket.h includes
  29    both time.h and sys/time.h, and the later file is protected
  30    from repeated inclusion.  We just hope that other systems will
  31    use this guard either not at all, or similarly.  */
  32 #ifndef _h_BSDTYPES
  33 #include <time.h>
  34 #endif /* _h_BSDTYPES */
  35
  36 #endif
  37
  38 /* AIX needs both <sys/time.h> and <time.h>.  */
  39 #ifdef _AIX
  40 #include <time.h>
  41 #endif
  42
  43 /* SVr4 doesn't actually declare this in its #include files.  */
  44 #ifdef USG5_4
  45 extern long timezone;
  46 #endif
  47
  48 #ifdef VMS
  49 #ifdef VAXC
  50 #include "vmstime.h"
  51 #endif
  52 #endif
  53
  54 \f
  55 /* EMACS_TIME is the type to use to represent temporal intervals -
  56    struct timeval on some systems, int on others.  It can be passed as
  57    the timeout argument to the select  system call.
  58
  59    EMACS_SECS (TIME) is an rvalue for the seconds component of TIME.
  60    EMACS_SET_SECS (TIME, SECONDS) sets that to SECONDS.
  61
  62    EMACS_HAS_USECS is defined iff EMACS_TIME has a usecs component.
  63    EMACS_USECS (TIME) is an rvalue for the milliseconds component of TIME.
  64         This returns zero if EMACS_TIME doesn't have a milliseconds component.
  65    EMACS_SET_USECS (TIME, MILLISECONDS) sets that to MILLISECONDS.
  66         This does nothing if EMACS_TIME doesn't have a milliseconds component.
  67
  68    EMACS_SET_SECS_USECS (TIME, SECS, USECS) sets both components of TIME.
  69
  70    EMACS_GET_TIME (TIME) stores the current system time in TIME, which
  71         should be an lvalue.
  72    EMACS_SET_UTIMES (PATH, ATIME, MTIME) changes the last-access and
  73         last-modification times of the file named PATH to ATIME and
  74         MTIME, which are EMACS_TIMEs.
  75
  76    EMACS_ADD_TIME (DEST, SRC1, SRC2) adds SRC1 to SRC2 and stores the
  77         result in DEST.  SRC should not be negative.
  78
  79    EMACS_SUB_TIME (DEST, SRC1, SRC2) subtracts SRC2 from SRC1 and
  80         stores the result in DEST.  SRC should not be negative.
  81    EMACS_TIME_NEG_P (TIME) is true iff TIME is negative.
  82
  83 */
  84
  85 #ifdef HAVE_TIMEVAL
  86
  87 #define EMACS_HAS_USECS
  88
  89 #define EMACS_TIME struct timeval
  90 #define EMACS_SECS(time)                    ((time).tv_sec  + 0)
  91 #define EMACS_USECS(time)                   ((time).tv_usec + 0)
  92 #define EMACS_SET_SECS(time, seconds)       ((time).tv_sec  = (seconds))
  93 #define EMACS_SET_USECS(time, milliseconds) ((time).tv_usec = (milliseconds))
  94
  95 #define EMACS_GET_TIME(time)                                    \
  96 {                                                               \
  97   struct timezone dummy;                                        \
  98   gettimeofday (&(time), &dummy);                               \
  99 }
 100
 101 #define EMACS_ADD_TIME(dest, src1, src2)                        \
 102 {                                                               \
 103   (dest).tv_sec  = (src1).tv_sec  + (src2).tv_sec;              \
 104   (dest).tv_usec = (src1).tv_usec + (src2).tv_usec;             \
 105   if ((dest).tv_usec > 1000000)                                 \
 106     (dest).tv_usec -= 1000000, (dest).tv_sec++;                 \
 107 }
 108
 109 #define EMACS_SUB_TIME(dest, src1, src2)                        \
 110 {                                                               \
 111   (dest).tv_sec  = (src1).tv_sec  - (src2).tv_sec;              \
 112   (dest).tv_usec = (src1).tv_usec - (src2).tv_usec;             \
 113   if ((dest).tv_usec < 0)                                       \
 114     (dest).tv_usec += 1000000, (dest).tv_sec--;                 \
 115 }
 116
 117 #define EMACS_TIME_NEG_P(time)                                  \
 118   ((time).tv_sec < 0                                            \
 119    || ((time).tv_sec == 0                                       \
 120        && (time).tv_usec < 0))
 121
 122 #else /* ! defined (HAVE_TIMEVAL) */
 123
 124 #define EMACS_TIME int
 125 #define EMACS_SECS(time)                    (time)
 126 #define EMACS_USECS(time)                   0
 127 #define EMACS_SET_SECS(time, seconds)       ((time) = (seconds))
 128 #define EMACS_SET_USECS(time, usecs)        0
 129
 130 #define EMACS_GET_TIME(t) ((t) = time ((long *) 0))
 131 #define EMACS_ADD_TIME(dest, src1, src2) ((dest) = (src1) + (src2))
 132 #define EMACS_SUB_TIME(dest, src1, src2) ((dest) = (src1) - (src2))
 133 #define EMACS_TIME_NEG_P(t) ((t) < 0)
 134
 135 #endif /* ! defined (HAVE_TIMEVAL) */
 136
 137 #define EMACS_SET_SECS_USECS(time, secs, usecs)                 \
 138   (EMACS_SET_SECS (time, secs), EMACS_SET_USECS (time, usecs))
 139
 140 #ifdef USE_UTIME
 141
 142 #define EMACS_SET_UTIMES(path, atime, mtime)                    \
 143   {                                                             \
 144     time_t tv[2];                                               \
 145     tv[0] = EMACS_SECS (atime);                                 \
 146     tv[1] = EMACS_SECS (mtime);                                 \
 147     utime ((path), tv);                                         \
 148   }
 149
 150 #else /* ! defined (USE_UTIME) */
 151
 152 #define EMACS_SET_UTIMES(path, atime, mtime)                    \
 153   {                                                             \
 154     EMACS_TIME tv[2];                                           \
 155     tv[0] = atime;                                              \
 156     tv[1] = mtime;                                              \
 157     utimes ((path), tv);                                        \
 158   }
 159
 160 #endif /* ! defined (USE_UTIME) */
 161
 162 \f
 163
 164 /* EMACS_CURRENT_TIME_ZONE (int *OFFSET, int *SAVINGS_FLAG,
 165                             char *STANDARD_ABBR, char *SAVINGS_ABBR);
 166    expands to a statement which stores information about the current
 167    time zone in its arguments.
 168
 169    *OFFSET is set to the number of minutes EAST of Greenwich at which
 170    the site's time zone is located.  This should describe the offset
 171    to standard time only; if some sort of daylight savings time is in
 172    effect, that should not affect this value.  Note that the tm_gmtoff
 173    member of the struct tm returned by localtime is adjusted for
 174    daylight savings, so you don't want to use localtime to set
 175    *OFFSET; gettimeofday does the right thing.
 176
 177    *SAVINGS_FLAG is set to 1 if some sort of daylight savings time is
 178    currently in effect, or 0 if no seasonal adjustment is currently
 179    active.
 180
 181    *STANDARD_ABBR points to an array of at least 10 characters, which
 182    should be set to the standard abbreviation for the time zone name
 183    when daylight savings time is not active.  For example, EDT would
 184    be appropriate for the Eastern time zone of the USA.
 185
 186    *SAVINGS_ABBR points to an array of at least 10 characters, which
 187    should be set to the standard abbreviation for the time zone name
 188    when daylight savings time is active.  For example, EST would be
 189    appropriate for the Eastern time zone of the USA.
 190
 191    If the operating system cannot provide all this information, then
 192    this macro will not be defined.  */
 193
 194
 195 /* The operating system configuration file can define
 196    EMACS_CURRENT_TIME_ZONE.   If not, we'll take a shot at it here.  */
 197
 198 #ifndef EMACS_CURRENT_TIME_ZONE
 199
 200 /* System V derivatives have a timezone global variable.  */
 201 #if defined(USG) || defined(VMS)
 202 #define EMACS_GET_TZ_OFFSET(offset)                                     \
 203   do {                                                                  \
 204     tzset ();                                                           \
 205     *(offset) = timezone;                                               \
 206   } while (0)
 207 #endif
 208
 209 /* If we have timeval, then we have gettimeofday; that's half the battle.  */
 210 #if defined (HAVE_TIMEVAL) && !defined (EMACS_GET_TZ_OFFSET)
 211 #define EMACS_GET_TZ_OFFSET(offset)                                     \
 212   do {                                                                  \
 213     struct timeval dummy;                                               \
 214     struct timezone zoneinfo;                                           \
 215                                                                         \
 216     gettimeofday (&dummy, &zoneinfo);                                   \
 217     *(offset) = -zoneinfo.tz_minuteswest;                               \
 218   } while (0)
 219 #endif /* ! defined (HAVE_TIMEVAL) */
 220
 221 /* The following sane systems have a tzname array.  The timezone function
 222    is a stupid idea; timezone names can only be determined geographically,
 223    not by Greenwich offset.  */
 224 #if defined (ultrix) || defined (hpux) || defined (_AIX) || defined (USG) || defined(VMS)
 225
 226 #define EMACS_GET_TZ_NAMES(standard, savings)                           \
 227   do {                                                                  \
 228     extern char *tzname[2];                                             \
 229     strcpy ((standard), tzname[0]);                                     \
 230     strcpy ((savings), tzname[1]);                                      \
 231   } while (0)
 232
 233 #else /* ! defined (ultrix) || defined (hpux) || defined (_AIX) */
 234 /* If we are running SunOS, Mt. Xinu BSD, or MACH 2.5, these systems have a
 235    timezone function.  */
 236 #if (defined (hp9000) && ! defined (hpux) && defined (unix)) || defined (MACH) || defined (sun)
 237
 238 #define EMACS_GET_TZ_NAMES(standard, savings)                           \
 239   do {                                                                  \
 240     struct timeval dummy;                                               \
 241     struct timezone zoneinfo;                                           \
 242     extern char *timezone ();                                           \
 243                                                                         \
 244     gettimeofday (&dummy, &zoneinfo);                                   \
 245     strcpy ((standard), timezone (zoneinfo.tz_minuteswest, 0));         \
 246     strcpy ((savings),  timezone (zoneinfo.tz_minuteswest, 1));         \
 247   } while (0)
 248
 249 #endif /* ! (defined (hp9000) && ! defined (hpux) && defined (unix)) || defined (MACH) || defined (sun) */
 250 #endif /* ! defined (ultrix) || defined (hpux) || defined (_AIX) */
 251
 252 /* If we can get all the information we need, let's define the macro!  */
 253 #if defined (EMACS_GET_TZ_OFFSET) && defined (EMACS_GET_TZ_NAMES)
 254
 255 #define EMACS_CURRENT_TIME_ZONE(offset, savings_flag, standard, savings)\
 256   do {                                                                  \
 257     EMACS_TIME t;                                                       \
 258     long secs;                                                          \
 259     struct tm *tmp;                                                     \
 260                                                                         \
 261     EMACS_GET_TIME (t);                                                 \
 262     secs = EMACS_SECS (t);                                              \
 263     tmp = localtime (&secs);                                            \
 264     *(savings_flag) = tmp->tm_isdst;                                    \
 265                                                                         \
 266     EMACS_GET_TZ_OFFSET (offset);                                       \
 267     EMACS_GET_TZ_NAMES (standard, savings);                             \
 268   } while (0)
 269 #endif /* ! defined (EMACS_GET_TZ_OFFSET) && defined (EMACS_GET_TZ_NAMES) */
 270
 271 #endif /* EMACS_CURRENT_TIME_ZONE */