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