home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / unix / volume24 / cvs1.2upgrade / part02 / Patch02.02
Encoding:
Text File  |  1991-03-05  |  47.8 KB  |  1,625 lines
  1. !  * Initial revision
  2. !  * 
  3. !  */
  4.   
  5. ! /* minimal changes needed to get this file to work for CVS rather than RCS */
  6. ! /* #include "rcsbase.h" */
  7. ! #include <ctype.h>
  8. ! #include <time.h>
  9. ! #include "cvs.h"
  10. ! #define libId(x,y) static char x[] = y;
  11. ! #define P(x) ()
  12. ! #if !__STDC__
  13. ! #    define const
  14.   #endif
  15. + /* see also `RCS' in comment below */
  16. + 
  17. + libId(partId, "$Id: partime.c,v 1.1.1.1 91/01/18 12:18:12 berliner Exp $")
  18.   
  19. + #define given(v) (0 <= (v))
  20. + #define TMNULL (-1) /* Items not given are given this value */
  21. + #define TZ_OFFSET (24*60) /* TMNULL  <  zone_offset - TZ_OFFSET */
  22. + 
  23.   struct tmwent {
  24. !     const char *went;
  25. !     short wval;
  26.       char wflgs;
  27.       char wtype;
  28.   };
  29.       /* wflgs */
  30.   #define TWTIME 02    /* Word is a time value (absence implies date) */
  31.   #define TWDST  04    /* Word is a DST-type timezone */
  32. !     /* wtype */
  33. ! #define TM_MON    1    /* month name */
  34. ! #define TM_WDAY    2    /* weekday name */
  35. ! #define TM_ZON    3    /* time zone name */
  36. ! #define TM_LT    4    /* local time */
  37. ! #define TM_DST    5    /* daylight savings time */
  38. ! #define TM_12    6    /* AM, PM, NOON, or MIDNIGHT */
  39. !     /* wval (for wtype==TM_12) */
  40. ! #define T12_AM 1
  41. ! #define T12_PM 2
  42. ! #define T12_NOON 12
  43. ! #define T12_MIDNIGHT 0
  44.   
  45. ! static const struct tmwent tmwords [] = {
  46.       {"january",      0, 0, TM_MON},
  47.       {"february",     1, 0, TM_MON},
  48.       {"march",        2, 0, TM_MON},
  49. ***************
  50. *** 75,119 ****
  51.       {"saturday",     6, 0, TM_WDAY},
  52.   
  53.       {"gmt",          0*60, TWTIME, TM_ZON},   /* Greenwich */
  54. !     {"gst",          0*60, TWTIME, TM_ZON},
  55. !     {"gdt",          0*60, TWTIME+TWDST, TM_ZON},     /* ?? */
  56.   
  57.       {"ast",          4*60, TWTIME, TM_ZON},   /* Atlantic */
  58.       {"est",          5*60, TWTIME, TM_ZON},   /* Eastern */
  59.       {"cst",          6*60, TWTIME, TM_ZON},   /* Central */
  60.       {"mst",          7*60, TWTIME, TM_ZON},   /* Mountain */
  61.       {"pst",          8*60, TWTIME, TM_ZON},   /* Pacific */
  62. !     {"yst",          9*60, TWTIME, TM_ZON},   /* Yukon */
  63.       {"hst",          10*60, TWTIME, TM_ZON},  /* Hawaii */
  64. !     {"bst",          11*60, TWTIME, TM_ZON},  /* Bering */
  65.   
  66.       {"adt",          4*60, TWTIME+TWDST, TM_ZON},     /* Atlantic */
  67.       {"edt",          5*60, TWTIME+TWDST, TM_ZON},     /* Eastern */
  68.       {"cdt",          6*60, TWTIME+TWDST, TM_ZON},     /* Central */
  69.       {"mdt",          7*60, TWTIME+TWDST, TM_ZON},     /* Mountain */
  70.       {"pdt",          8*60, TWTIME+TWDST, TM_ZON},     /* Pacific */
  71. !     {"ydt",          9*60, TWTIME+TWDST, TM_ZON},     /* Yukon */
  72. !     {"hdt",          10*60, TWTIME+TWDST, TM_ZON},    /* Hawaii */
  73. !     {"bdt",          11*60, TWTIME+TWDST, TM_ZON},    /* Bering */
  74. ! 
  75. !     {"daylight",     1, TWTIME+TWDST, TM_ZON},        /* Local Daylight */
  76. !     {"standard",     1, TWTIME, TM_ZON},      /* Local Standard */
  77. !     {"std",          1, TWTIME, TM_ZON},      /*   "       "    */
  78. ! 
  79. !     {"am",           1, TWTIME, TM_AMPM},
  80. !     {"pm",           2, TWTIME, TM_AMPM},
  81. !     {"noon",         12,TWTIME+TW1200, 0},    /* Special frobs */
  82. !     {"midnight",     0, TWTIME+TW1200, 0},
  83. !     {"at",           (long)ptnoise, TWSPEC, 0},    /* Noise word */
  84.   
  85.       {0, 0, 0, 0},             /* Zero entry to terminate searches */
  86.   };
  87.   
  88. - #define TMWILD (-2)    /* Value meaning item specified as wild-card */
  89. -             /* (May use someday...) */
  90. - 
  91.   struct token {
  92. !     char *tcp;    /* pointer to string */
  93.       int tcnt;    /* # chars */
  94.       char tbrk;    /* "break" char */
  95.       char tbrkl;    /* last break char */
  96. --- 123,230 ----
  97.       {"saturday",     6, 0, TM_WDAY},
  98.   
  99.       {"gmt",          0*60, TWTIME, TM_ZON},   /* Greenwich */
  100. !     {"utc",          0*60, TWTIME, TM_ZON},
  101. !     {"ut",           0*60, TWTIME, TM_ZON},
  102.   
  103. +     {"nzst",        -12*60, TWTIME, TM_ZON},  /* New Zealand */
  104. +     {"jst",         -9*60, TWTIME, TM_ZON},   /* Japan */
  105. +     {"kst",         -9*60, TWTIME, TM_ZON},   /* Korea */
  106. +     {"ist",         -5*60-30, TWTIME, TM_ZON},/* India */
  107. +     {"eet",         -2*60, TWTIME, TM_ZON},   /* Eastern Europe */
  108. +     {"cet",         -1*60, TWTIME, TM_ZON},   /* Central Europe */
  109. +     {"met",         -1*60, TWTIME, TM_ZON},   /* Middle Europe */
  110. +     {"wet",          0*60, TWTIME, TM_ZON},   /* Western Europe */
  111. +     {"nst",          3*60+30, TWTIME, TM_ZON},/* Newfoundland */
  112.       {"ast",          4*60, TWTIME, TM_ZON},   /* Atlantic */
  113.       {"est",          5*60, TWTIME, TM_ZON},   /* Eastern */
  114.       {"cst",          6*60, TWTIME, TM_ZON},   /* Central */
  115.       {"mst",          7*60, TWTIME, TM_ZON},   /* Mountain */
  116.       {"pst",          8*60, TWTIME, TM_ZON},   /* Pacific */
  117. !     {"akst",         9*60, TWTIME, TM_ZON},   /* Alaska */
  118. !     {"hast",         10*60, TWTIME, TM_ZON},  /* Hawaii-Aleutian */
  119.       {"hst",          10*60, TWTIME, TM_ZON},  /* Hawaii */
  120. !     {"sst",          11*60, TWTIME, TM_ZON},  /* Samoa */
  121.   
  122. +     {"nzdt",        -12*60, TWTIME+TWDST, TM_ZON},    /* New Zealand */
  123. +     {"kdt",         -9*60, TWTIME+TWDST, TM_ZON},     /* Korea */
  124. +     {"bst",          0*60, TWTIME+TWDST, TM_ZON},     /* Britain */
  125. +     {"ndt",          2*60+30, TWTIME+TWDST, TM_ZON}, /*Newfoundland (DDST)*/
  126.       {"adt",          4*60, TWTIME+TWDST, TM_ZON},     /* Atlantic */
  127.       {"edt",          5*60, TWTIME+TWDST, TM_ZON},     /* Eastern */
  128.       {"cdt",          6*60, TWTIME+TWDST, TM_ZON},     /* Central */
  129.       {"mdt",          7*60, TWTIME+TWDST, TM_ZON},     /* Mountain */
  130.       {"pdt",          8*60, TWTIME+TWDST, TM_ZON},     /* Pacific */
  131. !     {"akdt",         9*60, TWTIME+TWDST, TM_ZON},     /* Alaska */
  132. !     {"hadt",         10*60, TWTIME+TWDST, TM_ZON},    /* Hawaii-Aleutian */
  133. ! 
  134. ! #if 0
  135. !     /*
  136. !      * The following names are duplicates or are not well attested.
  137. !      * A standard is needed.
  138. !      */
  139. !     {"?st",         -13*60, TWTIME, TM_ZON},  /* Uelen */
  140. !     {"?st",         -11*60, TWTIME, TM_ZON},  /* Magadan */
  141. !     {"east",        -10*60, TWTIME, TM_ZON},  /* Eastern Australia */
  142. !     {"cast",        -9*60-30, TWTIME, TM_ZON},/* Central Australia */
  143. !     {"cst",         -8*60, TWTIME, TM_ZON},   /* China */
  144. !     {"hkt",         -8*60, TWTIME, TM_ZON},   /* Hong Kong */
  145. !     {"sst",         -8*60, TWTIME, TM_ZON},   /* Singapore */
  146. !     {"wast",        -8*60, TWTIME, TM_ZON},   /* Western Australia */
  147. !     {"?st",         -7*60, TWTIME, TM_ZON},   /* Novosibirsk */
  148. !     {"jt",          -7*60-30, TWTIME, TM_ZON},/* Java */
  149. !     {"nst",         -6*60-30, TWTIME, TM_ZON},/* North Sumatra */
  150. !     {"?st",         -6*60, TWTIME, TM_ZON},   /* Tashkent */
  151. !     {"?st",         -5*60, TWTIME, TM_ZON},      /* Sverdlovsk */
  152. !     {"?",           -4*60-30, TWTIME, TM_ZON},/* Afghanistan */
  153. !     {"?st",         -4*60, TWTIME, TM_ZON},      /* Rostov */
  154. !     {"it",          -3*60-30, TWTIME, TM_ZON},/* Iran */
  155. !     {"?st",         -3*60, TWTIME, TM_ZON},   /* Moscow */
  156. !     {"ist",         -2*60, TWTIME, TM_ZON},   /* Israel */
  157. !     {"ast",          1*60, TWTIME, TM_ZON},   /* Azores */
  158. !     {"fst",          2*60, TWTIME, TM_ZON},   /* Fernando de Noronha */
  159. !     {"bst",          3*60, TWTIME, TM_ZON},   /* Brazil */
  160. !     {"wst",          4*60, TWTIME, TM_ZON},   /* Western Brazil */
  161. !     {"ast",          5*60, TWTIME, TM_ZON},   /* Acre Brazil */
  162. !     {"?",            9*60+30, TWTIME, TM_ZON},/* Marquesas */
  163. !     {"?st",          12*60, TWTIME, TM_ZON},  /* Kwajalein */
  164. ! 
  165. !     {"?dt",         -13*60, TWTIME+TWDST, TM_ZON},      /* Uelen */
  166. !     {"?dt",         -11*60, TWTIME+TWDST, TM_ZON},      /* Magadan */
  167. !     {"eadt",        -10*60, TWTIME+TWDST, TM_ZON},    /* Eastern Australia */
  168. !     {"cadt",        -9*60-30, TWTIME+TWDST, TM_ZON},  /* Central Australia */
  169. !     {"cdt",         -8*60, TWTIME+TWDST, TM_ZON},     /* China */
  170. !     {"wadt",        -8*60, TWTIME+TWDST, TM_ZON},     /* Western Australia */
  171. !     {"?dt",         -7*60, TWTIME+TWDST, TM_ZON},      /* Novosibirsk */
  172. !     {"?dt",         -6*60, TWTIME+TWDST, TM_ZON},      /* Tashkent */
  173. !     {"?dt",         -5*60, TWTIME+TWDST, TM_ZON},      /* Sverdlovsk */
  174. !     {"?dt",         -4*60, TWTIME+TWDST, TM_ZON},      /* Rostov */
  175. !     {"?dt",         -3*60, TWTIME+TWDST, TM_ZON},     /* Moscow */
  176. !     {"idt",         -2*60, TWTIME+TWDST, TM_ZON},     /* Israel */
  177. !     {"eest",        -2*60, TWTIME+TWDST, TM_ZON},     /* Eastern Europe */
  178. !     {"cest",        -1*60, TWTIME+TWDST, TM_ZON},     /* Central Europe */
  179. !     {"mest",        -1*60, TWTIME+TWDST, TM_ZON},     /* Middle Europe */
  180. !     {"west",         0*60, TWTIME+TWDST, TM_ZON},     /* Western Europe */
  181. !     {"adt",          1*60, TWTIME+TWDST, TM_ZON},      /* Azores */
  182. !     {"fdt",          2*60, TWTIME+TWDST, TM_ZON},     /* Fernando de Noronha */
  183. !     {"edt",          3*60, TWTIME+TWDST, TM_ZON},     /* Eastern Brazil */
  184. !     {"wdt",          4*60, TWTIME+TWDST, TM_ZON},     /* Western Brazil */
  185. !     {"adt",          5*60, TWTIME+TWDST, TM_ZON},     /* Acre Brazil */
  186. ! #endif
  187. ! 
  188. !     {"lt",           0, TWTIME, TM_LT},       /* local time */
  189. !     {"dst",          1*60, TWTIME, TM_DST},      /* daylight savings time */
  190. !     {"ddst",         2*60, TWTIME, TM_DST},      /* double dst */
  191. ! 
  192. !     {"am",           T12_AM,    TWTIME, TM_12},
  193. !     {"pm",           T12_PM,    TWTIME, TM_12},
  194. !     {"noon",         T12_NOON,    TWTIME, TM_12},
  195. !     {"midnight",     T12_MIDNIGHT,    TWTIME, TM_12},
  196.   
  197.       {0, 0, 0, 0},             /* Zero entry to terminate searches */
  198.   };
  199.   
  200.   struct token {
  201. !     const char *tcp;/* pointer to string */
  202.       int tcnt;    /* # chars */
  203.       char tbrk;    /* "break" char */
  204.       char tbrkl;    /* last break char */
  205. ***************
  206. *** 120,227 ****
  207.       char tflg;    /* 0 = alpha, 1 = numeric */
  208.       union {         /* Resulting value; */
  209.           int tnum;/* either a #, or */
  210. !         struct tmwent *ttmw;/* ptr to a tmwent. */
  211.       } tval;
  212.   };
  213.   
  214. ! partime(astr, atm)
  215. ! char *astr;
  216. ! struct tm *atm;
  217. ! {    register int *tp;
  218. !     register struct tmwent *twp;
  219. !     register int i;
  220. !     struct token btoken, atoken;
  221. !     char *cp, ch;
  222. !     int ord, midnoon;
  223. !     int (*aproc)();
  224. ! 
  225. !     tp = (int *)atm;
  226. !     zaptime(tp);             /* Initialize the TM structure */
  227. !     midnoon = TMNULL;        /* and our own temp stuff */
  228. !     btoken.tcnt = btoken.tbrkl = 0;
  229. !     btoken.tcp = astr;
  230.   
  231. ! domore:
  232. !     if(!ptitoken(btoken.tcp+btoken.tcnt,&btoken))    /* Get a token */
  233.         {     if(btoken.tval.tnum) return(0);         /* Read error? */
  234. !         if(midnoon != TMNULL)            /* EOF, wrap up */
  235. !             return(pt12hack(tp, midnoon));
  236. !         return(1);                /* Win return! */
  237.         }
  238.       if(btoken.tflg == 0)        /* Alpha? */
  239. !       {     twp = btoken.tval.ttmw;         /* Yes, get ptr to entry */
  240. !         if(twp->wflgs&TWSPEC)        /* Special alpha crock */
  241. !           {     aproc = (int (*) ()) (twp->wval);
  242. !             if(!(*aproc)(tp, twp, &btoken))
  243. !                 return(0);    /* ERR: special word err */
  244. !             goto domore;
  245. !           }
  246. !         if(twp->wflgs&TW1200)
  247. !             if(ptstash(&midnoon,(int)twp->wval))
  248. !                 return(0);    /* ERR: noon/midnite clash */
  249. !             else goto domore;
  250. !         if(ptstash(&tp[twp->wtype],(int)twp->wval))
  251.               return(0);        /* ERR: val already set */
  252. !         if(twp->wtype == TM_ZON)    /* If was zone, hack DST */
  253. !             if(ptstash(&tp[TM_ISDST],(twp->wflgs&TWDST)))
  254. !                 return(0);    /* ERR: DST conflict */
  255. !         goto domore;
  256.         }
  257.   
  258.       /* Token is number.  Lots of hairy heuristics. */
  259. !     if(btoken.tcnt >= 7)    /* More than 6 digits in string? */
  260. !         return(0);    /* ERR: number too big */
  261. !     if(btoken.tcnt == 6)    /* 6 digits = HHMMSS.  Needs special crock */
  262. !       {            /* since 6 digits are too big for integer! */
  263. !         i = (btoken.tcp[0]-'0')*10    /* Gobble 1st 2 digits */
  264. !            + btoken.tcp[1]-'0';
  265. !         btoken.tcnt = 2;        /* re-read last 4 chars */
  266. !         goto coltime;
  267. !       }
  268.   
  269.       i = btoken.tval.tnum;   /* Value now known to be valid; get it. */
  270. !     if( btoken.tcnt == 5    /*  5 digits = HMMSS */
  271. !      || btoken.tcnt == 3)    /*  3 digits = HMM   */
  272. !       {    if(btoken.tcnt != 3)
  273. !             if(ptstash(&tp[TM_SEC], i%100))
  274. !                 return(0);    /* ERR: sec conflict */
  275. !             else i /= 100;
  276. ! hhmm4:        if(ptstash(&tp[TM_MIN], i%100))
  277.               return(0);        /* ERR: min conflict */
  278.           i /= 100;
  279. ! hh2:            if(ptstash(&tp[TM_HOUR], i))
  280.               return(0);        /* ERR: hour conflict */
  281. !         goto domore;
  282.         }
  283.   
  284.       if(btoken.tcnt == 4)    /* 4 digits = YEAR or HHMM */
  285. !       {    if(tp[TM_YEAR] != TMNULL) goto hhmm4;    /* Already got yr? */
  286. !         if(tp[TM_HOUR] != TMNULL) goto year4;    /* Already got hr? */
  287. !         if((i%100) > 59) goto year4;        /* MM >= 60? */
  288.           if(btoken.tbrk == ':')            /* HHMM:SS ? */
  289. !             if( ptstash(&tp[TM_HOUR],i/100)
  290. !              || ptstash(&tp[TM_MIN], i%100))
  291.                   return(0);        /* ERR: hr/min clash */
  292.               else goto coltm2;        /* Go handle SS */
  293.           if(btoken.tbrk != ',' && btoken.tbrk != '/'
  294. !           && ptitoken(btoken.tcp+btoken.tcnt,&atoken)    /* Peek */
  295. !           && atoken.tflg == 0            /* alpha */
  296. !           && (atoken.tval.ttmw->wflgs&TWTIME))  /* HHMM-ZON */
  297.               goto hhmm4;
  298. !         if(btoken.tbrkl == '-'        /* DD-Mon-YYYY */
  299. !           || btoken.tbrkl == ','    /* Mon DD, YYYY */
  300. !           || btoken.tbrkl == '/'    /* MM/DD/YYYY */
  301. !           || btoken.tbrkl == '.'    /* DD.MM.YYYY */
  302. !           || btoken.tbrk == '-'        /* YYYY-MM-DD */
  303. !             ) goto year4;
  304. !         goto hhmm4;            /* Give up, assume HHMM. */
  305.         }
  306.   
  307.       /* From this point on, assume tcnt == 1 or 2 */
  308. !     /* 2 digits = YY, MM, DD, or HH (MM and SS caught at coltime) */
  309.       if(btoken.tbrk == ':')        /* HH:MM[:SS] */
  310.           goto coltime;        /*  must be part of time. */
  311. !     if(i > 31) goto yy2;        /* If >= 32, only YY poss. */
  312.   
  313.       /* Check for numerical-format date */
  314.       for (cp = "/-."; ch = *cp++;)
  315. --- 231,398 ----
  316.       char tflg;    /* 0 = alpha, 1 = numeric */
  317.       union {         /* Resulting value; */
  318.           int tnum;/* either a #, or */
  319. !         const struct tmwent *ttmw;/* ptr to a tmwent. */
  320.       } tval;
  321.   };
  322.   
  323. ! static const struct tmwent*ptmatchstr P((const char*,int,const struct tmwent*));
  324. ! static int pt12hack P((struct tm *,int));
  325. ! static int ptitoken P((struct token *));
  326. ! static int ptstash P((int *,int));
  327. ! static int pttoken P((struct token *));
  328. ! 
  329. !     static int
  330. ! goodzone(t, offset, am)
  331. !     register const struct token *t;
  332. !     int offset;
  333. !     int *am;
  334. ! {
  335. !     register int m;
  336. !     if (
  337. !         t->tflg  &&
  338. !         t->tcnt == 4+offset  &&
  339. !         (m = t->tval.tnum) <= 2400  &&
  340. !         isdigit(t->tcp[offset]) &&
  341. !         (m%=100) < 60
  342. !     ) {
  343. !         m += t->tval.tnum/100 * 60;
  344. !         if (t->tcp[offset-1]=='+')
  345. !             m = -m;
  346. !         *am = m;
  347. !         return 1;
  348. !     }
  349. !     return 0;
  350. ! }
  351. ! 
  352. !     int
  353. ! partime(astr, atm, zone)
  354. ! const char *astr;
  355. ! register struct tm *atm;
  356. ! int *zone;
  357. ! {
  358. !     register int i;
  359. !     struct token btoken, atoken;
  360. !     int zone_offset; /* minutes west of GMT, plus TZ_OFFSET */
  361. !     register const char *cp;
  362. !     register char ch;
  363. !     int ord, midnoon;
  364. !     int *atmfield, dst, m;
  365. !     int got1 = 0;
  366. ! 
  367. !     atm->tm_sec = TMNULL;
  368. !     atm->tm_min = TMNULL;
  369. !     atm->tm_hour = TMNULL;
  370. !     atm->tm_mday = TMNULL;
  371. !     atm->tm_mon = TMNULL;
  372. !     atm->tm_year = TMNULL;
  373. !     atm->tm_wday = TMNULL;
  374. !     atm->tm_yday = TMNULL;
  375. !     midnoon = TMNULL;        /* and our own temp stuff */
  376. !     zone_offset = TMNULL;
  377. !     dst = TMNULL;
  378. !     btoken.tcnt = btoken.tbrk = 0;
  379. !     btoken.tcp = astr;
  380.   
  381. !     for (;; got1=1) {
  382. !     if (!ptitoken(&btoken))                /* Get a token */
  383.         {     if(btoken.tval.tnum) return(0);         /* Read error? */
  384. !         if (given(midnoon))            /* EOF, wrap up */
  385. !             if (!pt12hack(atm, midnoon))
  386. !                 return 0;
  387. !         if (!given(atm->tm_min))
  388. !             atm->tm_min = 0;
  389. !         *zone  =
  390. !                 (given(zone_offset) ? zone_offset-TZ_OFFSET : 0)
  391. !             -    (given(dst) ? dst : 0);
  392. !         return got1;
  393.         }
  394.       if(btoken.tflg == 0)        /* Alpha? */
  395. !       {     i = btoken.tval.ttmw->wval;
  396. !         switch (btoken.tval.ttmw->wtype) {
  397. !           default:
  398. !             return 0;
  399. !           case TM_MON:
  400. !             atmfield = &atm->tm_mon;
  401. !             break;
  402. !           case TM_WDAY:
  403. !             atmfield = &atm->tm_wday;
  404. !             break;
  405. !           case TM_DST:
  406. !             atmfield = &dst;
  407. !             break;
  408. !           case TM_LT:
  409. !             if (ptstash(&dst, 0))
  410. !                 return 0;
  411. !             i = 48*60; /* local time magic number -- see maketime() */
  412. !             /* fall into */
  413. !           case TM_ZON:
  414. !             i += TZ_OFFSET;
  415. !             if (btoken.tval.ttmw->wflgs & TWDST)
  416. !                 if (ptstash(&dst, 60))
  417. !                     return 0;
  418. !             /* Peek ahead for offset immediately afterwards. */
  419. !             if (
  420. !                 (btoken.tbrk=='-' || btoken.tbrk=='+') &&
  421. !                 (atoken=btoken, ++atoken.tcnt, ptitoken(&atoken)) &&
  422. !                 goodzone(&atoken, 0, &m)
  423. !             ) {
  424. !                 i += m;
  425. !                 btoken = atoken;
  426. !             }
  427. !             atmfield = &zone_offset;
  428. !             break;
  429. !           case TM_12:
  430. !             atmfield = &midnoon;
  431. !         }
  432. !         if (ptstash(atmfield, i))
  433.               return(0);        /* ERR: val already set */
  434. !         continue;
  435.         }
  436.   
  437.       /* Token is number.  Lots of hairy heuristics. */
  438. !     if (!isdigit(*btoken.tcp)) {
  439. !         if (!goodzone(&btoken, 1, &m))
  440. !             return 0;
  441. !         zone_offset = TZ_OFFSET + m;
  442. !         continue;
  443. !     }
  444.   
  445.       i = btoken.tval.tnum;   /* Value now known to be valid; get it. */
  446. !     if (btoken.tcnt == 3)    /*  3 digits = HMM   */
  447. !       {
  448. ! hhmm4:        if (ptstash(&atm->tm_min, i%100))
  449.               return(0);        /* ERR: min conflict */
  450.           i /= 100;
  451. ! hh2:            if (ptstash(&atm->tm_hour, i))
  452.               return(0);        /* ERR: hour conflict */
  453. !         continue;
  454.         }
  455.   
  456. +     if (4 < btoken.tcnt)
  457. +         goto year4; /* far in the future */
  458.       if(btoken.tcnt == 4)    /* 4 digits = YEAR or HHMM */
  459. !       {    if (given(atm->tm_year)) goto hhmm4;    /* Already got yr? */
  460. !         if (given(atm->tm_hour)) goto year4;    /* Already got hr? */
  461.           if(btoken.tbrk == ':')            /* HHMM:SS ? */
  462. !             if ( ptstash(&atm->tm_hour, i/100)
  463. !               || ptstash(&atm->tm_min, i%100))
  464.                   return(0);        /* ERR: hr/min clash */
  465.               else goto coltm2;        /* Go handle SS */
  466.           if(btoken.tbrk != ',' && btoken.tbrk != '/'
  467. !           && (atoken=btoken, ptitoken(&atoken))    /* Peek */
  468. !           && ( atoken.tflg
  469. !              ? !isdigit(*atoken.tcp)
  470. !              : atoken.tval.ttmw->wflgs & TWTIME)) /* HHMM-ZON */
  471.               goto hhmm4;
  472. !         goto year4;            /* Give up, assume year. */
  473.         }
  474.   
  475.       /* From this point on, assume tcnt == 1 or 2 */
  476. !     /* 2 digits = MM, DD, or HH (MM and SS caught at coltime) */
  477.       if(btoken.tbrk == ':')        /* HH:MM[:SS] */
  478.           goto coltime;        /*  must be part of time. */
  479. !     if (31 < i)
  480. !         return 0;
  481.   
  482.       /* Check for numerical-format date */
  483.       for (cp = "/-."; ch = *cp++;)
  484. ***************
  485. *** 228,416 ****
  486.         {    ord = (ch == '.' ? 0 : 1);    /* n/m = D/M or M/D */
  487.           if(btoken.tbrk == ch)            /* "NN-" */
  488.             {    if(btoken.tbrkl != ch)
  489. !               {    if(ptitoken(btoken.tcp+btoken.tcnt,&atoken)
  490.                     && atoken.tflg == 0
  491.                     && atoken.tval.ttmw->wtype == TM_MON)
  492.                       goto dd2;
  493.                   if(ord)goto mm2; else goto dd2; /* "NN-" */
  494.                 }                /* "-NN-" */
  495. !             if(tp[TM_DAY] == TMNULL
  496. !             && tp[TM_YEAR] != TMNULL)    /* If "YY-NN-" */
  497.                   goto mm2;        /* then always MM */
  498.               if(ord)goto dd2; else goto mm2;
  499.             }
  500.           if(btoken.tbrkl == ch            /* "-NN" */
  501. !           && tp[ord ? TM_MON : TM_DAY] != TMNULL)
  502. !             if(tp[ord ? TM_DAY : TM_MON] == TMNULL)    /* MM/DD */
  503.                   if(ord)goto dd2; else goto mm2;
  504. -             else goto yy2;            /* "-YY" */
  505.         }
  506.   
  507. -     /* At this point only YY, DD, and HH are left.
  508. -      * YY is very unlikely since value is <= 32 and there was
  509. -      * no numerical format date.  Make one last try at YY
  510. -      * before dropping through to DD vs HH code.
  511. -      */
  512. -     if(btoken.tcnt == 2        /* If 2 digits */
  513. -       && tp[TM_HOUR] != TMNULL    /* and already have hour */
  514. -       && tp[TM_DAY] != TMNULL    /* and day, but  */
  515. -       && tp[TM_YEAR] == TMNULL)    /* no year, then assume */
  516. -         goto yy2;        /* that's what we have. */
  517. - 
  518.       /* Now reduced to choice between HH and DD */
  519. !     if(tp[TM_HOUR] != TMNULL) goto dd2;    /* Have hour? Assume day. */
  520. !     if(tp[TM_DAY] != TMNULL) goto hh2;    /* Have day? Assume hour. */
  521.       if(i > 24) goto dd2;            /* Impossible HH means DD */
  522. !     if(!ptitoken(btoken.tcp+btoken.tcnt, &atoken))    /* Read ahead! */
  523.           if(atoken.tval.tnum) return(0); /* ERR: bad token */
  524.           else goto dd2;            /* EOF, assume day. */
  525. !     if( atoken.tflg == 0        /* If next token is an alpha */
  526. !      && atoken.tval.ttmw->wflgs&TWTIME)  /* time-spec, assume hour */
  527.           goto hh2;        /* e.g. "3 PM", "11-EDT"  */
  528.   
  529. ! dd2:    if(ptstash(&tp[TM_DAY],i))    /* Store day (1 based) */
  530.           return(0);
  531. !     goto domore;
  532.   
  533. ! mm2:    if(ptstash(&tp[TM_MON], i-1))    /* Store month (make zero based) */
  534.           return(0);
  535. !     goto domore;
  536.   
  537. ! yy2:    i += 1900;
  538. ! year4:    if(ptstash(&tp[TM_YEAR],i))    /* Store year (full number) */
  539.           return(0);        /* ERR: year conflict */
  540. !     goto domore;
  541.   
  542.       /* Hack HH:MM[[:]SS] */
  543.   coltime:
  544. !     if(ptstash(&tp[TM_HOUR],i)) return(0);
  545. !     if(!ptitoken(btoken.tcp+btoken.tcnt,&btoken))
  546.           return(!btoken.tval.tnum);
  547.       if(!btoken.tflg) return(0);    /* ERR: HH:<alpha> */
  548.       if(btoken.tcnt == 4)        /* MMSS */
  549. !         if(ptstash(&tp[TM_MIN],btoken.tval.tnum/100)
  550. !           || ptstash(&tp[TM_SEC],btoken.tval.tnum%100))
  551.               return(0);
  552. !         else goto domore;
  553.       if(btoken.tcnt != 2
  554. !       || ptstash(&tp[TM_MIN],btoken.tval.tnum))
  555.           return(0);        /* ERR: MM bad */
  556. !     if(btoken.tbrk != ':') goto domore;    /* Seconds follow? */
  557. ! coltm2:    if(!ptitoken(btoken.tcp+btoken.tcnt,&btoken))
  558.           return(!btoken.tval.tnum);
  559.       if(!btoken.tflg || btoken.tcnt != 2    /* Verify SS */
  560. !       || ptstash(&tp[TM_SEC], btoken.tval.tnum))
  561.           return(0);        /* ERR: SS bad */
  562. !     goto domore;
  563.   }
  564.   
  565.   /* Store date/time value, return 0 if successful.
  566. !  * Fails if entry already set to a different value.
  567.    */
  568.   ptstash(adr,val)
  569.   int *adr;
  570.   {    register int *a;
  571. !     if( *(a=adr) != TMNULL)
  572. !         return(*a != val);
  573.       *a = val;
  574.       return(0);
  575.   }
  576.   
  577. ! /* This subroutine is invoked for NOON or MIDNIGHT when wrapping up
  578.    * just prior to returning from partime.
  579.    */
  580. ! pt12hack(atp, aval)
  581. ! int *atp, aval;
  582. ! {    register int *tp, i, h;
  583. !     tp = atp;
  584. !     if (((i=tp[TM_MIN]) && i != TMNULL)    /* Ensure mins, secs */
  585. !      || ((i=tp[TM_SEC]) && i != TMNULL))    /* are 0 or unspec'd */
  586. !         return(0);            /* ERR: MM:SS not 00:00 */
  587. !     i = aval;            /* Get 0 or 12 (midnite or noon) */
  588. !     if ((h = tp[TM_HOUR]) == TMNULL    /* If hour unspec'd, win */
  589. !      || h == 12)            /* or if 12:00 (matches either) */
  590. !         tp[TM_HOUR] = i;    /* Then set time */
  591. !     else if(!(i == 0        /* Nope, but if midnight and */
  592. !         &&(h == 0 || h == 24)))    /* time matches, can pass. */
  593. !             return(0);    /* ERR: HH conflicts */
  594. !     tp[TM_AMPM] = TMNULL;        /* Always reset this value if won */
  595. !     return(1);
  596.   }
  597.   
  598. - /* Null routine for no-op tokens */
  599. - 
  600. - ptnoise() { return(1); }
  601. - 
  602.   /* Get a token and identify it to some degree.
  603.    * Returns 0 on failure; token.tval will be 0 for normal EOF, otherwise
  604.    * hit error of some sort
  605.    */
  606.   
  607. ! ptitoken(astr, tkp)
  608.   register struct token *tkp;
  609. - char *astr;
  610.   {
  611. !     register char *cp;
  612. !     register int i;
  613.   
  614. !     tkp->tval.tnum = 0;
  615. !     if(pttoken(astr,tkp) == 0)
  616.   #ifdef DEBUG
  617. !     VOID printf("EOF\n");
  618. ! #endif DEBUG
  619.           return(0);
  620.       cp = tkp->tcp;
  621.   
  622.   #ifdef DEBUG
  623. !     i = cp[tkp->tcnt];
  624. !     cp[tkp->tcnt] = 0;
  625. !     VOID printf("Token: \"%s\" ",cp);
  626. !     cp[tkp->tcnt] = i;
  627. ! #endif DEBUG
  628. ! 
  629. !     if(tkp->tflg)
  630. !         for(i = tkp->tcnt; i > 0; i--)
  631. !             tkp->tval.tnum = (int)tkp->tval.tnum*10 + ((*cp++)-'0');
  632. !     else
  633. !       {     i = ptmatchstr(cp, tkp->tcnt, tmwords);
  634. !         tkp->tval.tnum = i ? i : -1;         /* Set -1 for error */
  635.   
  636.   #ifdef DEBUG
  637. !         if(!i) VOID printf("Not found!\n");
  638. ! #endif DEBUG
  639. ! 
  640. !         if(!i) return(0);
  641.         }
  642.   
  643.   #ifdef DEBUG
  644.       if(tkp->tflg)
  645.           VOID printf("Val: %d.\n",tkp->tval.tnum);
  646. !     else VOID printf("Found: \"%s\", val: %d., type %d\n",
  647.           tkp->tval.ttmw->went,tkp->tval.ttmw->wval,tkp->tval.ttmw->wtype);
  648. ! #endif DEBUG
  649.   
  650.       return(1);
  651.   }
  652.   
  653.   /* Read token from input string into token structure */
  654. ! pttoken(astr,tkp)
  655.   register struct token *tkp;
  656. - char *astr;
  657.   {
  658. !     register char *cp;
  659.       register int c;
  660.   
  661. !     tkp->tcp = cp = astr;
  662.       tkp->tbrkl = tkp->tbrk;        /* Set "last break" */
  663.       tkp->tcnt = tkp->tbrk = tkp->tflg = 0;
  664.   
  665.       while(c = *cp++)
  666.         {    switch(c)
  667.             {    case ' ': case '\t':    /* Flush all whitespace */
  668. !                 while((c = *cp++) && isspace(c));
  669. !                 cp--;        /* Drop thru to handle brk */
  670.               case '(': case ')':    /* Perhaps any non-alphanum */
  671.               case '-': case ',':    /* shd qualify as break? */
  672.               case '/': case ':': case '.':    /* Break chars */
  673.                   if(tkp->tcnt == 0)    /* If no token yet */
  674.                     {    tkp->tcp = cp;    /* ignore the brk */
  675. --- 399,606 ----
  676.         {    ord = (ch == '.' ? 0 : 1);    /* n/m = D/M or M/D */
  677.           if(btoken.tbrk == ch)            /* "NN-" */
  678.             {    if(btoken.tbrkl != ch)
  679. !               {
  680. !                 atoken = btoken;
  681. !                 atoken.tcnt++;
  682. !                 if (ptitoken(&atoken)
  683.                     && atoken.tflg == 0
  684.                     && atoken.tval.ttmw->wtype == TM_MON)
  685.                       goto dd2;
  686.                   if(ord)goto mm2; else goto dd2; /* "NN-" */
  687.                 }                /* "-NN-" */
  688. !             if (!given(atm->tm_mday)
  689. !               && given(atm->tm_year))    /* If "YYYY-NN-" */
  690.                   goto mm2;        /* then always MM */
  691.               if(ord)goto dd2; else goto mm2;
  692.             }
  693.           if(btoken.tbrkl == ch            /* "-NN" */
  694. !           && given(ord ? atm->tm_mon : atm->tm_mday))
  695. !             if (!given(ord ? atm->tm_mday : atm->tm_mon)) /* MM/DD */
  696.                   if(ord)goto dd2; else goto mm2;
  697.         }
  698.   
  699.       /* Now reduced to choice between HH and DD */
  700. !     if (given(atm->tm_hour)) goto dd2;    /* Have hour? Assume day. */
  701. !     if (given(atm->tm_mday)) goto hh2;    /* Have day? Assume hour. */
  702. !     if (given(atm->tm_mon)) goto dd2;    /* Have month? Assume day. */
  703.       if(i > 24) goto dd2;            /* Impossible HH means DD */
  704. !     atoken = btoken;
  705. !     if (!ptitoken(&atoken))            /* Read ahead! */
  706.           if(atoken.tval.tnum) return(0); /* ERR: bad token */
  707.           else goto dd2;            /* EOF, assume day. */
  708. !     if ( atoken.tflg
  709. !        ? !isdigit(*atoken.tcp)
  710. !        : atoken.tval.ttmw->wflgs & TWTIME)
  711. !         /* If next token is a time spec, assume hour */
  712.           goto hh2;        /* e.g. "3 PM", "11-EDT"  */
  713.   
  714. ! dd2:    if (ptstash(&atm->tm_mday, i))    /* Store day (1 based) */
  715.           return(0);
  716. !     continue;
  717.   
  718. ! mm2:    if (ptstash(&atm->tm_mon, i-1))    /* Store month (make zero based) */
  719.           return(0);
  720. !     continue;
  721.   
  722. ! year4:    if ((i-=1900) < 0  ||  ptstash(&atm->tm_year, i)) /* Store year-1900 */
  723.           return(0);        /* ERR: year conflict */
  724. !     continue;
  725.   
  726.       /* Hack HH:MM[[:]SS] */
  727.   coltime:
  728. !     if (ptstash(&atm->tm_hour, i)) return 0;
  729. !     if (!ptitoken(&btoken))
  730.           return(!btoken.tval.tnum);
  731.       if(!btoken.tflg) return(0);    /* ERR: HH:<alpha> */
  732.       if(btoken.tcnt == 4)        /* MMSS */
  733. !         if (ptstash(&atm->tm_min, btoken.tval.tnum/100)
  734. !           || ptstash(&atm->tm_sec, btoken.tval.tnum%100))
  735.               return(0);
  736. !         else continue;
  737.       if(btoken.tcnt != 2
  738. !       || ptstash(&atm->tm_min, btoken.tval.tnum))
  739.           return(0);        /* ERR: MM bad */
  740. !     if (btoken.tbrk != ':') continue;    /* Seconds follow? */
  741. ! coltm2:    if (!ptitoken(&btoken))
  742.           return(!btoken.tval.tnum);
  743.       if(!btoken.tflg || btoken.tcnt != 2    /* Verify SS */
  744. !       || ptstash(&atm->tm_sec, btoken.tval.tnum))
  745.           return(0);        /* ERR: SS bad */
  746. !     }
  747.   }
  748.   
  749.   /* Store date/time value, return 0 if successful.
  750. !  * Fail if entry is already set.
  751.    */
  752. +     static int
  753.   ptstash(adr,val)
  754.   int *adr;
  755. + int val;
  756.   {    register int *a;
  757. !     if (given(*(a=adr)))
  758. !         return 1;
  759.       *a = val;
  760.       return(0);
  761.   }
  762.   
  763. ! /* This subroutine is invoked for AM, PM, NOON and MIDNIGHT when wrapping up
  764.    * just prior to returning from partime.
  765.    */
  766. !     static int
  767. ! pt12hack(tm, aval)
  768. ! register struct tm *tm;
  769. ! register int aval;
  770. ! {    register int h = tm->tm_hour;
  771. !     switch (aval) {
  772. !       case T12_AM:
  773. !       case T12_PM:
  774. !         if (h > 12)
  775. !             return 0;
  776. !         if (h == 12)
  777. !             tm->tm_hour = 0;
  778. !         if (aval == T12_PM)
  779. !             tm->tm_hour += 12;
  780. !         break;
  781. !       default:
  782. !         if (0 < tm->tm_min  ||  0 < tm->tm_sec)
  783. !             return 0;
  784. !         if (!given(h) || h==12)
  785. !             tm->tm_hour = aval;
  786. !         else if (aval==T12_MIDNIGHT  &&  (h==0 || h==24))
  787. !             return 0;
  788. !     }
  789. !     return 1;
  790.   }
  791.   
  792.   /* Get a token and identify it to some degree.
  793.    * Returns 0 on failure; token.tval will be 0 for normal EOF, otherwise
  794.    * hit error of some sort
  795.    */
  796.   
  797. !     static int
  798. ! ptitoken(tkp)
  799.   register struct token *tkp;
  800.   {
  801. !     register const char *cp;
  802. !     register int i, j, k;
  803.   
  804. !     if (!pttoken(tkp))
  805.   #ifdef DEBUG
  806. !         {
  807. !         VOID printf("EOF\n");
  808. !         return(0);
  809. !         }
  810. ! #else
  811.           return(0);
  812. + #endif    
  813.       cp = tkp->tcp;
  814.   
  815.   #ifdef DEBUG
  816. !     VOID printf("Token: \"%.*s\" ", tkp->tcnt, cp);
  817. ! #endif
  818.   
  819. +     if (tkp->tflg) {
  820. +         i = tkp->tcnt;
  821. +         if (*cp == '+' || *cp == '-') {
  822. +             cp++;
  823. +             i--;
  824. +         }
  825. +         while (0 <= --i) {
  826. +             j = tkp->tval.tnum*10;
  827. +             k = j + (*cp++ - '0');
  828. +             if (j/10 != tkp->tval.tnum  ||  k < j) {
  829. +                 /* arithmetic overflow */
  830. +                 tkp->tval.tnum = 1;
  831. +                 return 0;
  832. +             }
  833. +             tkp->tval.tnum = k;
  834. +         }
  835. +     } else if (!(tkp->tval.ttmw  =  ptmatchstr(cp, tkp->tcnt, tmwords)))
  836. +       {
  837.   #ifdef DEBUG
  838. !         VOID printf("Not found!\n");
  839. ! #endif
  840. !         tkp->tval.tnum = 1;
  841. !         return 0;
  842.         }
  843.   
  844.   #ifdef DEBUG
  845.       if(tkp->tflg)
  846.           VOID printf("Val: %d.\n",tkp->tval.tnum);
  847. !     else VOID printf("Found: \"%s\", val: %d, type %d\n",
  848.           tkp->tval.ttmw->went,tkp->tval.ttmw->wval,tkp->tval.ttmw->wtype);
  849. ! #endif
  850.   
  851.       return(1);
  852.   }
  853.   
  854.   /* Read token from input string into token structure */
  855. !     static int
  856. ! pttoken(tkp)
  857.   register struct token *tkp;
  858.   {
  859. !     register const char *cp;
  860.       register int c;
  861. +     const char *astr;
  862.   
  863. !     tkp->tcp = astr = cp = tkp->tcp + tkp->tcnt;
  864.       tkp->tbrkl = tkp->tbrk;        /* Set "last break" */
  865.       tkp->tcnt = tkp->tbrk = tkp->tflg = 0;
  866. +     tkp->tval.tnum = 0;
  867.   
  868.       while(c = *cp++)
  869.         {    switch(c)
  870.             {    case ' ': case '\t':    /* Flush all whitespace */
  871. !             case '\r': case '\n':
  872. !             case '\v': case '\f':
  873. !                 if (!tkp->tcnt) {    /* If no token yet */
  874. !                     tkp->tcp = cp;    /* ignore the brk */
  875. !                     continue;    /* and go on. */
  876. !                 }
  877. !                 /* fall into */
  878.               case '(': case ')':    /* Perhaps any non-alphanum */
  879.               case '-': case ',':    /* shd qualify as break? */
  880. +             case '+':
  881.               case '/': case ':': case '.':    /* Break chars */
  882.                   if(tkp->tcnt == 0)    /* If no token yet */
  883.                     {    tkp->tcp = cp;    /* ignore the brk */
  884. ***************
  885. *** 420,476 ****
  886.                   tkp->tbrk = c;
  887.                   return(tkp->tcnt);
  888.             }
  889. !         if(tkp->tcnt == 0)        /* If first char of token, */
  890. !             tkp->tflg = isdigit(c);    /*    determine type */
  891. !           if(( isdigit(c) &&  tkp->tflg)    /* If not first, make sure */
  892. !          ||(!isdigit(c) && !tkp->tflg))    /*    char matches type */
  893. !             tkp->tcnt++;        /* Win, add to token. */
  894. !         else {
  895. !             cp--;            /* Wrong type, back up */
  896.               tkp->tbrk = c;
  897. !             return(tkp->tcnt);
  898. !           }
  899.         }
  900.       return(tkp->tcnt);        /* When hit EOF */
  901.   }
  902.   
  903.   
  904.   ptmatchstr(astr,cnt,astruc)
  905. ! char *astr;
  906. ! int cnt;
  907. ! struct tmwent *astruc;
  908. ! {    register char *cp, *mp;
  909.       register int c;
  910. !     struct tmwent *lastptr;
  911. !     struct integ { int word; };   /* For getting at array ptr */
  912.       int i;
  913.   
  914.       lastptr = 0;
  915. !     for(;mp = (char *)((struct integ *)astruc)->word; astruc += 1)
  916.         {    cp = astr;
  917.           for(i = cnt; i > 0; i--)
  918. !           {    switch((c = *cp++) ^ *mp++)    /* XOR the chars */
  919.                 {    case 0: continue;    /* Exact match */
  920. !                 case 040: if(isalpha(c))
  921.                       continue;
  922.                 }
  923.               break;
  924.             }
  925.           if(i==0)
  926. !             if(*mp == 0) return((unsigned int)astruc);    /* Exact match */
  927.               else if(lastptr) return(0);    /* Ambiguous */
  928.               else lastptr = astruc;        /* 1st ambig */
  929.         }
  930. !     return((unsigned int)lastptr);
  931. ! }
  932. ! 
  933. ! 
  934. ! 
  935. ! zaptime(tp)
  936. ! register int *tp;
  937. ! /* clears tm structure pointed to by tp */
  938. ! {    register int i;
  939. !     i = (sizeof (struct tm))/(sizeof (int));
  940. !     do *tp++ = TMNULL;        /* Set entry to "unspecified" */
  941. !     while(--i);            /* Faster than FOR */
  942.   }
  943. --- 610,662 ----
  944.                   tkp->tbrk = c;
  945.                   return(tkp->tcnt);
  946.             }
  947. !         if (!tkp->tcnt++) {        /* If first char of token, */
  948. !             if (isdigit(c)) {
  949. !                 tkp->tflg = 1;
  950. !                 if (astr<cp-2 && (cp[-2]=='-'||cp[-2]=='+')) {
  951. !                     /* timezone is break+sign+digit */
  952. !                     tkp->tcp--;
  953. !                     tkp->tcnt++;
  954. !                 }
  955. !             }
  956. !         } else if ((isdigit(c)!=0) != tkp->tflg) { /* else check type */
  957.               tkp->tbrk = c;
  958. !             return --tkp->tcnt;    /* Wrong type, back up */
  959. !         }
  960.         }
  961.       return(tkp->tcnt);        /* When hit EOF */
  962.   }
  963.   
  964.   
  965. +     static const struct tmwent *
  966.   ptmatchstr(astr,cnt,astruc)
  967. !     const char *astr;
  968. !     int cnt;
  969. !     const struct tmwent *astruc;
  970. ! {
  971. !     register const char *cp, *mp;
  972.       register int c;
  973. !     const struct tmwent *lastptr;
  974.       int i;
  975.   
  976.       lastptr = 0;
  977. !     for(;mp = astruc->went; astruc += 1)
  978.         {    cp = astr;
  979.           for(i = cnt; i > 0; i--)
  980. !           {
  981. !             switch (*cp++ - (c = *mp++))
  982.                 {    case 0: continue;    /* Exact match */
  983. !                 case 'A'-'a':
  984. !                     /* `if (ctab[c]==Letter)' in RCS */
  985. !                     if (islower(c))
  986.                       continue;
  987.                 }
  988.               break;
  989.             }
  990.           if(i==0)
  991. !             if (!*mp) return astruc;    /* Exact match */
  992.               else if(lastptr) return(0);    /* Ambiguous */
  993.               else lastptr = astruc;        /* 1st ambig */
  994.         }
  995. !     return lastptr;
  996.   }
  997. diff -c src/patch.c:1.6 src/patch.c:1.6.1.1
  998. *** src/patch.c:1.6    Wed Feb  6 11:32:13 1991
  999. --- src/patch.c    Wed Feb  6 11:32:14 1991
  1000. ***************
  1001. *** 1,5 ****
  1002.   #ifndef lint
  1003. ! static char rcsid[] = "$Id: patch.c,v 1.6 90/02/14 10:01:33 berliner Exp $";
  1004.   #endif !lint
  1005.   
  1006.   /*
  1007. --- 1,5 ----
  1008.   #ifndef lint
  1009. ! static char rcsid[] = "$Id: patch.c,v 1.6.1.1 91/01/18 12:18:45 berliner Exp $";
  1010.   #endif !lint
  1011.   
  1012.   /*
  1013. ***************
  1014. *** 22,29 ****
  1015.   #include <ctype.h>
  1016.   #include "cvs.h"
  1017.   
  1018. - extern long maketime();
  1019. - 
  1020.   extern char update_dir[];
  1021.   extern DBM *open_module();
  1022.   extern int force_tag_match;
  1023. --- 22,27 ----
  1024. ***************
  1025. *** 106,112 ****
  1026.       error(0, "must specify at least one revision/date!");
  1027.       }
  1028.       if (date1[0] != '\0' && date2[0] != '\0') {
  1029. !     if (strcmp(date1, date2) >= 0)
  1030.           error(0, "second date must come after first date!");
  1031.       }
  1032.       (void) signal(SIGHUP, patch_cleanup);
  1033. --- 104,110 ----
  1034.       error(0, "must specify at least one revision/date!");
  1035.       }
  1036.       if (date1[0] != '\0' && date2[0] != '\0') {
  1037. !     if (datecmp(date1, date2) >= 0)
  1038.           error(0, "second date must come after first date!");
  1039.       }
  1040.       (void) signal(SIGHUP, patch_cleanup);
  1041. ***************
  1042. *** 379,395 ****
  1043.           if (*cp && (semi = index(cp, ';')) != NULL) {
  1044.           ret = 0;
  1045.           *semi = '\0';
  1046. !         ftm = &tm;
  1047. !         zaptime((int *)ftm);
  1048. !         (void) sscanf(cp, DATEFORM, &ftm->tm_year, &ftm->tm_mon,
  1049. !                   &ftm->tm_mday, &ftm->tm_hour, &ftm->tm_min,
  1050. !                   &ftm->tm_sec);
  1051. !         ftm->tm_mon--;
  1052. !         revdate = (time_t)maketime(ftm) - 1;
  1053. !         ftm = localtime(&revdate);
  1054. !         (void) sprintf(date, DATEFORM, ftm->tm_year, ftm->tm_mon+1,
  1055. !                    ftm->tm_mday, ftm->tm_hour, ftm->tm_min,
  1056. !                    ftm->tm_sec);
  1057.           }
  1058.           break;
  1059.       }
  1060. --- 377,383 ----
  1061.           if (*cp && (semi = index(cp, ';')) != NULL) {
  1062.           ret = 0;
  1063.           *semi = '\0';
  1064. !         semi[-1]--;    /* This works even if semi[-1] was '0'.  */
  1065.           }
  1066.           break;
  1067.       }
  1068. diff -c src/patchlevel.h:1.1 src/patchlevel.h:1.1.1.1
  1069. *** src/patchlevel.h:1.1    Wed Feb  6 11:32:12 1991
  1070. --- src/patchlevel.h    Wed Feb  6 11:32:12 1991
  1071. ***************
  1072. *** 1,3 ****
  1073. ! /*    $Id: patchlevel.h,v 1.1 89/11/20 00:06:30 berliner Exp $    */
  1074.   
  1075. ! #define    PATCHLEVEL    0
  1076. --- 1,3 ----
  1077. ! /*    $Id: patchlevel.h,v 1.1.1.1 91/01/18 12:19:46 berliner Exp $    */
  1078.   
  1079. ! #define    PATCHLEVEL    2
  1080. diff -c src/rcstime.h:1.1 src/rcstime.h:removed
  1081. *** src/rcstime.h:1.1    Wed Feb  6 11:32:08 1991
  1082. --- src/rcstime.h    Wed Feb  6 11:32:08 1991
  1083. ***************
  1084. *** 1,42 ****
  1085. - #define TIMEID "$Id: rcstime.h,v 1.1 89/05/09 11:51:03 berliner Exp $"
  1086. - 
  1087. - /* Structure for use by time manipulating subroutines.
  1088. -  * The following library routines use it:
  1089. -  *    libc: ctime, localtime, gmtime, asctime
  1090. -  *    libcx: partime, maketime (may not be installed yet)
  1091. -  */
  1092. - 
  1093. - struct tm {     /* See defines below for allowable ranges */
  1094. -     int tm_sec;
  1095. -     int tm_min;
  1096. -     int tm_hour;
  1097. -     int tm_mday;
  1098. -     int tm_mon;
  1099. -     int tm_year;
  1100. -     int tm_wday;
  1101. -     int tm_yday;
  1102. -     int tm_isdst;
  1103. -     int tm_zon;    /* NEW: mins westward of Greenwich */
  1104. -     int tm_ampm;    /* NEW: 1 if AM, 2 if PM */
  1105. - };
  1106. - 
  1107. - #define LCLZONE (5*60)    /* Until V7 ftime(2) works, this defines local zone*/
  1108. - #define TMNULL (-1)    /* Items not specified are given this value
  1109. -              * in order to distinguish null specs from zero
  1110. -              * specs.  This is only used by partime and
  1111. -              * maketime. */
  1112. - 
  1113. -     /* Indices into TM structure */
  1114. - #define TM_SEC 0    /* 0-59            */
  1115. - #define TM_MIN 1    /* 0-59            */
  1116. - #define TM_HOUR 2    /* 0-23            */
  1117. - #define TM_MDAY 3    /* 1-31            day of month */
  1118. - #define TM_DAY TM_MDAY    /*  "            synonym      */
  1119. - #define TM_MON 4    /* 0-11            */
  1120. - #define TM_YEAR 5    /* (year-1900) (year)    */
  1121. - #define TM_WDAY 6    /* 0-6            day of week (0 = Sunday) */
  1122. - #define TM_YDAY 7    /* 0-365        day of year */
  1123. - #define TM_ISDST 8    /* 0 Std, 1 DST        */
  1124. -     /* New stuff */
  1125. - #define TM_ZON 9    /* 0-(24*60) minutes west of Greenwich */
  1126. - #define TM_AMPM 10    /* 1 AM, 2 PM        */
  1127. --- 0 ----
  1128. diff -c src/subr.c:1.14 src/subr.c:1.14.1.2
  1129. *** src/subr.c:1.14    Wed Feb  6 11:32:11 1991
  1130. --- src/subr.c    Wed Feb  6 11:32:11 1991
  1131. ***************
  1132. *** 1,5 ****
  1133.   #ifndef lint
  1134. ! static char rcsid[] = "$Id: subr.c,v 1.14 89/11/20 09:51:10 berliner Exp $";
  1135.   #endif !lint
  1136.   
  1137.   /*
  1138. --- 1,5 ----
  1139.   #ifndef lint
  1140. ! static char rcsid[] = "$Id: subr.c,v 1.14.1.2 91/01/29 19:46:20 berliner Exp $";
  1141.   #endif !lint
  1142.   
  1143.   /*
  1144. ***************
  1145. *** 114,120 ****
  1146.   
  1147.       if (stat(file, &sb) < 0)
  1148.       return (0);
  1149. !     return ((sb.st_mode & S_IFMT) & S_IFDIR);
  1150.   }
  1151.   
  1152.   /*
  1153. --- 114,120 ----
  1154.   
  1155.       if (stat(file, &sb) < 0)
  1156.       return (0);
  1157. !     return ((sb.st_mode & S_IFMT) == S_IFDIR);
  1158.   }
  1159.   
  1160.   /*
  1161. ***************
  1162. *** 125,133 ****
  1163.   {
  1164.       struct stat sb;
  1165.   
  1166.       if (lstat(file, &sb) < 0)
  1167.       return (0);
  1168. !     return ((sb.st_mode & S_IFMT) & S_IFLNK);
  1169.   }
  1170.   
  1171.   /*
  1172. --- 125,137 ----
  1173.   {
  1174.       struct stat sb;
  1175.   
  1176. + #ifdef S_IFLNK
  1177.       if (lstat(file, &sb) < 0)
  1178.       return (0);
  1179. !     return ((sb.st_mode & S_IFMT) == S_IFLNK);
  1180. ! #else
  1181. !     return (0);
  1182. ! #endif
  1183.   }
  1184.   
  1185.   /*
  1186. diff -c src/tag.c:1.19 src/tag.c:1.19.1.2
  1187. *** src/tag.c:1.19    Wed Feb  6 11:32:10 1991
  1188. --- src/tag.c    Wed Feb  6 11:32:10 1991
  1189. ***************
  1190. *** 1,5 ****
  1191.   #ifndef lint
  1192. ! static char rcsid[] = "$Id: tag.c,v 1.19 89/11/19 23:40:46 berliner Exp $";
  1193.   #endif !lint
  1194.   
  1195.   /*
  1196. --- 1,5 ----
  1197.   #ifndef lint
  1198. ! static char rcsid[] = "$Id: tag.c,v 1.19.1.2 91/01/29 19:45:54 berliner Exp $";
  1199.   #endif !lint
  1200.   
  1201.   /*
  1202. ***************
  1203. *** 180,185 ****
  1204. --- 180,205 ----
  1205.   {
  1206.       char version[50];
  1207.   
  1208. + #ifdef S_IFLNK
  1209. +     /*
  1210. +      * Ooops..  if there is a symbolic link in the source repository
  1211. +      * which points to a normal file, rcs will do its file renaming
  1212. +      * mumbo-jumbo and blow away the symbolic link; this is essentially
  1213. +      * like a copy-on-commit RCS revision control file, but I consider
  1214. +      * it a bug.  Instead, read the contents of the link and recursively
  1215. +      * tag the link contents (which may be a symlink itself...).
  1216. +      */
  1217. +     if (islink(rcs) && isfile(rcs)) {
  1218. +     char link_name[MAXPATHLEN];
  1219. +     int count;
  1220. + 
  1221. +     if ((count = readlink(rcs, link_name, sizeof(link_name))) != -1) {
  1222. +         link_name[count] = '\0';
  1223. +         return (tag_file(link_name));
  1224. +     }
  1225. +     }
  1226. + #endif
  1227. + 
  1228.       if (delete) {
  1229.       /*
  1230.        * If -d is specified, "force_tag_match" is set, so that this call
  1231. ***************
  1232. *** 210,220 ****
  1233.       }
  1234.       Version_Number(rcs, numtag, Date, version);
  1235.       if (version[0] == '\0') {
  1236. !     if (!really_quiet) {
  1237.           warn(0, "cannot find tag '%s' for %s", numtag[0] ? numtag : "head",
  1238.            rcs);
  1239.       }
  1240. !     return (1);
  1241.       }
  1242.       if (isdigit(numtag[0]) && strcmp(numtag, version) != 0) {
  1243.       /*
  1244. --- 230,241 ----
  1245.       }
  1246.       Version_Number(rcs, numtag, Date, version);
  1247.       if (version[0] == '\0') {
  1248. !     if (!quiet) {
  1249.           warn(0, "cannot find tag '%s' for %s", numtag[0] ? numtag : "head",
  1250.            rcs);
  1251. +         return (1);
  1252.       }
  1253. !     return (0);
  1254.       }
  1255.       if (isdigit(numtag[0]) && strcmp(numtag, version) != 0) {
  1256.       /*
  1257. diff -c src/update.c:1.27 src/update.c:1.27.1.2
  1258. *** src/update.c:1.27    Wed Feb  6 11:32:16 1991
  1259. --- src/update.c    Wed Feb  6 11:32:16 1991
  1260. ***************
  1261. *** 1,5 ****
  1262.   #ifndef lint
  1263. ! static char rcsid[] = "$Id: update.c,v 1.27 89/11/19 23:40:48 berliner Exp $";
  1264.   #endif !lint
  1265.   
  1266.   /*
  1267. --- 1,5 ----
  1268.   #ifndef lint
  1269. ! static char rcsid[] = "$Id: update.c,v 1.27.1.2 91/02/06 18:30:07 berliner Exp $";
  1270.   #endif !lint
  1271.   
  1272.   /*
  1273. ***************
  1274. *** 111,117 ****
  1275.       if (!isdir(CVSADM)) {
  1276.       if (!quiet)
  1277.           warn(0, "warning: no %s directory found", CVSADM);
  1278. !     err += update_descend(update_recursive);
  1279.       return (err);
  1280.       }
  1281.       Name_Repository();
  1282. --- 111,132 ----
  1283.       if (!isdir(CVSADM)) {
  1284.       if (!quiet)
  1285.           warn(0, "warning: no %s directory found", CVSADM);
  1286. !     if (argc <= 0) {
  1287. !         err += update_descend(update_recursive);
  1288. !     } else {
  1289. !         int i;
  1290. ! 
  1291. !         for (i = 0; i < argc; i++) {
  1292. !         if (isdir(argv[i])) {
  1293. !             (void) strcat(Dlist, " ");
  1294. !             (void) strcat(Dlist, argv[i]);
  1295. !         } else {
  1296. !             warn(0, "nothing known about %s", argv[i]);
  1297. !             err++;
  1298. !         }
  1299. !         }
  1300. !         err += update_process_lists();
  1301. !     }
  1302.       return (err);
  1303.       }
  1304.       Name_Repository();
  1305. ***************
  1306. *** 175,180 ****
  1307. --- 190,196 ----
  1308.       update_Files = 1;
  1309.       (void) strcpy(User, cp);
  1310.       Scratch_Entry(User);
  1311. +     (void) unlink(User);
  1312.       }
  1313.       /*
  1314.        * Olist is the "needs checking out" list.
  1315. ***************
  1316. *** 349,359 ****
  1317.           strcmp(dp->d_name, CVSLCK) == 0)
  1318.           continue;
  1319.           (void) sprintf(fname, "%s/%s", Repository, dp->d_name);
  1320.           if (!isdir(fname))
  1321.           continue;
  1322. !         if (isdir(dp->d_name))
  1323.           continue;
  1324. !         if (isfile(dp->d_name)) {
  1325.           warn(0, "file %s should be a directory; please move it", dp->d_name);
  1326.           err++;
  1327.           } else {
  1328. --- 365,376 ----
  1329.           strcmp(dp->d_name, CVSLCK) == 0)
  1330.           continue;
  1331.           (void) sprintf(fname, "%s/%s", Repository, dp->d_name);
  1332. +         (void) sprintf(tmp, "%s/%s", dp->d_name, CVSADM);
  1333.           if (!isdir(fname))
  1334.           continue;
  1335. !         if (islink(dp->d_name) || isdir(tmp))
  1336.           continue;
  1337. !         if (!isdir(dp->d_name) && isfile(dp->d_name)) {
  1338.           warn(0, "file %s should be a directory; please move it", dp->d_name);
  1339.           err++;
  1340.           } else {
  1341. diff -c src/version_number.c:1.16 src/version_number.c:1.16.1.2
  1342. *** src/version_number.c:1.16    Wed Feb  6 11:32:09 1991
  1343. --- src/version_number.c    Wed Feb  6 11:32:09 1991
  1344. ***************
  1345. *** 1,5 ****
  1346.   #ifndef lint
  1347. ! static char rcsid[] = "$Id: version_number.c,v 1.16 89/11/19 23:20:35 berliner Exp $";
  1348.   #endif !lint
  1349.   
  1350.   /*
  1351. --- 1,5 ----
  1352.   #ifndef lint
  1353. ! static char rcsid[] = "$Id: version_number.c,v 1.16.1.2 91/01/29 07:20:26 berliner Exp $";
  1354.   #endif !lint
  1355.   
  1356.   /*
  1357. ***************
  1358. *** 67,72 ****
  1359. --- 67,73 ----
  1360.           (void) strcpy(vers, rev);
  1361.           }
  1362.       } else {
  1363. +         if (!force_tag_match)
  1364.           (void) strcpy(vers, rev);
  1365.       }
  1366.       }
  1367. ***************
  1368. *** 100,105 ****
  1369. --- 101,107 ----
  1370.       if (fgets(line, sizeof(line), fp) == NULL)
  1371.       return;
  1372.       if (strncmp(line, RCSHEAD, sizeof(RCSHEAD) - 1) != 0 ||
  1373. +     !isspace(line[sizeof(RCSHEAD) - 1]) ||
  1374.       (cp = rindex(line, ';')) == NULL)
  1375.       return;
  1376.       *cp = '\0';                /* strip the ';' */
  1377. ***************
  1378. *** 119,124 ****
  1379. --- 121,127 ----
  1380.       if (fgets(line, sizeof(line), fp) == NULL)
  1381.       return;
  1382.       if (strncmp(line, RCSBRANCH, sizeof(RCSBRANCH) - 1) == 0 &&
  1383. +     isspace(line[sizeof(RCSBRANCH) - 1]) &&
  1384.       (cp = rindex(line, ';')) != NULL) {
  1385.       *cp = '\0';            /* strip the ';' */
  1386.       if ((cp = rindex(line, ' ')) == NULL &&
  1387. ***************
  1388. *** 149,156 ****
  1389.        * the highest numbered branch off "rev", if necessary.
  1390.        */
  1391.       get_branch(fp, rev);
  1392. !     if (tag[0] == '\0' || isdigit(tag[0]) || symtag_matched < 0)
  1393. !     (void) strcpy(vers, rev);
  1394.   }
  1395.   
  1396.   /*
  1397. --- 152,161 ----
  1398.        * the highest numbered branch off "rev", if necessary.
  1399.        */
  1400.       get_branch(fp, rev);
  1401. !     if (tag[0] == '\0' || isdigit(tag[0]) || symtag_matched < 0) {
  1402. !     if ((numdots(rev) & 1) != 0)
  1403. !         (void) strcpy(vers, rev);
  1404. !     }
  1405.   }
  1406.   
  1407.   /*
  1408. ***************
  1409. *** 172,196 ****
  1410.       char *rev;
  1411.       char *vers;
  1412.   {
  1413. !     char line[MAXLINELEN], tagdot[50];
  1414.       char *cp, *cprev;
  1415. -     int tagdots, tagdotlen;
  1416.   
  1417.       if (isdigit(tag[0])) {
  1418. !     while (tag[strlen(tag)] == '.')
  1419. !         tag[strlen(tag)] = '\0';    /* strip trailing dots */
  1420. !     (void) sprintf(tagdot, "%s.", tag);
  1421. !     tagdotlen = strlen(tagdot);
  1422. !     tagdots = numdots(tag);
  1423.       }
  1424.       while (fgets(line, sizeof(line), fp) != NULL) {
  1425.       if (strncmp(line, RCSDESC, sizeof(RCSDESC) - 1) == 0) {
  1426. -         /*
  1427. -          * Use head, or a partial branch match found with the strncmp
  1428. -          * call with tagdot below
  1429. -          */
  1430.           rewind(fp);
  1431. !         return (1);
  1432.       }
  1433.       /*
  1434.        * For numeric tags, the RCS file contains the revision
  1435. --- 177,197 ----
  1436.       char *rev;
  1437.       char *vers;
  1438.   {
  1439. !     char line[MAXLINELEN];
  1440.       char *cp, *cprev;
  1441.   
  1442.       if (isdigit(tag[0])) {
  1443. !     while (tag[strlen(tag)-1] == '.')
  1444. !         tag[strlen(tag)-1] = '\0';    /* strip trailing dots */
  1445. !     if ((numdots(tag) & 1) == 0) {
  1446. !         (void) strcpy(rev, tag);
  1447. !         return (1);            /* let get_branch() figure it out */
  1448. !     }
  1449.       }
  1450.       while (fgets(line, sizeof(line), fp) != NULL) {
  1451.       if (strncmp(line, RCSDESC, sizeof(RCSDESC) - 1) == 0) {
  1452.           rewind(fp);
  1453. !         return (1);            /* use head */
  1454.       }
  1455.       /*
  1456.        * For numeric tags, the RCS file contains the revision
  1457. ***************
  1458. *** 204,221 ****
  1459.           (void) strcpy(vers, line);
  1460.           return (0);        /* a match for a numeric tag */
  1461.           }
  1462. -         if (strncmp(tagdot, line, tagdotlen) == 0) {
  1463. -         if ((tagdots & 1) == 0 && numdots(line) == tagdots+1)
  1464. -             (void) strcpy(rev, line);
  1465. -         }
  1466.           continue;
  1467.       }
  1468.       if (strncmp(line, RCSSYMBOL, sizeof(RCSSYMBOL)-1)!=0 ||
  1469. !         (cp = rindex(line, ';')) == NULL)
  1470. !         continue;
  1471. !     *cp = ' ';            /* strip the ';' */
  1472. !     if ((cp = index(line, ' ')) == NULL &&
  1473. !         (cp = index(line, '\t')) == NULL)
  1474.           continue;
  1475.       /*
  1476.        * A rather ugly loop to process the "symbols" line.  I would
  1477. --- 205,214 ----
  1478.           (void) strcpy(vers, line);
  1479.           return (0);        /* a match for a numeric tag */
  1480.           }
  1481.           continue;
  1482.       }
  1483.       if (strncmp(line, RCSSYMBOL, sizeof(RCSSYMBOL)-1)!=0 ||
  1484. !         !isspace(line[sizeof(RCSSYMBOL) - 1]))
  1485.           continue;
  1486.       /*
  1487.        * A rather ugly loop to process the "symbols" line.  I would
  1488. ***************
  1489. *** 222,233 ****
  1490.        * really rather use strtok(), but other above me already are,
  1491.        * and strtok() blows up in this case.
  1492.        */
  1493. !     while (cp && *cp) {
  1494.           while (isspace(*cp))
  1495.           cp++;
  1496.           /* symbols and revisions are separated by a colon */
  1497.           if ((cprev = index(cp, ':')) == NULL) {
  1498. !         while (*cp && !isspace(*cp))
  1499.               cp++;
  1500.           continue;
  1501.           }
  1502. --- 215,234 ----
  1503.        * really rather use strtok(), but other above me already are,
  1504.        * and strtok() blows up in this case.
  1505.        */
  1506. !     for (cp = line + sizeof(RCSSYMBOL);  cp;  ) {
  1507.           while (isspace(*cp))
  1508.           cp++;
  1509. +         if (*cp == ';')
  1510. +         break;
  1511. +         if (!*cp) {
  1512. +             if (fgets(line, sizeof(line), fp) == NULL)
  1513. +             return 0;
  1514. +         cp = line;
  1515. +         continue;
  1516. +         }
  1517.           /* symbols and revisions are separated by a colon */
  1518.           if ((cprev = index(cp, ':')) == NULL) {
  1519. !         while (*cp && !isspace(*cp) && *cp!=';')
  1520.               cp++;
  1521.           continue;
  1522.           }
  1523. ***************
  1524. *** 245,253 ****
  1525.           (void) strcpy(rev, cprev);
  1526.           return (-1);        /* look for branches off rev */
  1527.           } else {
  1528. !         while (!isspace(*cp))
  1529.               cp++;
  1530. -         cp++;
  1531.           }
  1532.       }
  1533.       return (1);
  1534. --- 246,253 ----
  1535.           (void) strcpy(rev, cprev);
  1536.           return (-1);        /* look for branches off rev */
  1537.           } else {
  1538. !         while (!isspace(*cp) && *cp!=';')
  1539.               cp++;
  1540.           }
  1541.       }
  1542.       return (1);
  1543. ***************
  1544. *** 282,288 ****
  1545.           *cp = '\0';        /* strip the newline */
  1546.           if (numdots(line) == dots+1 &&
  1547.           strncmp(line, branch, len) == 0) {
  1548. !         if (strcmp(branch, line) <= 0)
  1549.               (void) strcpy(rev, line);
  1550.           }
  1551.       }
  1552. --- 282,288 ----
  1553.           *cp = '\0';        /* strip the newline */
  1554.           if (numdots(line) == dots+1 &&
  1555.           strncmp(line, branch, len) == 0) {
  1556. !         if ((numdots(rev) & 1) == 0 || strcmp(rev, line) <= 0)
  1557.               (void) strcpy(rev, line);
  1558.           }
  1559.       }
  1560. ***************
  1561. *** 342,348 ****
  1562.       char *cp, *semi;
  1563.   
  1564.       last_rev[0] = '\0';
  1565. !     (void) strcpy(curdate, "00");    /* what happens at 2000 ad? */
  1566.       (void) sprintf(date_dot, "%s.", rev);
  1567.       date_dotlen = strlen(date_dot);
  1568.       date_dots = numdots(rev);
  1569. --- 342,348 ----
  1570.       char *cp, *semi;
  1571.   
  1572.       last_rev[0] = '\0';
  1573. !     curdate[0] = '\0';
  1574.       (void) sprintf(date_dot, "%s.", rev);
  1575.       date_dotlen = strlen(date_dot);
  1576.       date_dots = numdots(rev);
  1577. ***************
  1578. *** 360,365 ****
  1579. --- 360,366 ----
  1580.           continue;
  1581.       }
  1582.       if (strncmp(line, RCSDATE, sizeof(RCSDATE) - 1) == 0 &&
  1583. +         isspace(line[sizeof(RCSDATE) - 1]) &&
  1584.           last_rev[0] != '\0') {
  1585.           for (cp = line; *cp && !isspace(*cp); cp++)
  1586.           ;
  1587. ***************
  1588. *** 367,373 ****
  1589.           cp++;
  1590.           if (*cp && (semi = index(cp, ';')) != NULL) {
  1591.           *semi = '\0';        /* strip the semicolon */
  1592. !         if (strcmp(cp, date) <= 0 && strcmp(cp, curdate) >= 0) {
  1593.               (void) strcpy(curdate, cp);
  1594.               (void) strcpy(version, last_rev);
  1595.           }
  1596. --- 368,374 ----
  1597.           cp++;
  1598.           if (*cp && (semi = index(cp, ';')) != NULL) {
  1599.           *semi = '\0';        /* strip the semicolon */
  1600. !         if (datecmp(cp, date) <= 0 && datecmp(cp, curdate) >= 0) {
  1601.               (void) strcpy(curdate, cp);
  1602.               (void) strcpy(version, last_rev);
  1603.           }
  1604. ***************
  1605. *** 374,377 ****
  1606. --- 375,391 ----
  1607.           }
  1608.       }
  1609.       }
  1610. + }
  1611. + 
  1612. + /*
  1613. +  * Compare two dates in RCS format.
  1614. +  * Beware the change in format on January 1, 2000,
  1615. +  * when years go from 2-digit to full format.
  1616. +  */
  1617. + int
  1618. + datecmp(date1, date2)
  1619. +     char *date1, *date2;
  1620. + {
  1621. +     int length_diff = strlen(date1) - strlen(date2);
  1622. +     return length_diff ? length_diff : strcmp(date1, date2);
  1623.   }
  1624.  
  1625.