home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1994 March / Source_Code_CD-ROM_Walnut_Creek_March_1994.iso / compsrcs / misc / volume38 / remind / patch07c < prev    next >
Encoding:
Text File  |  1993-07-22  |  34.0 KB  |  1,079 lines
  1. Newsgroups: comp.sources.misc
  2. From: <dfs@doe.carleton.ca> (David F. Skoll)
  3. Subject: v38i064:  remind - A replacement for calendar, Patch07c/3
  4. Message-ID: <1993Jul22.213933.7824@sparky.sterling.com>
  5. X-Md4-Signature: 8725ced53aa37a4899abf050eb8c2c38
  6. Sender: kent@sparky.sterling.com (Kent Landfield)
  7. Organization: Sterling Software
  8. Date: Thu, 22 Jul 1993 21:39:33 GMT
  9. Approved: kent@sparky.sterling.com
  10.  
  11. Submitted-by: <dfs@doe.carleton.ca> (David F. Skoll)
  12. Posting-number: Volume 38, Issue 64
  13. Archive-name: remind/patch07c
  14. Environment: UNIX, MS-DOS, OS/2
  15. Patch-To: remind: Volume 33, Issue 58-69
  16.  
  17. #! /bin/sh
  18. # This is a shell archive.  Remove anything before this line, then feed it
  19. # into a shell via "sh file" or similar.  To overwrite existing files,
  20. # type "sh file -c".
  21. # Contents:  patch.07.B
  22. # Wrapped by kent@sparky on Thu Jul 22 16:19:14 1993
  23. PATH=/bin:/usr/bin:/usr/ucb:/usr/local/bin:/usr/lbin ; export PATH
  24. echo If this archive is complete, you will see the following message:
  25. echo '          "shar: End of archive 3 (of 3)."'
  26. if test -f 'patch.07.B' -a "${1}" != "-c" ; then 
  27.   echo shar: Will not clobber existing file \"'patch.07.B'\"
  28. else
  29.   echo shar: Extracting \"'patch.07.B'\" \(31602 characters\)
  30.   sed "s/^X//" >'patch.07.B' <<'END_OF_FILE'
  31. X***************
  32. X*** 1376,1381 ****
  33. X--- 1390,1426 ----
  34. X  
  35. X  /***************************************************************/
  36. X  /*                                                             */
  37. X+ /*  FFiledir                                                   */
  38. X+ /*                                                             */
  39. X+ /*  Return directory of current file                           */
  40. X+ /*                                                             */
  41. X+ /***************************************************************/
  42. X+ #ifdef HAVE_PROTOS
  43. X+ PRIVATE int FFiledir(void)
  44. X+ #else
  45. X+ static int FFiledir()
  46. X+ #endif
  47. X+ {
  48. X+    char TmpBuf[LINELEN];  /* Should be _POSIX_PATH_MAX ? */
  49. X+    char *s;
  50. X+ 
  51. X+ #ifdef __MSDOS__
  52. X+ #define PATHSEP '\\'
  53. X+ #else
  54. X+ #define PATHSEP '/'
  55. X+ #endif
  56. X+ 
  57. X+    strcpy(TmpBuf, FileName);
  58. X+    s = TmpBuf + strlen(TmpBuf) - 1;
  59. X+    if (s < TmpBuf) return RetStrVal(".");
  60. X+    while (s > TmpBuf && *s != PATHSEP) s--;
  61. X+    if (*s == PATHSEP) {
  62. X+          *s = 0;
  63. X+      return RetStrVal(TmpBuf);
  64. X+    } else return RetStrVal(".");
  65. X+ }
  66. X+ /***************************************************************/
  67. X+ /*                                                             */
  68. X  /*  FAccess                                                    */
  69. X  /*                                                             */
  70. X  /*  The UNIX access() system call.                             */
  71. X***************
  72. X*** 1571,1576 ****
  73. X--- 1616,1622 ----
  74. X     int year, day, mon, jahr;
  75. X     int mout, dout;
  76. X     int ans, r;
  77. X+    int adarbehave;
  78. X  
  79. X     if (ARG(0).type != INT_TYPE || ARG(1).type != STR_TYPE) return E_BAD_TYPE;
  80. X     day = ARG(0).v.val;
  81. X***************
  82. X*** 1580,1591 ****
  83. X        return E_BAD_DATE;
  84. X     }
  85. X     if (Nargs == 2) {
  86. X!       r = GetNextHebrewDate(JulianToday, mon, day, 0, &ans);
  87. X        if (r) return r;
  88. X        RetVal.type = DATE_TYPE;
  89. X        RetVal.v.val = ans;
  90. X        return OK;
  91. X     }
  92. X     if (Nargs == 4) {
  93. X        if (ARG(3).type != INT_TYPE) return E_BAD_TYPE;
  94. X        jahr = ARG(3).v.val;
  95. X--- 1626,1644 ----
  96. X        return E_BAD_DATE;
  97. X     }
  98. X     if (Nargs == 2) {
  99. X!       r = GetNextHebrewDate(JulianToday, mon, day, 0, 0, &ans);
  100. X        if (r) return r;
  101. X        RetVal.type = DATE_TYPE;
  102. X        RetVal.v.val = ans;
  103. X        return OK;
  104. X     }
  105. X+    if (Nargs == 5) {
  106. X+       if (ARG(4).type != INT_TYPE) return E_BAD_TYPE;
  107. X+       adarbehave = ARG(4).v.val;
  108. X+       if (adarbehave < 0) return E_2LOW;
  109. X+       if (adarbehave > 2) return E_2HIGH;
  110. X+    } else adarbehave = 0;
  111. X+ 
  112. X     if (Nargs == 4) {
  113. X        if (ARG(3).type != INT_TYPE) return E_BAD_TYPE;
  114. X        jahr = ARG(3).v.val;
  115. X***************
  116. X*** 1599,1605 ****
  117. X  
  118. X     if (ARG(2).type == INT_TYPE) {
  119. X        year = ARG(2).v.val;
  120. X!       r = GetValidHebDate(year, mon, day, &mout, &dout, jahr);
  121. X        if (r) return r;
  122. X        r = HebToJul(year, mout, dout);
  123. X        if (r<0) return E_DATE_OVER;
  124. X--- 1652,1658 ----
  125. X  
  126. X     if (ARG(2).type == INT_TYPE) {
  127. X        year = ARG(2).v.val;
  128. X!       r = GetValidHebDate(year, mon, day, 0, &mout, &dout, jahr);
  129. X        if (r) return r;
  130. X        r = HebToJul(year, mout, dout);
  131. X        if (r<0) return E_DATE_OVER;
  132. X***************
  133. X*** 1607,1613 ****
  134. X        RetVal.type = DATE_TYPE;
  135. X        return OK;
  136. X     } else if (ARG(2).type == DATE_TYPE) {
  137. X!       r = GetNextHebrewDate(ARG(2).v.val, mon, day, jahr, &ans);
  138. X        if (r) return r;
  139. X        RetVal.v.val = ans;
  140. X        RetVal.type = DATE_TYPE;
  141. X--- 1660,1666 ----
  142. X        RetVal.type = DATE_TYPE;
  143. X        return OK;
  144. X     } else if (ARG(2).type == DATE_TYPE) {
  145. X!       r = GetNextHebrewDate(ARG(2).v.val, mon, day, jahr, adarbehave, &ans);
  146. X        if (r) return r;
  147. X        RetVal.v.val = ans;
  148. X        RetVal.type = DATE_TYPE;
  149. X***************
  150. X*** 1681,1684 ****
  151. X--- 1734,2008 ----
  152. X     RetVal.type = INT_TYPE;
  153. X     RetVal.v.val = y;
  154. X     return OK;
  155. X+ }
  156. X+ /****************************************************************/
  157. X+ /*                                                              */
  158. X+ /*  FEasterdate - calc. easter Sunday from a year.              */
  159. X+ /*                                                              */
  160. X+ /*    from The Art of Computer Programming Vol 1.               */
  161. X+ /*            Fundamental Algorithms                            */
  162. X+ /*    by Donald Knuth.                                          */
  163. X+ /*                                                              */
  164. X+ /* Donated by Michael Salmon - thanks!                          */
  165. X+ /*                                                              */
  166. X+ /* I haven't examined this in detail, but I *think* int         */
  167. X+ /* arithmetic is fine, even on 16-bit machines.                 */
  168. X+ /*                                                              */
  169. X+ /****************************************************************/
  170. X+ #ifdef HAVE_PROTOS
  171. X+ PRIVATE int FEasterdate(void)
  172. X+ #else
  173. X+ static int FEasterdate()
  174. X+ #endif
  175. X+ {
  176. X+    int y, m, d;
  177. X+    int g, c, x, z, e, n;
  178. X+    if (ARG(0).type == INT_TYPE) {
  179. X+       y = ARG(0).v.val;
  180. X+       if (y < BASE) return E_2LOW;
  181. X+       else if (y > BASE+YR_RANGE) return E_2HIGH;
  182. X+    } else if (ARG(0).type == DATE_TYPE) {
  183. X+       FromJulian(ARG(0).v.val, &y, &m, &d);  /* We just want the year */
  184. X+    } else return E_BAD_TYPE;
  185. X+ 
  186. X+    do {
  187. X+       g = (y % 19) + 1;  /* golden number */
  188. X+       c = (y / 100) + 1; /* century */
  189. X+       x = (3 * c)/4 - 12;        /* correction for non-leap year centuries */
  190. X+       z = (8 * c + 5)/25 - 5;    /* special constant for moon sync */
  191. X+       d = (5 * y)/4 - x - 10;    /* find sunday */
  192. X+       e = (11 * g + 20 + z - x) % 30;    /* calc epact */
  193. X+       if ( e < 0 ) e += 30;
  194. X+       if ( e == 24 || (e == 25 && g > 11)) e++;
  195. X+       n = 44 - e;                        /* find full moon */
  196. X+       if ( n < 21 ) n += 30;     /* after 21st */
  197. X+       d = n + 7 - (d + n)%7;     /* calc sunday after */
  198. X+       if (d <= 31) m = 2;
  199. X+       else
  200. X+       {
  201. X+          d = d - 31;
  202. X+          m = 3;
  203. X+       }
  204. X+ 
  205. X+       RetVal.type = DATE_TYPE;
  206. X+       RetVal.v.val = Julian(y, m, d);
  207. X+       y++; } while (ARG(0).type == DATE_TYPE && RetVal.v.val < ARG(0).v.val);
  208. X+ 
  209. X+    return OK;
  210. X+ }
  211. X+ /***************************************************************/
  212. X+ /*                                                             */
  213. X+ /*  FIsdst and FMinsfromutc                                    */
  214. X+ /*                                                             */
  215. X+ /*  Check whether daylight savings time is in effect, and      */
  216. X+ /*  get minutes from UTC.                                      */
  217. X+ /*                                                             */
  218. X+ /***************************************************************/
  219. X+ PRIVATE int FTimeStuff ARGS ((int wantmins));
  220. X+ #ifdef HAVE_PROTOS
  221. X+ PRIVATE int FIsdst(void)
  222. X+ #else
  223. X+ static int FIsdst()
  224. X+ #endif
  225. X+ {
  226. X+    return FTimeStuff(0);
  227. X+ }
  228. X+ 
  229. X+ #ifdef HAVE_PROTOS
  230. X+ PRIVATE int FMinsfromutc(void)
  231. X+ #else
  232. X+ static int FMinsfromutc()
  233. X+ #endif
  234. X+ {
  235. X+    return FTimeStuff(1);
  236. X+ }
  237. X+ 
  238. X+ #ifdef HAVE_PROTOS
  239. X+ PRIVATE int FTimeStuff(int wantmins)
  240. X+ #else
  241. X+ static int FTimeStuff(wantmins)
  242. X+ int wantmins;
  243. X+ #endif
  244. X+ {
  245. X+    int jul, tim;
  246. X+    int mins, dst;
  247. X+ 
  248. X+    jul = JulianToday;
  249. X+    tim = 0;
  250. X+ 
  251. X+    if (Nargs >= 1) {
  252. X+       if (ARG(0).type != DATE_TYPE) return E_BAD_TYPE;
  253. X+       jul = ARG(0).v.val;
  254. X+       if (Nargs >= 2) {
  255. X+          if (ARG(1).type != TIM_TYPE) return E_BAD_TYPE;
  256. X+      tim = ARG(1).v.val;
  257. X+       }
  258. X+    }
  259. X+ 
  260. X+    if (CalcMinsFromUTC(jul, tim, &mins, &dst)) return E_MKTIME_PROBLEM;
  261. X+    RetVal.type = INT_TYPE;
  262. X+    if (wantmins) RetVal.v.val = mins; else RetVal.v.val = dst;
  263. X+ 
  264. X+    return OK;
  265. X+ }
  266. X+ 
  267. X+ /***************************************************************/
  268. X+ /*                                                             */
  269. X+ /*  Sunrise and sunset functions.                              */
  270. X+ /*                                                             */
  271. X+ /*  Algorithm from "Almanac for computers for the year 1978"   */
  272. X+ /*  by L. E. Doggett, Nautical Almanac Office, USNO.           */
  273. X+ /*                                                             */
  274. X+ /*  This code also uses some ideas found in programs written   */
  275. X+ /*  by Michael Schwartz and Marc T. Kaufman.                   */
  276. X+ /*                                                             */
  277. X+ /***************************************************************/
  278. X+ #define PI 3.1415926536
  279. X+ #define DEGRAD (PI/180.0)
  280. X+ #define RADDEG (180.0/PI)
  281. X+ 
  282. X+ #ifdef HAVE_PROTOS
  283. X+ PRIVATE int SunStuff(int rise, double cosz, int jul)
  284. X+ #else
  285. X+ static int SunStuff(rise, cosz, jul)
  286. X+ int rise;
  287. X+ double cosz;
  288. X+ int jul;
  289. X+ #endif
  290. X+ {
  291. X+    int year, mon, day;
  292. X+    int jan0;
  293. X+    int mins, hours;
  294. X+ 
  295. X+    double M, L, tanA, sinDelta, cosDelta, a, a_hr, cosH, t, H, T;
  296. X+    double latitude, longdeg, UT, local;
  297. X+ 
  298. X+ /* Get offset from UTC */
  299. X+    if (CalculateUTC) {
  300. X+       if (CalcMinsFromUTC(jul, 12*60, &mins, NULL)) {
  301. X+          Eprint(ErrMsg[E_MKTIME_PROBLEM]);
  302. X+      return NO_TIME;
  303. X+       }
  304. X+    } else mins = MinsFromUTC;
  305. X+ 
  306. X+ /* Get latitude and longitude */
  307. X+    longdeg = (double) LongDeg + (double) LongMin / 60.0
  308. X+               + (double) LongSec / 3600.0;
  309. X+ 
  310. X+    latitude = DEGRAD * ((double) LatDeg + (double) LatMin / 60.0
  311. X+                  + (double) LatSec / 3600.0);
  312. X+ 
  313. X+ 
  314. X+    FromJulian(jul, &year, &mon, &day);
  315. X+    jan0 = jul - Julian(year, 0, 1);
  316. X+ 
  317. X+ /* Following formula on page B6 exactly... */
  318. X+    t = (double) jan0;
  319. X+    if (rise) t += (6.0 + longdeg/15.0) / 24.0;
  320. X+    else      t += (18.0 + longdeg/15.0) / 24.0;
  321. X+ 
  322. X+ /* Mean anomaly of sun for 1978 ... how accurate for other years??? */
  323. X+    M = 0.985600 * t - 3.251;  /* In degrees */
  324. X+ 
  325. X+ /* Sun's true longitude */
  326. X+    L = M + 1.916*sin(DEGRAD*M) + 0.02*sin(2*DEGRAD*M) + 282.565;
  327. X+    if (L > 360.0) L -= 360.0;
  328. X+ 
  329. X+ /* Tan of sun's right ascension */
  330. X+    tanA = 0.91746 * tan(DEGRAD*L);
  331. X+    a = RADDEG * atan(tanA);
  332. X+ 
  333. X+ /* Move a into same quadrant as L */
  334. X+    if (0.0 <= L && L < 90.0) {
  335. X+       if (a < 0.0) a += 180.0;
  336. X+    } else if (90.0 <= L && L < 180.0) {
  337. X+       a += 180.0;
  338. X+    } else if (180.0 <= L && L < 270.0) {
  339. X+       a += 180.0;
  340. X+    } else {
  341. X+       if (a > 0.0) a += 180.0;
  342. X+    }
  343. X+ /*   if (fabs(a - L) > 90.0)
  344. X+       a += 180.0; */
  345. X+ 
  346. X+    if (a > 360.0)
  347. X+       a -= 360.0;
  348. X+    a_hr = a / 15.0;
  349. X+ 
  350. X+ /* Sine of sun's declination */
  351. X+    sinDelta = 0.39782 * sin(DEGRAD*L);
  352. X+    cosDelta = sqrt(1 - sinDelta*sinDelta);
  353. X+ 
  354. X+ /* Cosine of sun's local hour angle */
  355. X+    cosH = (cosz - sinDelta * sin(latitude)) / (cosDelta * cos(latitude));
  356. X+ 
  357. X+    if (cosH > 1.0 || cosH < -1.0) return NO_TIME;
  358. X+ 
  359. X+    H = RADDEG * acos(cosH);
  360. X+    if (rise) H = 360.0 - H;
  361. X+ 
  362. X+    T = H / 15.0 + a_hr - 0.065710*t - 6.620;
  363. X+    if (T >= 24.0) T -= 24.0;
  364. X+    else if (T < 0.0) T+= 24.0;
  365. X+ 
  366. X+    UT = T + longdeg / 15.0;
  367. X+ 
  368. X+ 
  369. X+    local = UT + (double) mins / 60.0;
  370. X+    if (local < 0.0) local += 24.0;
  371. X+    else if (local >= 24.0) local -= 24.0;
  372. X+ 
  373. X+    hours = (int) local;
  374. X+    mins = (int) ((local - hours) * 60.0);
  375. X+ 
  376. X+    return hours*60 + mins;
  377. X+ }
  378. X+ 
  379. X+ /***************************************************************/
  380. X+ /*                                                             */
  381. X+ /*  Sunrise and Sunset functions.                              */
  382. X+ /*                                                             */
  383. X+ /***************************************************************/
  384. X+ #ifdef HAVE_PROTOS
  385. X+ PRIVATE int FSun(int rise)
  386. X+ #else
  387. X+ static int FSun(rise)
  388. X+ int rise;
  389. X+ #endif
  390. X+ {
  391. X+    int jul = JulianToday;
  392. X+    static double cosz = -0.014543897;  /* for sunrise and sunset */
  393. X+    int r;
  394. X+ 
  395. X+    if (Nargs >= 1) {
  396. X+       if (ARG(0).type != DATE_TYPE) return E_BAD_TYPE;
  397. X+       jul = ARG(0).v.val;
  398. X+    }
  399. X+    
  400. X+    r = SunStuff(rise, cosz, jul);
  401. X+    if (r == NO_TIME) {
  402. X+       RetVal.v.val = 0;
  403. X+       RetVal.type = INT_TYPE;
  404. X+    } else {
  405. X+       RetVal.v.val = r;
  406. X+       RetVal.type = TIM_TYPE;
  407. X+    }
  408. X+    return OK;
  409. X+ }
  410. X+       
  411. X+ #ifdef HAVE_PROTOS
  412. X+ PRIVATE int FSunrise(void)
  413. X+ #else
  414. X+ static int FSunrise()
  415. X+ #endif
  416. X+ {
  417. X+    return FSun(1);
  418. X+ }
  419. X+ #ifdef HAVE_PROTOS
  420. X+ PRIVATE int FSunset(void)
  421. X+ #else
  422. X+ static int FSunset()
  423. X+ #endif
  424. X+ {
  425. X+    return FSun(0);
  426. X  }
  427. X*** ../p6/globals.h    Thu Apr 22 10:24:07 1993
  428. X--- ./globals.h    Mon Jun 28 12:29:31 1993
  429. X***************
  430. X*** 31,69 ****
  431. X  EXTERN    int    CurMon;
  432. X  EXTERN    int    CurYear;
  433. X  EXTERN  int    LineNo;
  434. X! EXTERN  char    FreshLine;
  435. X  EXTERN  char    LineBuffer[LINELEN];
  436. X  EXTERN  char    SubstBuffer[LINELEN];
  437. X  EXTERN  char    TokBuffer[TOKSIZE+1];
  438. X  EXTERN  INIT(   char    *MsgCommand, NULL);
  439. X! EXTERN  INIT(    char    ShowAllErrors, 0);
  440. X  EXTERN  INIT(    int     DebugFlag, 0);
  441. X! EXTERN  INIT(   char    DoCalendar, 0);
  442. X! EXTERN  INIT(   char    DoSimpleCalendar, 0);
  443. X! EXTERN  INIT(   char    PsCal, 0);
  444. X  EXTERN  INIT(   int     CalWidth, 80);
  445. X  EXTERN  INIT(   int     CalWeeks, 0);
  446. X  EXTERN  INIT(   int     CalMonths, 0);
  447. X! EXTERN  INIT(    char    Hush, 0);
  448. X! EXTERN  INIT(    char    NextMode, 0);
  449. X! EXTERN  INIT(    char    InfiniteDelta, 0);
  450. X! EXTERN  INIT(   char    RunDisabled, 0);
  451. X! EXTERN  INIT(   char    IgnoreOnce, 0);
  452. X  EXTERN  INIT(   char    Banner[LINELEN], L_BANNER);
  453. X! EXTERN  INIT(   char    SortByTime, 0);
  454. X! EXTERN  INIT(   char    SortByDate, 0);
  455. X  
  456. X  EXTERN    char    *InitialFile;
  457. X  EXTERN    int    FileAccessDate;
  458. X  
  459. X! #ifdef HAVE_QUEUED
  460. X! EXTERN  INIT(    char    DontFork, 0);
  461. X! EXTERN  INIT(    char    DontQueue, 0);
  462. X  EXTERN  INIT(   int     NumQueued, 0);
  463. X! EXTERN  INIT(   char    DontIssueAts, 0);
  464. X! EXTERN  INIT(   char    Daemon, 0);
  465. X! #endif
  466. X  
  467. X  EXTERN  INIT(   int     ScFormat, SC_AMPM);
  468. X  EXTERN  INIT(   int     MaxSatIter, 150);
  469. X  EXTERN  INIT(    char    *FileName, NULL);
  470. X--- 31,68 ----
  471. X  EXTERN    int    CurMon;
  472. X  EXTERN    int    CurYear;
  473. X  EXTERN  int    LineNo;
  474. X! EXTERN  int     FreshLine;
  475. X  EXTERN  char    LineBuffer[LINELEN];
  476. X  EXTERN  char    SubstBuffer[LINELEN];
  477. X  EXTERN  char    TokBuffer[TOKSIZE+1];
  478. X  EXTERN  INIT(   char    *MsgCommand, NULL);
  479. X! EXTERN  INIT(    int     ShowAllErrors, 0);
  480. X  EXTERN  INIT(    int     DebugFlag, 0);
  481. X! EXTERN  INIT(   int    DoCalendar, 0);
  482. X! EXTERN  INIT(   int     DoSimpleCalendar, 0);
  483. X! EXTERN  INIT(   int     PsCal, 0);
  484. X  EXTERN  INIT(   int     CalWidth, 80);
  485. X  EXTERN  INIT(   int     CalWeeks, 0);
  486. X  EXTERN  INIT(   int     CalMonths, 0);
  487. X! EXTERN  INIT(    int     Hush, 0);
  488. X! EXTERN  INIT(    int     NextMode, 0);
  489. X! EXTERN  INIT(    int     InfiniteDelta, 0);
  490. X! EXTERN  INIT(   int     RunDisabled, 0);
  491. X! EXTERN  INIT(   int     IgnoreOnce, 0);
  492. X  EXTERN  INIT(   char    Banner[LINELEN], L_BANNER);
  493. X! EXTERN  INIT(   int     SortByTime, 0);
  494. X! EXTERN  INIT(   int     SortByDate, 0);
  495. X  
  496. X  EXTERN    char    *InitialFile;
  497. X  EXTERN    int    FileAccessDate;
  498. X  
  499. X! EXTERN  INIT(    int     DontFork, 0);
  500. X! EXTERN  INIT(    int     DontQueue, 0);
  501. X  EXTERN  INIT(   int     NumQueued, 0);
  502. X! EXTERN  INIT(   int     DontIssueAts, 0);
  503. X! EXTERN  INIT(   int     Daemon, 0);
  504. X  
  505. X+ 
  506. X  EXTERN  INIT(   int     ScFormat, SC_AMPM);
  507. X  EXTERN  INIT(   int     MaxSatIter, 150);
  508. X  EXTERN  INIT(    char    *FileName, NULL);
  509. X***************
  510. X*** 71,79 ****
  511. X  EXTERN  INIT(   int     NumIfs,    0);
  512. X  EXTERN  INIT(   unsigned int IfFlags,   0);
  513. X  EXTERN  INIT(   int     LastTriggerDate, 0);
  514. X! EXTERN  INIT(   char    LastTrigValid, 0);
  515. X  EXTERN  INIT(   int     LastTriggerTime, 0);
  516. X! EXTERN  INIT(   char    ShouldCache, 0);
  517. X  EXTERN  char    *CurLine;
  518. X  EXTERN  INIT(   int     NumTriggered, 0);
  519. X  EXTERN  int ArgC;
  520. X--- 70,78 ----
  521. X  EXTERN  INIT(   int     NumIfs,    0);
  522. X  EXTERN  INIT(   unsigned int IfFlags,   0);
  523. X  EXTERN  INIT(   int     LastTriggerDate, 0);
  524. X! EXTERN  INIT(   int     LastTrigValid, 0);
  525. X  EXTERN  INIT(   int     LastTriggerTime, 0);
  526. X! EXTERN  INIT(   int     ShouldCache, 0);
  527. X  EXTERN  char    *CurLine;
  528. X  EXTERN  INIT(   int     NumTriggered, 0);
  529. X  EXTERN  int ArgC;
  530. X***************
  531. X*** 81,86 ****
  532. X--- 80,97 ----
  533. X  EXTERN  INIT(   int     CalLines, CAL_LINES);
  534. X  EXTERN  INIT(   int     CalPad, 1);
  535. X  
  536. X+ /* Latitude and longitude */
  537. X+ EXTERN  INIT(    int      LatDeg, LAT_DEG);
  538. X+ EXTERN  INIT(    int      LatMin, LAT_MIN);
  539. X+ EXTERN  INIT(    int      LatSec, LAT_SEC);
  540. X+ EXTERN  INIT(    int      LongDeg, LONG_DEG);
  541. X+ EXTERN  INIT(    int      LongMin, LONG_MIN);
  542. X+ EXTERN  INIT(    int      LongSec, LONG_SEC);
  543. X+ 
  544. X+ /* UTC calculation stuff */
  545. X+ EXTERN  INIT(    int      MinsFromUTC, 0);
  546. X+ EXTERN    INIT(    int      CalculateUTC, 1);
  547. X+ EXTERN  INIT(   int      FoldYear, 0);
  548. X  /* List of months */
  549. X  EXTERN    char    *MonthName[]
  550. X  #ifdef MK_GLOBALS
  551. X*** ../p6/hbcal.c    Mon May  3 11:34:29 1993
  552. X--- ./hbcal.c    Mon Jun 28 12:29:49 1993
  553. X***************
  554. X*** 48,53 ****
  555. X--- 48,57 ----
  556. X  #define JAHR_FORWARD  1
  557. X  #define JAHR_BACKWARD 2
  558. X  
  559. X+ #define ADAR2ADARB 0
  560. X+ #define ADAR2ADARA 1
  561. X+ #define ADAR2BOTH  2
  562. X+ 
  563. X  static char *HebMonthNames[] = {
  564. X     "Tishrey", "Heshvan", "Kislev", "Tevet", "Shvat", "Adar A", "Adar B",
  565. X     "Nisan", "Iyar", "Sivan", "Tamuz", "Av", "Elul", "Adar"};
  566. X***************
  567. X*** 324,334 ****
  568. X  /*                                                             */
  569. X  /***************************************************************/
  570. X  #ifdef HAVE_PROTOS
  571. X! PUBLIC int GetValidHebDate(int yin, int min, int din,
  572. X                             int *mout, int *dout, int jahr)
  573. X  #else
  574. X! int GetValidHebDate(yin, min, din, mout, dout, jahr)
  575. X! int yin, min, din, *mout, *dout, jahr;
  576. X  #endif
  577. X  {
  578. X     char *monlen;
  579. X--- 328,338 ----
  580. X  /*                                                             */
  581. X  /***************************************************************/
  582. X  #ifdef HAVE_PROTOS
  583. X! PUBLIC int GetValidHebDate(int yin, int min, int din, int adarbehave,
  584. X                             int *mout, int *dout, int jahr)
  585. X  #else
  586. X! int GetValidHebDate(yin, min, din, adarbehave, mout, dout, jahr)
  587. X! int yin, min, din, adarbehave, *mout, *dout, jahr;
  588. X  #endif
  589. X  {
  590. X     char *monlen;
  591. X***************
  592. X*** 344,355 ****
  593. X        return E_BAD_DATE;
  594. X     }
  595. X  
  596. X-    /* Convert ADAR to ADAR-B */
  597. X-    if (min == ADAR) *mout = min = ADARB;
  598. X- 
  599. X     ylen = DaysInHebYear(yin);
  600. X     monlen = DaysInHebMonths(ylen);
  601. X  
  602. X     if (din <= monlen[min]) return OK;
  603. X  
  604. X     switch(jahr) {
  605. X--- 348,371 ----
  606. X        return E_BAD_DATE;
  607. X     }
  608. X  
  609. X     ylen = DaysInHebYear(yin);
  610. X     monlen = DaysInHebMonths(ylen);
  611. X  
  612. X+    /* Convert ADAR as necessary */
  613. X+    if (min == ADAR) {
  614. X+       switch(adarbehave) {
  615. X+          case ADAR2ADARA: if (monlen[ADARA]) *mout = min = ADARA;
  616. X+               else             *mout = min = ADARB;
  617. X+               break;
  618. X+ 
  619. X+      case ADAR2ADARB: *mout = min = ADARB; break;
  620. X+ 
  621. X+      default:
  622. X+         Eprint("GetValidHebDate: Bad adarbehave value %d", adarbehave);
  623. X+         return E_SWERR;
  624. X+       }
  625. X+    }
  626. X+ 
  627. X     if (din <= monlen[min]) return OK;
  628. X  
  629. X     switch(jahr) {
  630. X***************
  631. X*** 418,443 ****
  632. X  /*                                                             */
  633. X  /***************************************************************/
  634. X  #ifdef HAVE_PROTOS
  635. X! PUBLIC int GetNextHebrewDate(int julstart, int hm, int hd, int jahr, int *ans)
  636. X  #else
  637. X! int GetNextHebrewDate(julstart, hm, hd, jahr, ans)
  638. X! int julstart, hm, hd, jahr, *ans;
  639. X  #endif
  640. X  {
  641. X     int r, yout, mout, dout, jul=1;
  642. X  
  643. X     /* I initialize jul above to stop gcc from complaining about
  644. X        possible use of uninitialized variable.  You can take it
  645. X        out if the small inefficiency really bothers you. */
  646. X  
  647. X     JulToHeb(julstart, &yout, &mout, &dout);
  648. X  
  649. X     r = 1;
  650. X     while(r) {
  651. X!       r = GetValidHebDate(yout, hm, hd, &mout, &dout, jahr);
  652. X        if (dout == -1) return r;
  653. X        if (r) {
  654. X!          yout++;
  655. X       continue;
  656. X        }
  657. X        jul = HebToJul(yout, mout, dout);
  658. X--- 434,471 ----
  659. X  /*                                                             */
  660. X  /***************************************************************/
  661. X  #ifdef HAVE_PROTOS
  662. X! PUBLIC int GetNextHebrewDate(int julstart, int hm, int hd,
  663. X!                  int jahr, int adarbehave, int *ans)
  664. X  #else
  665. X! int GetNextHebrewDate(julstart, hm, hd, jahr, adarbehave, ans)
  666. X! int julstart, hm, hd, jahr, adarbehave, *ans;
  667. X  #endif
  668. X  {
  669. X     int r, yout, mout, dout, jul=1;
  670. X+    int adarflag = adarbehave;
  671. X  
  672. X     /* I initialize jul above to stop gcc from complaining about
  673. X        possible use of uninitialized variable.  You can take it
  674. X        out if the small inefficiency really bothers you. */
  675. X  
  676. X+    /* If adarbehave == ADAR2BOTH, set adarflag to ADAR2ADARA for now */
  677. X+    if (adarbehave == ADAR2BOTH) adarflag = ADAR2ADARA;
  678. X+ 
  679. X     JulToHeb(julstart, &yout, &mout, &dout);
  680. X  
  681. X     r = 1;
  682. X     while(r) {
  683. X!       r = GetValidHebDate(yout, hm, hd, adarflag, &mout, &dout, jahr);
  684. X        if (dout == -1) return r;
  685. X        if (r) {
  686. X!          if (adarbehave == ADAR2BOTH && hm == ADAR) {
  687. X!         if (adarflag == ADAR2ADARA) {
  688. X!            adarflag = ADAR2ADARB;
  689. X!             } else {
  690. X!            adarflag = ADAR2ADARA;
  691. X!            yout++;
  692. X!             }
  693. X!          } else yout++;
  694. X       continue;
  695. X        }
  696. X        jul = HebToJul(yout, mout, dout);
  697. X***************
  698. X*** 444,450 ****
  699. X        if (jul < 0) return E_DATE_OVER;
  700. X        if (jul >= julstart) break;
  701. X        else {
  702. X!          yout++;
  703. X           r=1;  /* Force loop to continue */
  704. X        }
  705. X     }
  706. X--- 472,485 ----
  707. X        if (jul < 0) return E_DATE_OVER;
  708. X        if (jul >= julstart) break;
  709. X        else {
  710. X!          if (adarbehave == ADAR2BOTH && hm == ADAR) {
  711. X!         if (adarflag == ADAR2ADARA) {
  712. X!            adarflag = ADAR2ADARB;
  713. X!             } else {
  714. X!            adarflag = ADAR2ADARA;
  715. X!            yout++;
  716. X!             }
  717. X!          } else yout++;
  718. X           r=1;  /* Force loop to continue */
  719. X        }
  720. X     }
  721. X*** ../p6/init.c    Thu Apr 29 15:08:41 1993
  722. X--- ./init.c    Mon Jun 28 12:29:50 1993
  723. X***************
  724. X*** 61,67 ****
  725. X   *  -z[n]    = Daemon mode waking up every n (def 5) minutes.
  726. X   *  -bn      = Time format for cal (0, 1, or 2)
  727. X   *  -xn      = Max. number of iterations for SATISFY
  728. X!  *  -uname   = Run as user 'name' - only valid when run by root.
  729. X   *  -kcmd    = Run 'cmd' for MSG-type reminders instead of printing to stdout
  730. X   *  -iVAR=EXPR = Initialize and preserve VAR.
  731. X   *
  732. X--- 61,68 ----
  733. X   *  -z[n]    = Daemon mode waking up every n (def 5) minutes.
  734. X   *  -bn      = Time format for cal (0, 1, or 2)
  735. X   *  -xn      = Max. number of iterations for SATISFY
  736. X!  *  -uname   = Run as user 'name' - only valid when run by root.  If run
  737. X!  *             by non-root, changes environment but not effective uid.
  738. X   *  -kcmd    = Run 'cmd' for MSG-type reminders instead of printing to stdout
  739. X   *  -iVAR=EXPR = Initialize and preserve VAR.
  740. X   *
  741. X***************
  742. X*** 116,121 ****
  743. X--- 117,130 ----
  744. X     JulianToday = RealToday;
  745. X     FromJulian(JulianToday, &CurYear, &CurMon, &CurDay);
  746. X  
  747. X+ #if !defined(HAVE_QUEUED)
  748. X+    DontFork = 1;
  749. X+    DontQueue = 1;
  750. X+    NumQueued = 0;
  751. X+    DontIssueAts = 0;
  752. X+    Daemon = 0;
  753. X+ #endif
  754. X+ 
  755. X     /* Parse the command-line options */
  756. X     i = 1;
  757. X     while (i < argc) {
  758. X***************
  759. X*** 229,236 ****
  760. X          case 's':
  761. X          case 'S':
  762. X             DoSimpleCalendar = 1;
  763. X!            PARSENUM(CalMonths, arg);
  764. X!            if (!CalMonths) CalMonths = 1;
  765. X             break;
  766. X  
  767. X          case 'p':
  768. X--- 238,251 ----
  769. X          case 's':
  770. X          case 'S':
  771. X             DoSimpleCalendar = 1;
  772. X!            if (*arg == '+') {
  773. X!               arg++;
  774. X!               PARSENUM(CalWeeks, arg);
  775. X!           if (!CalWeeks) CalWeeks = 1;
  776. X!                } else {
  777. X!                  PARSENUM(CalMonths, arg);
  778. X!               if (!CalMonths) CalMonths = 1;
  779. X!                }
  780. X             break;
  781. X  
  782. X          case 'p':
  783. X***************
  784. X*** 357,363 ****
  785. X--- 372,383 ----
  786. X        CurMon = m;
  787. X        CurDay = d;
  788. X        if (JulianToday != RealToday) IgnoreOnce = 1;
  789. X+ 
  790. X     }
  791. X+ /* Figure out the offset from UTC */
  792. X+    if (CalculateUTC)
  793. X+       (void) CalcMinsFromUTC(JulianToday, SystemTime()/60,
  794. X+                  &MinsFromUTC, NULL);
  795. X  }
  796. X  
  797. X  /***************************************************************/
  798. X***************
  799. X*** 384,390 ****
  800. X     fprintf(ErrFp, " -c[n]  Produce a calendar for n (default 1) months\n");
  801. X     fprintf(ErrFp, " -c+[n] Produce a calendar for n (default 1) weeks\n");
  802. X     fprintf(ErrFp, " -w[n[,p[,s]]]  Specify width, padding and spacing of calendar\n");
  803. X!    fprintf(ErrFp, " -s[n]  Produce 'simple calendar' for n (1) months\n");
  804. X     fprintf(ErrFp, " -p[n]  Same as -s, but input compatible with rem2ps\n");
  805. X     fprintf(ErrFp, " -v     Verbose mode\n");
  806. X     fprintf(ErrFp, " -o     Ignore ONCE directives\n");
  807. X--- 404,410 ----
  808. X     fprintf(ErrFp, " -c[n]  Produce a calendar for n (default 1) months\n");
  809. X     fprintf(ErrFp, " -c+[n] Produce a calendar for n (default 1) weeks\n");
  810. X     fprintf(ErrFp, " -w[n[,p[,s]]]  Specify width, padding and spacing of calendar\n");
  811. X!    fprintf(ErrFp, " -s[+][n] Produce 'simple calendar' for n (1) months (weeks)\n");
  812. X     fprintf(ErrFp, " -p[n]  Same as -s, but input compatible with rem2ps\n");
  813. X     fprintf(ErrFp, " -v     Verbose mode\n");
  814. X     fprintf(ErrFp, " -o     Ignore ONCE directives\n");
  815. X***************
  816. X*** 402,408 ****
  817. X     fprintf(ErrFp, " -x[n]  Iteration limit for SATISFY clause (def=150)\n");
  818. X     fprintf(ErrFp, " -kcmd  Run 'cmd' for MSG-type reminders\n");
  819. X     fprintf(ErrFp, " -g[d[d]] Sort reminders by date and time before issuing\n");
  820. X!    fprintf(ErrFp, "-ivar=val Initialize var to val and preserve var\n");
  821. X     exit(1);
  822. X  }
  823. X  
  824. X--- 422,428 ----
  825. X     fprintf(ErrFp, " -x[n]  Iteration limit for SATISFY clause (def=150)\n");
  826. X     fprintf(ErrFp, " -kcmd  Run 'cmd' for MSG-type reminders\n");
  827. X     fprintf(ErrFp, " -g[d[d]] Sort reminders by date and time before issuing\n");
  828. X!    fprintf(ErrFp, " -ivar=val Initialize var to val and preserve var\n");
  829. X     exit(1);
  830. X  }
  831. X  
  832. X***************
  833. X*** 436,445 ****
  834. X     static char *home, *shell, *username, *logname;
  835. X  
  836. X     myuid = getuid();
  837. X-    if (myuid) {
  838. X-       fprintf(ErrFp, "Remind: Only the super-user can use the '-u' option.\n");
  839. X-       exit(1);
  840. X-    }
  841. X  
  842. X     pwent = getpwnam(user);
  843. X  
  844. X--- 456,461 ----
  845. X***************
  846. X*** 448,459 ****
  847. X        exit(1);
  848. X     }
  849. X  
  850. X!    if (setgid(pwent->pw_gid)) {
  851. X        fprintf(ErrFp, "Remind: Could not change gid to %d\n", pwent->pw_gid);
  852. X        exit(1);
  853. X     }
  854. X  
  855. X!    if (setuid(pwent->pw_uid)) {
  856. X        fprintf(ErrFp, "Remind: Could not change uid to %d\n", pwent->pw_uid);
  857. X        exit(1);
  858. X     }
  859. X--- 464,475 ----
  860. X        exit(1);
  861. X     }
  862. X  
  863. X!    if (!myuid && setgid(pwent->pw_gid)) {
  864. X        fprintf(ErrFp, "Remind: Could not change gid to %d\n", pwent->pw_gid);
  865. X        exit(1);
  866. X     }
  867. X  
  868. X!    if (!myuid && setuid(pwent->pw_uid)) {
  869. X        fprintf(ErrFp, "Remind: Could not change uid to %d\n", pwent->pw_uid);
  870. X        exit(1);
  871. X     }
  872. X***************
  873. X*** 535,540 ****
  874. X--- 551,566 ----
  875. X     r=EvalExpr(&expr, &val);
  876. X     if (r) {
  877. X        fprintf(ErrFp, Err, ErrMsg[r]);
  878. X+       return;
  879. X+    }
  880. X+ 
  881. X+    if (*varname == '$') {
  882. X+       if (val.type != INT_TYPE) {
  883. X+          fprintf(ErrFp, Err, ErrMsg[E_BAD_TYPE]);
  884. X+      return;
  885. X+       }
  886. X+       r=SetSysVar(varname+1, val.v.val);
  887. X+       if (r) fprintf(ErrFp, Err, ErrMsg[r]);
  888. X        return;
  889. X     }
  890. X  
  891. X*** ../p6/kall    Thu Apr 22 10:24:09 1993
  892. X--- ./kall    Mon Jun 28 12:30:15 1993
  893. X***************
  894. X*** 25,31 ****
  895. X  
  896. X  # NOTE:  You may have to modify the next line, since PS is non-portable.
  897. X  # The 'awk' command picks out the process IDs to pass them on to kill.
  898. X!     rprocs=`ps cx | awk '{if(prog == $NF) print $1}' prog=$1 -`
  899. X      if [ "$rprocs" != "" ]; then
  900. X          msg="1"
  901. X          echo -n "${me}: Sending $signal signal to $1 process(es)"
  902. X--- 25,31 ----
  903. X  
  904. X  # NOTE:  You may have to modify the next line, since PS is non-portable.
  905. X  # The 'awk' command picks out the process IDs to pass them on to kill.
  906. X!     rprocs=`ps cx | awk '{if(prog == $NF && $1 != mypid) print $1}' prog=$1 mypid=$$ -`
  907. X      if [ "$rprocs" != "" ]; then
  908. X          msg="1"
  909. X          echo -n "${me}: Sending $signal signal to $1 process(es)"
  910. X*** ../p6/main.c    Thu Apr 22 10:24:10 1993
  911. X--- ./main.c    Mon Jun 28 12:39:37 1993
  912. X***************
  913. X*** 30,38 ****
  914. X  
  915. X  #ifdef __MSDOS__
  916. X  #include <dos.h>
  917. X! # ifdef __MSC__
  918. X! # include <time.h>
  919. X! # endif
  920. X  #endif
  921. X  
  922. X  
  923. X--- 30,36 ----
  924. X  
  925. X  #ifdef __MSDOS__
  926. X  #include <dos.h>
  927. X! #include <time.h>
  928. X  #endif
  929. X  
  930. X  
  931. X***************
  932. X*** 92,98 ****
  933. X     /* Not doing a calendar.  Do the regular remind loop */
  934. X     DoReminders();
  935. X  
  936. X!    if (DebugFlag & DB_DUMP_VARS) DumpVarTable();
  937. X  
  938. X     if (!Hush) {
  939. X        if (DestroyOmitContexts())
  940. X--- 90,99 ----
  941. X     /* Not doing a calendar.  Do the regular remind loop */
  942. X     DoReminders();
  943. X  
  944. X!    if (DebugFlag & DB_DUMP_VARS) {
  945. X!       DumpVarTable();
  946. X!       DumpSysVarByName(NULL);
  947. X!    }
  948. X  
  949. X     if (!Hush) {
  950. X        if (DestroyOmitContexts())
  951. X***************
  952. X*** 482,488 ****
  953. X        if (err) return err;
  954. X     }
  955. X     if (!c) return E_EOLN;
  956. X!    if (c != '_' && !isalpha(c)) return E_BAD_ID;
  957. X     *out++ = c;
  958. X     *out = 0;
  959. X     len++;
  960. X--- 483,489 ----
  961. X        if (err) return err;
  962. X     }
  963. X     if (!c) return E_EOLN;
  964. X!    if (c != '$' && c != '_' && !isalpha(c)) return E_BAD_ID;
  965. X     *out++ = c;
  966. X     *out = 0;
  967. X     len++;
  968. X***************
  969. X*** 1048,1058 ****
  970. X     if ( (r=ParseToken(p, TokBuffer)) ) return r;
  971. X  
  972. X  /* Only allow RUN ON in top-level script */
  973. X!    if (StriEq(TokBuffer, "ON")) {
  974. X        if (TopLevel()) RunDisabled &= ~RUN_SCRIPT;
  975. X     }
  976. X  /* But allow RUN OFF anywhere */
  977. X!    else if (StriEq(TokBuffer, "OFF"))
  978. X        RunDisabled |= RUN_SCRIPT;
  979. X     else return E_PARSE_ERR;
  980. X  
  981. X--- 1049,1059 ----
  982. X     if ( (r=ParseToken(p, TokBuffer)) ) return r;
  983. X  
  984. X  /* Only allow RUN ON in top-level script */
  985. X!    if (! StrCmpi(TokBuffer, "ON")) {
  986. X        if (TopLevel()) RunDisabled &= ~RUN_SCRIPT;
  987. X     }
  988. X  /* But allow RUN OFF anywhere */
  989. X!    else if (! StrCmpi(TokBuffer, "OFF"))
  990. X        RunDisabled |= RUN_SCRIPT;
  991. X     else return E_PARSE_ERR;
  992. X  
  993. X***************
  994. X*** 1088,1090 ****
  995. X--- 1089,1164 ----
  996. X     return OK;
  997. X  }
  998. X  
  999. X+ /***************************************************************/
  1000. X+ /*                                                             */
  1001. X+ /*  CalcMinsFromUTC                                            */
  1002. X+ /*                                                             */
  1003. X+ /*  Attempt to calculate the minutes from UTC for a specific   */
  1004. X+ /*  date.                                                      */
  1005. X+ /*                                                             */
  1006. X+ /***************************************************************/
  1007. X+ 
  1008. X+ /* The array FoldArray[2][7] contains sample years which begin
  1009. X+    on the specified weekday.  For example, FoldArray[0][2] is a
  1010. X+    non-leapyear beginning on Wednesday, and FoldArray[1][5] is a
  1011. X+    leapyear beginning on Saturday.  Used to fold back dates which
  1012. X+    are too high for the standard Unix representation. 
  1013. X+    NOTE:  This implies that you cannot set BASE > 2001!!!!! */
  1014. X+ static int FoldArray[2][7] = {
  1015. X+    {2001, 2002, 2003, 2009, 2010, 2005, 2006},
  1016. X+    {2024, 2008, 2020, 2004, 2016, 2000, 2012}
  1017. X+ };
  1018. X+ 
  1019. X+ #ifdef HAVE_PROTOS
  1020. X+ PUBLIC int CalcMinsFromUTC(int jul, int tim, int *mins, int *isdst)
  1021. X+ #else
  1022. X+ int CalcMinsFromUTC(jul, tim, mins, isdst)
  1023. X+ int jul, tim, *mins, *isdst;
  1024. X+ #endif
  1025. X+ {
  1026. X+ 
  1027. X+ /* Convert jul and tim to an Unix tm struct */
  1028. X+    int yr, mon, day;
  1029. X+    struct tm local, utc, *temp;
  1030. X+    time_t loc_t, utc_t;
  1031. X+ 
  1032. X+    FromJulian(jul, &yr, &mon, &day);
  1033. X+ 
  1034. X+ /* If the year is greater than 2037, some Unix machines have problems.
  1035. X+    Fold it back to a "similar" year and trust that the UTC calculations
  1036. X+    are still valid... */
  1037. X+    if (FoldYear && yr>2037) {
  1038. X+       jul = Julian(yr, 0, 1);
  1039. X+       yr = FoldArray[IsLeapYear(yr)][jul%7];
  1040. X+    }
  1041. X+    local.tm_sec = 0;
  1042. X+    local.tm_min = tim % 60;
  1043. X+    local.tm_hour = tim / 60;
  1044. X+    local.tm_mday = day;
  1045. X+    local.tm_mon = mon;
  1046. X+    local.tm_year = yr-1900;
  1047. X+    local.tm_isdst = -1;  /* We don't know whether or not dst is in effect */
  1048. END_OF_FILE
  1049.   if test 31602 -ne `wc -c <'patch.07.B'`; then
  1050.     echo shar: \"'patch.07.B'\" unpacked with wrong size!
  1051.   elif test -f 'patch.07.A' && test -f 'patch.07.C'; then
  1052.     echo shar: Combining  \"'patch.07'\" \(117693 characters\)
  1053.     cat 'patch.07.A' 'patch.07.B' 'patch.07.C' > 'patch.07'
  1054.     if test 117693 -ne `wc -c <'patch.07'`; then
  1055.       echo shar: \"'patch.07'\" combined with wrong size!
  1056.     else
  1057.       rm patch.07.A patch.07.B patch.07.C
  1058.     fi
  1059.   fi
  1060.   # end of 'patch.07.B'
  1061. fi
  1062. echo shar: End of archive 3 \(of 3\).
  1063. cp /dev/null ark3isdone
  1064. MISSING=""
  1065. for I in 1 2 3 ; do
  1066.     if test ! -f ark${I}isdone ; then
  1067.     MISSING="${MISSING} ${I}"
  1068.     fi
  1069. done
  1070. if test "${MISSING}" = "" ; then
  1071.     echo You have unpacked all 3 archives.
  1072.     rm -f ark[1-9]isdone
  1073. else
  1074.     echo You still must unpack the following archives:
  1075.     echo "        " ${MISSING}
  1076. fi
  1077. exit 0
  1078. exit 0 # Just in case...
  1079.