TimeInterface.cpp

00001 
00002 #include "TimeInterface.h"
00003 
00004 #include "rtc_api.h"
00005 
00006 //#define DEBUG "Time"
00007 #include <cstdio>
00008 #if (defined(DEBUG) && !defined(TARGET_LPC11U24))
00009 #define DBG(x, ...)  std::printf("[DBG %s %3d] "x"\r\n", DEBUG, __LINE__, ##__VA_ARGS__);
00010 #define WARN(x, ...) std::printf("[WRN %s %3d] "x"\r\n", DEBUG, __LINE__, ##__VA_ARGS__);
00011 #define ERR(x, ...)  std::printf("[ERR %s %3d] "x"\r\n", DEBUG, __LINE__, ##__VA_ARGS__);
00012 #define INFO(x, ...) std::printf("[INF %s %3d] "x"\r\n", DEBUG, __LINE__, ##__VA_ARGS__);
00013 #else
00014 #define DBG(x, ...)
00015 #define WARN(x, ...)
00016 #define ERR(x, ...)
00017 #define INFO(x, ...)
00018 #endif
00019 
00020 #ifdef WIN32
00021 // Fake it out for Win32 development and testing
00022 struct LPC {
00023     unsigned long CCR;          // Clock Control register
00024     unsigned long GPREG0;       // General Purpose Register #0 - 32-bit Battery backed
00025     unsigned long GPREG1;       // General Purpose Register #1 - 32-bit Battery backed
00026     unsigned long CALIBRATION;  // Calibration Register
00027 };
00028 struct LPC X;
00029 struct LPC * LPC_RTC = &X;
00030 #define set_time(x) (void)x
00031 #endif
00032 
00033 
00034 TimeInterface::TimeInterface(void *net)
00035 {
00036     m_net = net;
00037     dst = false;
00038     memset(&dst_pair, 0, sizeof(dst_pair));  // that's enough to keep it from running
00039 }
00040 
00041 TimeInterface::~TimeInterface()
00042 {
00043 }
00044 
00045 #if 0
00046 NTPResult TimeInterface::setTime(const char* host, uint16_t port, uint32_t timeout)
00047 {
00048     NTPResult res;
00049     
00050     if (m_net) {
00051         NTPClient ntp(m_net);
00052         // int16_t tzomin = get_tzo_min();
00053         INFO("setTime(%s, %d, %d)\r\n", host, port, timeout);
00054         res = ntp.setTime(host, port, timeout);
00055         INFO("  ret: %d\r\n", res);
00056         if (res == NTP_OK) {
00057             // if the time was fetched successfully, then
00058             // let's save the time last set with the local tzo applied
00059             // and this saves the last time set for later precision
00060             // tuning.
00061             set_time(std::time(NULL));
00062         }
00063     } else {
00064         ERR("No connection");
00065         res = NTP_CONN;
00066     }
00067     return res;
00068 }
00069 #endif
00070 
00071 bool TimeInterface::parseDSTstring(TimeInterface::dst_event_t * result, const char * dstr)
00072 {
00073     int x;
00074     dst_event_t test_dst;
00075 
00076     x = atoi(dstr);
00077     if (x >= 1 && x <= 12) {
00078         test_dst.MM = x;
00079         dstr = strchr(dstr, '/');
00080         if (dstr++) {
00081             x = atoi(dstr);
00082             if (x >= 1 && x <= 31) {
00083                 test_dst.DD = x;
00084                 dstr = strchr(dstr, ',');
00085                 if (dstr++) {
00086                     x = atoi(dstr);
00087                     if (x >= 0 && x <= 23) {
00088                         test_dst.hh = x;
00089                         dstr = strchr(dstr, ':');
00090                         if (dstr++) {
00091                             x = atoi(dstr);
00092                             if (x >= 0 && x <= 59) {
00093                                 test_dst.mm = x;
00094                                 memcpy(result, &test_dst, sizeof(dst_event_t));
00095                                 INFO("parsed: %d/%d %d:%02d", test_dst.MM, test_dst.DD, test_dst.hh, test_dst.mm);
00096                                 return true;
00097                             }
00098                         }
00099                     }
00100                 }
00101             }
00102         }
00103     }
00104     return false;
00105 }
00106 
00107 // parse MM/DD,hh:mm
00108 bool TimeInterface::set_dst(const char * dstStart, const char * dstStop)
00109 {
00110     dst_event_pair_t test_pair;
00111 
00112     if (parseDSTstring(&test_pair.dst_start, dstStart)
00113     && parseDSTstring(&test_pair.dst_stop, dstStop)) {
00114         memcpy(&dst_pair, &test_pair, sizeof(dst_event_pair_t));
00115         INFO("set_dst from (%s,%s)", dstStart, dstStop);
00116         return true;
00117     }
00118     WARN("failed to set_dst from (%s,%s)", dstStart, dstStop);
00119     return false;
00120 }
00121 
00122 bool TimeInterface::set_dst(bool isdst)
00123 {
00124     dst = isdst;
00125     return true;
00126 }
00127 
00128 bool TimeInterface::get_dst(void)
00129 {
00130     return dst;
00131 }
00132 
00133 clock_t TimeInterface::clock(void)
00134 {
00135     return std::clock();
00136 }
00137 
00138 time_t TimeInterface::time(time_t * timer)
00139 {
00140     return std::time(timer);
00141 }
00142 
00143 uint32_t TimeInterface::minutesSinceJan(int mon, int day, int hr, int min)
00144 {
00145     return (mon * 60 * 24 * 31) + (day * 60 * 24) + (hr * 60) + min;
00146 }
00147 
00148 time_t TimeInterface::timelocal(time_t * timer)
00149 {
00150     time_t privTime;
00151     struct tm * tminfo;
00152 
00153     if (dst_pair.dst_start.MM) {    // may have to change the dst
00154         std::time(&privTime);
00155         tminfo = std::localtime(&privTime);
00156 
00157         uint32_t min_since_jan = minutesSinceJan(tminfo->tm_mon + 1, tminfo->tm_mday, tminfo->tm_hour, tminfo->tm_min);
00158         uint32_t min_dst_start = minutesSinceJan(dst_pair.dst_start.MM, dst_pair.dst_start.DD, dst_pair.dst_start.hh, dst_pair.dst_start.mm) + get_tzo_min();
00159         uint32_t min_dst_stop  = minutesSinceJan(dst_pair.dst_stop.MM, dst_pair.dst_stop.DD, dst_pair.dst_stop.hh, dst_pair.dst_stop.mm) + get_tzo_min();
00160 
00161         if (min_since_jan >= min_dst_start && min_since_jan < min_dst_stop) {
00162             dst = 1;
00163             //INFO(" is dst: %u - %u - %u", min_since_jan, min_dst_start, min_dst_stop);
00164         } else {
00165             dst = 0;
00166             //INFO("not dst: %u - %u - %u", min_since_jan, min_dst_start, min_dst_stop);
00167         }
00168     }
00169     INFO(" timelocal: %u, %d, %d", std::time(timer), get_tzo_min(), dst);
00170     return std::time(timer) + get_tzo_min() * 60 + dst * 3600;
00171 }
00172 
00173 char * TimeInterface::ctime(const time_t * timer)
00174 {
00175     char * p = std::ctime(timer);
00176 
00177     if (strlen(p) < sizeof(result)) {
00178         strcpy(result, p);
00179         p = strchr(result, '\n');
00180         if (p)
00181             *p = '\0';
00182     } else {
00183         result[0] = '\0';
00184     }
00185     return result;
00186 }
00187 
00188 char * TimeInterface::asctime(const struct tm_ex * timeptr)
00189 {
00190     static const char wday_name[][4] = {
00191         "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
00192     };
00193     static const char mon_name[][4] = {
00194         "Jan", "Feb", "Mar", "Apr", "May", "Jun",
00195         "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
00196     };
00197     struct tm_ex tmp = *timeptr;
00198     
00199     tmp.tm_min += tmp.tm_tzo_min;
00200     if (tmp.tm_isdst)
00201         tmp.tm_min += 60;
00202     while (tmp.tm_min >= 60) {
00203         tmp.tm_min -= 60;
00204         tmp.tm_hour++;
00205     }
00206     while (tmp.tm_min < 0) {
00207         tmp.tm_min += 60;
00208         tmp.tm_hour--;
00209     }
00210     while (tmp.tm_hour >= 24) {
00211         tmp.tm_wday = (tmp.tm_wday + 1) % 7;
00212         tmp.tm_mday++;
00213         tmp.tm_hour -= 24;
00214     }
00215     while (tmp.tm_hour < 0) {
00216         tmp.tm_wday = (tmp.tm_wday + 6) % 7;
00217         tmp.tm_mday--;
00218         tmp.tm_hour += 24;
00219     }
00220     sprintf(result, "%.3s %.3s%3d %.2d:%.2d:%.2d %d",
00221             wday_name[tmp.tm_wday % 7],
00222             mon_name[tmp.tm_mon % 12],
00223             tmp.tm_mday % 99, tmp.tm_hour % 25,
00224             tmp.tm_min % 99, tmp.tm_sec % 99,
00225             1900 + tmp.tm_year);
00226     return result;
00227 }
00228 
00229 struct tm_ex * TimeInterface::gmtime(const time_t * timer)
00230 {
00231     time_t priv = *timer + get_tzo_min() * 60 + dst * 3600;
00232     struct tm * tmp = std::localtime(&priv);
00233 
00234     tm_ext.tm_sec     = tmp->tm_sec;
00235     tm_ext.tm_min     = tmp->tm_min;
00236     tm_ext.tm_hour    = tmp->tm_hour;
00237     tm_ext.tm_mday    = tmp->tm_mday;
00238     tm_ext.tm_mon     = tmp->tm_mon;
00239     tm_ext.tm_year    = tmp->tm_year;
00240     tm_ext.tm_wday    = tmp->tm_wday;
00241     tm_ext.tm_yday    = tmp->tm_yday;
00242     tm_ext.tm_isdst   = tmp->tm_isdst;
00243     tm_ext.tm_tzo_min = get_tzo_min();
00244     return &tm_ext;
00245 }
00246 
00247 struct tm_ex * TimeInterface::localtime(const time_t * timer)
00248 {
00249     struct tm * tmp = std::localtime(timer);
00250 
00251     tm_ext.tm_sec = tmp->tm_sec;
00252     tm_ext.tm_min = tmp->tm_min;
00253     tm_ext.tm_hour = tmp->tm_hour;
00254     tm_ext.tm_mday = tmp->tm_mday;
00255     tm_ext.tm_mon = tmp->tm_mon;
00256     tm_ext.tm_year = tmp->tm_year;
00257     tm_ext.tm_wday = tmp->tm_wday;
00258     tm_ext.tm_yday = tmp->tm_yday;
00259     tm_ext.tm_isdst = tmp->tm_isdst;
00260     tm_ext.tm_tzo_min = get_tzo_min();
00261     return &tm_ext;
00262 }
00263 
00264 time_t TimeInterface::mktime(struct tm_ex * timeptr)
00265 {
00266     timeptr->tm_tzo_min = get_tzo_min();
00267     return std::mktime((struct tm *)timeptr);
00268 }
00269 
00270 size_t TimeInterface::strftime(char * ptr, size_t maxsize, const char * format, const struct tm_ex * timeptr)
00271 {
00272     return std::strftime(ptr, maxsize, format, (struct tm *)timeptr);
00273 }
00274 
00275 double TimeInterface::difftime(time_t end, time_t beginning)
00276 {
00277     return std::difftime(end, beginning);
00278 }
00279 
00280 
00281 
00282 // time zone functions
00283 
00284 void TimeInterface::set_time(time_t t, int16_t tzo_min)
00285 {
00286     time_t tval = t - (tzo_min * 60);
00287     rtc_init();
00288     rtc_write(tval);
00289     LPC_RTC->GPREG1 = tval;
00290     INFO("set_time(%s)", ctime(&tval));
00291 }
00292 
00293 void TimeInterface::set_tzo_min(int16_t tzo_min)
00294 {
00295     uint16_t th;
00296     uint32_t treg;
00297 
00298     if (tzo_min >= -720 && tzo_min <= 720) {
00299         th = (uint16_t)(-tzo_min);
00300         treg = (th << 16) | (uint16_t)tzo_min;
00301         LPC_RTC->GPREG0 = treg;
00302         //printf("set_tzo(%d) %d is %08X\r\n", tzo, th, LPC_RTC->GPREG0);
00303     }
00304 }
00305 
00306 int16_t TimeInterface::get_tzo_min(void)
00307 {
00308     uint16_t th, tl;
00309 
00310     th = LPC_RTC->GPREG0 >> 16;
00311     tl = LPC_RTC->GPREG0;
00312     //printf("get_tzo() is %04X %04X\r\n", th, tl);
00313     if ((uint16_t)(th + tl) == 0) {
00314         return tl;
00315     } else {
00316         return 0;
00317     }
00318 }
00319 
00320 time_t TimeInterface::get_timelastset(void)
00321 {
00322     return LPC_RTC->GPREG1;
00323 }
00324 
00325 int32_t TimeInterface::get_cal()
00326 {
00327     int32_t calvalue = LPC_RTC->CALIBRATION & 0x3FFFF;
00328 
00329     if (calvalue & 0x20000) {
00330         calvalue = -(calvalue & 0x1FFFF);
00331     }
00332     return calvalue;
00333 }
00334 
00335 void TimeInterface::set_cal(int32_t calibration)
00336 {
00337     if (calibration) {
00338         if (calibration < 0) {
00339             calibration = (-calibration & 0x1FFFF) | 0x20000;
00340         }
00341         LPC_RTC->CCR = 0x000001; //(LPC_RTC->CCR & 0x0003);   // Clear CCALEN to enable it
00342     } else {
00343         LPC_RTC->CCR = 0x000011; //(LPC_RTC->CCR & 0x0003) | 0x0010;   // Set CCALEN to disable it
00344     }
00345     LPC_RTC->CALIBRATION = calibration;
00346 }
00347 
00348 bool TimeInterface::adjust_sec(int32_t adjustSeconds)
00349 {
00350     time_t lastSet = get_timelastset();
00351 
00352     if (lastSet != 0) {
00353         time_t seconds = time(NULL);    // get "now" according to the rtc
00354         int32_t delta = seconds - lastSet;
00355         //int32_t curCal = get_cal();   // calibration might want to leverage the current cal factor.
00356         int32_t calMAX = 131071;
00357         int32_t secPerDay = 86400;
00358         float errSecPerDay;
00359 
00360         // Convert the current calibration and the adjustment into
00361         // the new calibration value
00362         // assume it is +10sec and it has been 2days, then the adjustment
00363         // needs to be +5 sec per day, or one adjustment every 1/5th
00364         // of a day, or 1 adjustment every 86400/5 counts.
00365         // delta = now - then (number of elapsed seconds)
00366         if (adjustSeconds != 0 && delta != 0) {
00367             int32_t calFactor;
00368 
00369             // Make the clock correct
00370             seconds = seconds + adjustSeconds;
00371             set_time(seconds);
00372             // Compute the calibration factor
00373             errSecPerDay = (float)adjustSeconds / ((float)(delta)/secPerDay);
00374             calFactor = (int32_t)((float)secPerDay/errSecPerDay);
00375             if (abs(calFactor) < calMAX)
00376                 set_cal(calFactor);
00377         }
00378         return true;
00379     } else {
00380         return false;
00381     }
00382 }
00383 
00384 
00385 // #############################################################################
00386 /*
00387  * Enhancement to use a custom tm_ex struct and the time zone by D. Smart
00388  *  %Z
00389  *
00390  * Copyright (c) 1994 Powerdog Industries.  All rights reserved.
00391  *
00392  * Redistribution and use in source and binary forms, without
00393  * modification, are permitted provided that the following conditions
00394  * are met:
00395  * 1. Redistributions of source code must retain the above copyright
00396  *    notice, this list of conditions and the following disclaimer.
00397  * 2. Redistributions in binary form must reproduce the above copyright
00398  *    notice, this list of conditions and the following disclaimer
00399  *    in the documentation and/or other materials provided with the
00400  *    distribution.
00401  * 3. All advertising materials mentioning features or use of this
00402  *    software must display the following acknowledgement:
00403  *      This product includes software developed by Powerdog Industries.
00404  * 4. The name of Powerdog Industries may not be used to endorse or
00405  *    promote products derived from this software without specific prior
00406  *    written permission.
00407  *
00408  * THIS SOFTWARE IS PROVIDED BY POWERDOG INDUSTRIES ``AS IS'' AND ANY
00409  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
00410  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
00411  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE POWERDOG INDUSTRIES BE
00412  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
00413  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
00414  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
00415  * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
00416  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
00417  * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
00418  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
00419  */
00420 
00421 #define asizeof(a)      (sizeof (a) / sizeof ((a)[0]))
00422 
00423 struct dtconv {
00424     const char    *abbrev_month_names[12];
00425     const char    *month_names[12];
00426     const char    *abbrev_weekday_names[7];
00427     const char    *weekday_names[7];
00428     const char    *time_format;
00429     const char    *sdate_format;
00430     const char    *dtime_format;
00431     const char    *am_string;
00432     const char    *pm_string;
00433     const char    *ldate_format;
00434     const char    *zone_names[10];
00435     int8_t  zone_offsets[10];
00436 };
00437 
00438 static const struct dtconv    En_US = {
00439     {
00440         "Jan", "Feb", "Mar", "Apr", "May", "Jun",
00441         "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
00442     },
00443     {
00444         "January", "February", "March", "April",
00445         "May", "June", "July", "August",
00446         "September", "October", "November", "December"
00447     },
00448     { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" },
00449     {
00450         "Sunday", "Monday", "Tuesday", "Wednesday",
00451         "Thursday", "Friday", "Saturday"
00452     },
00453     "%H:%M:%S",
00454     "%m/%d/%y",
00455     "%a %b %e %T %Z %Y",
00456     "AM",
00457     "PM",
00458     "%A, %B, %e, %Y",
00459     { "UTC", "EST", "CST", "MST", "PST", "YST", "CAT", "HST", "CET", "EET", },
00460     {     0,    -5,    -6,    -7,    -8,    -9,   -10,   -10,    +1,    +2, },
00461 };
00462 
00463 
00464 #ifndef isprint
00465 #define in_range(c, lo, up)  ((uint8_t)c >= lo && (uint8_t)c <= up)
00466 #define isprint(c)           in_range(c, 0x20, 0x7f)
00467 #define isdigit(c)           in_range(c, '0', '9')
00468 #define isxdigit(c)          (isdigit(c) || in_range(c, 'a', 'f') || in_range(c, 'A', 'F'))
00469 #define islower(c)           in_range(c, 'a', 'z')
00470 #define isspace(c)           (c == ' ' || c == '\f' || c == '\n' || c == '\r' || c == '\t' || c == '\v')
00471 #endif
00472 
00473 
00474 const char * TimeInterface::strptime(const char *buf, const char *fmt, struct tm_ex *tm)
00475 {
00476     char c;
00477     const char *ptr;
00478     int i, len;
00479     size_t ndx;
00480     bool fSet_wday = false;     // so we can notice if the wday was set
00481     
00482     ptr = fmt;
00483     while (*ptr != 0) {
00484         if (*buf == 0)
00485             break;
00486 
00487         c = *ptr++;
00488 
00489         if (c != '%') {
00490             if (isspace(c))
00491                 while (*buf != 0 && isspace(*buf))
00492                     buf++;
00493             else if (c != *buf++)
00494                 return 0;
00495             continue;
00496         }
00497 
00498         c = *ptr++;
00499         switch (c) {
00500             case 0:
00501             case '%':
00502                 if (*buf++ != '%')
00503                     return 0;
00504                 break;
00505 
00506             case 'C':
00507                 buf = strptime(buf, En_US.ldate_format, tm);
00508                 if (buf == 0)
00509                     return 0;
00510                 break;
00511 
00512             case 'c':
00513                 buf = strptime(buf, "%x %X", tm);
00514                 if (buf == 0)
00515                     return 0;
00516                 break;
00517 
00518             case 'D':
00519                 buf = strptime(buf, "%m/%d/%y", tm);
00520                 if (buf == 0)
00521                     return 0;
00522                 break;
00523 
00524             case 'R':
00525                 buf = strptime(buf, "%H:%M", tm);
00526                 if (buf == 0)
00527                     return 0;
00528                 break;
00529 
00530             case 'r':
00531                 buf = strptime(buf, "%I:%M:%S %p", tm);
00532                 if (buf == 0)
00533                     return 0;
00534                 break;
00535 
00536             case 'T':
00537                 buf = strptime(buf, "%H:%M:%S", tm);
00538                 if (buf == 0)
00539                     return 0;
00540                 break;
00541 
00542             case 'X':
00543                 buf = strptime(buf, En_US.time_format, tm);
00544                 if (buf == 0)
00545                     return 0;
00546                 break;
00547 
00548             case 'x':
00549                 buf = strptime(buf, En_US.sdate_format, tm);
00550                 if (buf == 0)
00551                     return 0;
00552                 break;
00553 
00554             case 'j':
00555                 if (!isdigit(*buf))
00556                     return 0;
00557 
00558                 for (i = 0; *buf != 0 && isdigit(*buf); buf++) {
00559                     i *= 10;
00560                     i += *buf - '0';
00561                 }
00562                 if (i > 365)
00563                     return 0;
00564 
00565                 tm->tm_yday = i;
00566                 break;
00567 
00568             case 'M':
00569             case 'S':
00570                 if (*buf == 0 || isspace(*buf))
00571                     break;
00572 
00573                 if (!isdigit(*buf))
00574                     return 0;
00575 
00576                 for (i = 0; *buf != 0 && isdigit(*buf); buf++) {
00577                     i *= 10;
00578                     i += *buf - '0';
00579                 }
00580                 if (i > 59)
00581                     return 0;
00582 
00583                 if (c == 'M')
00584                     tm->tm_min = i;
00585                 else
00586                     tm->tm_sec = i;
00587 
00588                 if (*buf != 0 && isspace(*buf))
00589                     while (*ptr != 0 && !isspace(*ptr))
00590                         ptr++;
00591                 break;
00592 
00593             case 'H':
00594             case 'I':
00595             case 'k':
00596             case 'l':
00597                 if (!isdigit(*buf))
00598                     return 0;
00599 
00600                 for (i = 0; *buf != 0 && isdigit(*buf); buf++) {
00601                     i *= 10;
00602                     i += *buf - '0';
00603                 }
00604                 if (c == 'H' || c == 'k') {
00605                     if (i > 23)
00606                         return 0;
00607                 } else if (i > 11)
00608                     return 0;
00609 
00610                 tm->tm_hour = i;
00611 
00612                 if (*buf != 0 && isspace(*buf))
00613                     while (*ptr != 0 && !isspace(*ptr))
00614                         ptr++;
00615                 break;
00616 
00617             case 'p':
00618                 len = strlen(En_US.am_string);
00619                 if (strncasecmp(buf, En_US.am_string, len) == 0) {
00620                     if (tm->tm_hour > 12)
00621                         return 0;
00622                     if (tm->tm_hour == 12)
00623                         tm->tm_hour = 0;
00624                     buf += len;
00625                     break;
00626                 }
00627 
00628                 len = strlen(En_US.pm_string);
00629                 if (strncasecmp(buf, En_US.pm_string, len) == 0) {
00630                     if (tm->tm_hour > 12)
00631                         return 0;
00632                     if (tm->tm_hour != 12)
00633                         tm->tm_hour += 12;
00634                     buf += len;
00635                     break;
00636                 }
00637 
00638                 return 0;
00639 
00640             case 'A':
00641             case 'a':
00642                 for (ndx = 0; ndx < asizeof(En_US.weekday_names); ndx++) {
00643                     len = strlen(En_US.weekday_names[ndx]);
00644                     if (strncasecmp(buf, En_US.weekday_names[ndx], len) == 0)
00645                         break;
00646 
00647                     len = strlen(En_US.abbrev_weekday_names[ndx]);
00648                     if (strncasecmp(buf, En_US.abbrev_weekday_names[ndx], len) == 0)
00649                         break;
00650                 }
00651                 if (ndx == asizeof(En_US.weekday_names))
00652                     return 0;
00653                 fSet_wday = true;
00654                 tm->tm_wday = ndx;
00655                 buf += len;
00656                 break;
00657 
00658             case 'd':
00659             case 'e':
00660                 if (!isdigit(*buf))
00661                     return 0;
00662 
00663                 for (i = 0; *buf != 0 && isdigit(*buf); buf++) {
00664                     i *= 10;
00665                     i += *buf - '0';
00666                 }
00667                 if (i > 31)
00668                     return 0;
00669 
00670                 tm->tm_mday = i;
00671 
00672                 if (*buf != 0 && isspace(*buf))
00673                     while (*ptr != 0 && !isspace(*ptr))
00674                         ptr++;
00675                 break;
00676 
00677             case 'B':
00678             case 'b':
00679             case 'h':
00680                 for (ndx = 0; ndx < asizeof(En_US.month_names); ndx++) {
00681                     len = strlen(En_US.month_names[ndx]);
00682                     if (strncasecmp(buf, En_US.month_names[ndx], len) == 0)
00683                         break;
00684 
00685                     len = strlen(En_US.abbrev_month_names[ndx]);
00686                     if (strncasecmp(buf, En_US.abbrev_month_names[ndx], len) == 0)
00687                         break;
00688                 }
00689                 if (ndx == asizeof(En_US.month_names))
00690                     return 0;
00691 
00692                 tm->tm_mon = ndx;
00693                 buf += len;
00694                 break;
00695 
00696             case 'm':
00697                 if (!isdigit(*buf))
00698                     return 0;
00699 
00700                 for (i = 0; *buf != 0 && isdigit(*buf); buf++) {
00701                     i *= 10;
00702                     i += *buf - '0';
00703                 }
00704                 if (i < 1 || i > 12)
00705                     return 0;
00706 
00707                 tm->tm_mon = i - 1;
00708 
00709                 if (*buf != 0 && isspace(*buf))
00710                     while (*ptr != 0 && !isspace(*ptr))
00711                         ptr++;
00712                 break;
00713 
00714             case 'Y':
00715             case 'y':
00716                 if (*buf == 0 || isspace(*buf))
00717                     break;
00718 
00719                 if (!isdigit(*buf))
00720                     return 0;
00721 
00722                 for (i = 0; *buf != 0 && isdigit(*buf); buf++) {
00723                     i *= 10;
00724                     i += *buf - '0';
00725                 }
00726                 if (c == 'Y')
00727                     i -= 1900;
00728                 if (i < 0)
00729                     return 0;
00730 
00731                 tm->tm_year = i;
00732 
00733                 if (*buf != 0 && isspace(*buf))
00734                     while (*ptr != 0 && !isspace(*ptr))
00735                         ptr++;
00736                 break;
00737             case 'Z':
00738                 for (ndx = 0; ndx < asizeof(En_US.zone_names); ndx++) {
00739                     len = strlen(En_US.zone_names[ndx]);
00740                     if (strncasecmp(buf, En_US.zone_names[ndx], len) == 0)
00741                         break;
00742                 }
00743                 if (ndx == asizeof(En_US.zone_names))
00744                     return 0;
00745                 tm->tm_tzo_min = En_US.zone_offsets[ndx] * 60;
00746                 buf += len;
00747                 break;
00748         }
00749     }
00750     if (!fSet_wday) {
00751         if (mktime(tm) == (time_t)-1)
00752             tm->tm_wday = 7;
00753     }
00754     return buf;
00755 }