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