home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / misc / volume35 / hebcal / part01 next >
Text File  |  1993-02-21  |  53KB  |  1,944 lines
  1. Newsgroups: comp.sources.misc,soc.culture.jewish
  2. From: sadinoff@unagi.cis.upenn.edu (Danny Sadinoff)
  3. Subject: v35i076:  hebcal - A Jewish calendar generator, v2.0, Part01/01
  4. Message-ID: <1993Feb22.035212.14721@sparky.imd.sterling.com>
  5. X-Md4-Signature: c40b69fb42d9e91ed258eb9aea8dbbc6
  6. Date: Mon, 22 Feb 1993 03:52:12 GMT
  7. Approved: kent@sparky.imd.sterling.com
  8.  
  9. Submitted-by: sadinoff@unagi.cis.upenn.edu (Danny Sadinoff)
  10. Posting-number: Volume 35, Issue 76
  11. Archive-name: hebcal/part01
  12. Environment: UNIX
  13. Supersedes: hebcal: Volume 34, Issue 117
  14.  
  15.             [ THIS PROGRAM IS SHAREWARE/GUILTWARE  -Kent+ ]
  16.  
  17. Hebcal 2.0  - a program for printing Jewish calendars
  18.   by Danny Sadinoff
  19.  
  20. DESCRIPTION
  21. Hebcal is a program which prints out the days in the Jewish calendar
  22. for a given gregorian year.  Hebcal is fairly flexible in terms of which
  23. events in the Jewish calendar it displays.  Each of the following can
  24. be individualy turned on or off:
  25.  
  26.   The Hebrew date
  27.   Jewish Holdiays (including Yom Ha'atzmaut and Yom HaShoah etc.)
  28.   The weekly Sedrah
  29.   The day of the week
  30.   The days of the Omer
  31.  
  32. CHANGES 
  33. Since version 1.4:
  34.   Optimized code, with an eye towards the -t and -T switches
  35.   Added -i user events option.
  36.   Added -S "what's this week's sedra?" option
  37.  
  38. Since version 1.3:
  39.   This is a quickie fix of the new Chanukah routine added in the last release
  40.   I also changed the suffix of the manpage from .l to .1, since it was
  41.      causing some versions of make to compile the manpage as a lex
  42.      file, destroying the source code in the process.
  43.   Added Yom Yerushalayim 
  44.    changed output format from "24 of Kislev" to "24th of Kislev"
  45.  
  46. Since version 1.2:
  47.   Fixed a critical bug which put Purim on the 15th of Adar, instead of
  48.     the 14th
  49.   Now uses sys/types.h instead of stdlib.h
  50.   Added the rest of the 8 days of Chanukah
  51.   Added -e European output switch.
  52.  
  53. Since version 1.1, the following changes were made:
  54.   Changed usage-- the -p "parshiot" switch was changed to "-s" sedrot switch
  55.   Fixed certain slippery variable type bugs
  56.   Changed code to K&R old style
  57.   Added Manpage
  58.   Decided to change the "Distribu-Ware" to a normal shareware.
  59.  
  60. DISTRIBUTION
  61. This program is GUILTWARE. 
  62. It may be distributed freely, with a few conditions:
  63.    1) The package must be distributed INTACT with ALL source code, as
  64.    well as this file.  You are welcome to modify the code,
  65.    but DON'T distribute it modified.  This disclaimer should certainly
  66.    appear with every distributed copy.
  67.    
  68.    2) You can use this program for free for one week.  After that
  69.    trial period, if you wish to use this program, drop me a line.
  70.    I'd like to know who you are, what version you're using, and how
  71.    you're using hebcal, and anything else you'd like to tell me, so
  72.    that I can adjust the program to meet users' needs.
  73.  
  74.    I am NOT demanding payment for the use of my program, but writing
  75.    this program DID take time.  Feel free to send $10 to
  76.    me at my US Mail address. (hint)
  77.  
  78.    send US Mail to:        send email to:
  79.     Danny Sadinoff       sadinoff@eniac.seas.upenn.edu
  80.     1 Cove La. 
  81.     Great Neck, NY 11024
  82.  
  83.    Email respondents will receive notifications of new versions as they
  84.    come out, as will US Mail responents (if they send me postage for a disk).
  85.  
  86.    If you do not mail me or email me after one week, please don't
  87.    use the program, although you may feel free to distribute it further.
  88.  
  89.  
  90. COMPILATION
  91. The code has K&R "old style" declarations in it, so it should compile
  92. on most machines.
  93. The distribution includes a "Makefile" so once you've unpacked all the
  94. files, (including this one) just run the command "make" and that
  95. should compile everything for you.
  96.  
  97. The file hebcal.1 is the manual page.  For information on using man in
  98. conjunction with local manpages, see the manpage for man.  Briefly, to
  99. read a manpage, type 
  100. nroff -man <filename> | more
  101.  
  102. #! /bin/sh
  103. # This is a shell archive.  Remove anything before this line, then feed it
  104. # into a shell via "sh file" or similar.  To overwrite existing files,
  105. # type "sh file -c".
  106. # Contents:  README Makefile danlib.c danlib.h error.c error.h greg.c
  107. #   greg.h hebcal.1 hebcal.c hebcal.h start.c
  108. # Wrapped by kent@sparky on Sat Feb 20 23:25:26 1993
  109. PATH=/bin:/usr/bin:/usr/ucb:/usr/local/bin:/usr/lbin ; export PATH
  110. echo If this archive is complete, you will see the following message:
  111. echo '          "shar: End of archive 1 (of 1)."'
  112. if test -f 'README' -a "${1}" != "-c" ; then 
  113.   echo shar: Will not clobber existing file \"'README'\"
  114. else
  115.   echo shar: Extracting \"'README'\" \(6003 characters\)
  116.   sed "s/^X//" >'README' <<'END_OF_FILE'
  117. XHebcal 2.0  - a program for printing Jewish calendars
  118. X  by Danny Sadinoff
  119. X
  120. XDESCRIPTION
  121. XHebcal is a program which prints out the days in the Jewish calendar
  122. Xfor a given gregorian year.  Hebcal is fairly flexible in terms of which
  123. Xevents in the Jewish calendar it displays.  Each of the following can
  124. Xbe individualy turned on or off:
  125. X
  126. X  The Hebrew date
  127. X  Jewish Holdiays (including Yom Ha'atzmaut and Yom HaShoah etc.)
  128. X  The weekly Sedrah
  129. X  The day of the week
  130. X  The days of the Omer
  131. X
  132. XCHANGES 
  133. XSince version 1.4:
  134. X  Optimized code, with an eye towards the -t and -T switches
  135. X  Added -i user events option.
  136. X  Added -S "what's this week's sedra?" option
  137. X
  138. XSince version 1.3:
  139. X  This is a quickie fix of the new Chanukah routine added in the last release
  140. X  I also changed the suffix of the manpage from .l to .1, since it was
  141. X     causing some versions of make to compile the manpage as a lex
  142. X     file, destroying the source code in the process.
  143. X  Added Yom Yerushalayim 
  144. X   changed output format from "24 of Kislev" to "24th of Kislev"
  145. X
  146. XSince version 1.2:
  147. X  Fixed a critical bug which put Purim on the 15th of Adar, instead of
  148. X    the 14th
  149. X  Now uses sys/types.h instead of stdlib.h
  150. X  Added the rest of the 8 days of Chanukah
  151. X  Added -e European output switch.
  152. X
  153. XSince version 1.1, the following changes were made:
  154. X  Changed usage-- the -p "parshiot" switch was changed to "-s" sedrot switch
  155. X  Fixed certain slippery variable type bugs
  156. X  Changed code to K&R old style
  157. X  Added Manpage
  158. X  Decided to change the "Distribu-Ware" to a normal shareware.
  159. X
  160. XDISTRIBUTION
  161. XThis program is GUILTWARE. 
  162. XIt may be distributed freely, with a few conditions:
  163. X   1) The package must be distributed INTACT with ALL source code, as
  164. X   well as this file.  You are welcome to modify the code,
  165. X   but DON'T distribute it modified.  This disclaimer should certainly
  166. X   appear with every distributed copy.
  167. X   
  168. X   2) You can use this program for free for one week.  After that
  169. X   trial period, if you wish to use this program, drop me a line.
  170. X   I'd like to know who you are, what version you're using, and how
  171. X   you're using hebcal, and anything else you'd like to tell me, so
  172. X   that I can adjust the program to meet users' needs.
  173. X
  174. X   I am NOT demanding payment for the use of my program, but writing
  175. X   this program DID take time.  Feel free to send $10 to
  176. X   me at my US Mail address. (hint)
  177. X
  178. X   send US Mail to:        send email to:
  179. X    Danny Sadinoff       sadinoff@eniac.seas.upenn.edu
  180. X    1 Cove La. 
  181. X    Great Neck, NY 11024
  182. X
  183. X   Email respondents will receive notifications of new versions as they
  184. X   come out, as will US Mail responents (if they send me postage for a disk).
  185. X
  186. X   If you do not mail me or email me after one week, please don't
  187. X   use the program, although you may feel free to distribute it further.
  188. X
  189. X 
  190. XCOMPILATION
  191. XThe code has K&R "old style" declarations in it, so it should compile
  192. Xon most machines.
  193. XThe distribution includes a "Makefile" so once you've unpacked all the
  194. Xfiles, (including this one) just run the command "make" and that
  195. Xshould compile everything for you.
  196. X
  197. XThe file hebcal.1 is the manual page.  For information on using man in
  198. Xconjunction with local manpages, see the manpage for man.  Briefly, to
  199. Xread a manpage, type 
  200. Xnroff -man <filename> | more
  201. X
  202. X
  203. XOPERATION:
  204. XThe operation of hebcal is fairly simple.  Hebcal defaults to printing
  205. Xout the holidays for the current gregorian year.  With the
  206. Xcommand-line options, a specific gregorian year, month or date can be
  207. Xspecified.  
  208. X
  209. XGiven one numeric argument, hebcal will print out the calendar 
  210. Xfor that year.  Given two numeric argumetnts mm yyyy, it
  211. Xprints out the calendar for month mm of year yyyy.  Given three
  212. Xnumeric arguments mm dd yyyy, it will print out the hebrew calendar
  213. Xentries for day dd of month mm of year yyyy.  In the last case, the -d
  214. Xoption is automatically enabled.
  215. X
  216. XBe sure to give the whole year to hebcal.  
  217. Xhebcal 92 will return the calendar for a time somewhere in the early
  218. Xchristian era, not in the twentieth century.  Use hebcal 1992 instead.
  219. X
  220. Xusage: hebcal [-dehosStTw] [-i filename] [[month [day]] year]  
  221. X       hebcal help --- prints this message. 
  222. X
  223. XOPTIONS:  
  224. X   -d : add hebrew dates
  225. X   -e : use European dates (dd mm yyyy) for OUTPUT ONLY (input format
  226. X        the same)
  227. X   -h : suppress holidays
  228. X   -i : draw user-defined calendar events from the specified file
  229. X   -o : add days of the omer
  230. X   -s : add weekly sedrot on Saturdays
  231. X   -S : add sedra of the week every day
  232. X   -t : only output today's date.  This switch implies the -d switch.
  233. X   -T : only output today's date, suppressing gregorian date. This
  234. X        switch implies the -d and -o switches.
  235. X   -w : add day of the week
  236. X
  237. X
  238. XExamples: 
  239. Xexample% hebcal -ho
  240. X4/19/1992 1st day of the Omer
  241. X4/20/1992 2nd day of the Omer
  242. X4/21/1992 3rd day of the Omer
  243. X4/22/1992 4th day of the Omer
  244. X4/23/1992 5th day of the Omer
  245. X4/24/1992 6th day of the Omer
  246. X.
  247. X.
  248. X6/5/1992 48th day of the Omer
  249. X6/6/1992 49th day of the Omer
  250. X
  251. Xto find out what's happening in today's Jewish calendar, use
  252. Xexample% hebcal -ToS
  253. X19 of Nisan, 5752
  254. XPesach V (CH"M)
  255. X4th day of the Omer
  256. X
  257. X
  258. XDISCLAIMER
  259. XI tried to make this program as accurate as possible.  However, I
  260. Xtake no responsibility for any horrible consequences which may come
  261. Xabout as a result of faulty output from this program.  Remember: never
  262. Xtrust a program with a zero at the end of its revision number.
  263. X
  264. XThe secular dates before september 1752 are off by two weeks due to
  265. Xthe correction that took place then.
  266. X
  267. XThe secular dates before 1522 become progressively meaningless, as I
  268. Xmade no correction for the changeover from julian to gregorian
  269. Xcalendars; but the Hebrew dates and years are correct.
  270. X
  271. XCOMING SOON
  272. XFeatures to be included in future versions:
  273. X  - Arba' parshiot
  274. X  - The ability to specify and output a particular HEBREW year, month
  275. X    or date.   The absence of this feature is a serious drawback to
  276. X    hebcal as it now stands.
  277. X
  278. XGRIPES
  279. Xsend questions, comments or complaints to:
  280. XDanny Sadinoff
  281. Xsadinoff@eniac.seas.upenn.edu
  282. END_OF_FILE
  283.   if test 6003 -ne `wc -c <'README'`; then
  284.     echo shar: \"'README'\" unpacked with wrong size!
  285.   fi
  286.   # end of 'README'
  287. fi
  288. if test -f 'Makefile' -a "${1}" != "-c" ; then 
  289.   echo shar: Will not clobber existing file \"'Makefile'\"
  290. else
  291.   echo shar: Extracting \"'Makefile'\" \(99 characters\)
  292.   sed "s/^X//" >'Makefile' <<'END_OF_FILE'
  293. XCFLAGS = -O
  294. XOBJ= start.o hebcal.o greg.o error.o danlib.o
  295. Xhebcal:  $(OBJ)
  296. X     $(CC) $(OBJ) -o hebcal
  297. END_OF_FILE
  298.   if test 99 -ne `wc -c <'Makefile'`; then
  299.     echo shar: \"'Makefile'\" unpacked with wrong size!
  300.   fi
  301.   # end of 'Makefile'
  302. fi
  303. if test -f 'danlib.c' -a "${1}" != "-c" ; then 
  304.   echo shar: Will not clobber existing file \"'danlib.c'\"
  305. else
  306.   echo shar: Extracting \"'danlib.c'\" \(1285 characters\)
  307.   sed "s/^X//" >'danlib.c' <<'END_OF_FILE'
  308. X#include <stdio.h>
  309. X#include <sys/types.h>
  310. X#include <ctype.h>
  311. X#include "danlib.h"
  312. X#include "error.h"
  313. X
  314. X/* Some generally useful routines */
  315. X  
  316. Xvoid initStr(s,size)
  317. Xchar **s;
  318. Xint size;
  319. X{
  320. X  /* allocate space for a string */
  321. X  if ((*s = (char *)malloc((size_t) (size + 1) * sizeof(char))) == NULL)
  322. X    die("\n Memory Error: Couldn't allocate string\n","");
  323. X
  324. X  **s = '\0';
  325. X}
  326. X
  327. Xint isAllNums(s)
  328. Xchar * s;
  329. X{
  330. X/* returns true if a string contains only digits, dashes and newlines */
  331. X  int n = 0, len = strlen(s);
  332. X  
  333. X  for(n=0;
  334. X      (n < len)  &&  ( isdigit(s[n]) || (s[n] == '-') || (s[n] == '\n'));
  335. X      n++);
  336. X  return (n == len);
  337. X}
  338. X
  339. Xchar * numSuffix(i)
  340. Xint i;
  341. X{
  342. X/* returns he proper ordinal suffix of a number */
  343. X  if ((i / 10) == 1) return "th";
  344. X  switch (i % 10) {
  345. X  case 1 : return "st";
  346. X  case 2 : return "nd";
  347. X  case 3 : return "rd";
  348. X  default: return "th";
  349. X  }
  350. X}
  351. X
  352. Xchar * itoa (i) 
  353. Xint i;
  354. X{
  355. X  static char ret[7];
  356. X  int c = 0;
  357. X  char tmp;
  358. X
  359. X  if (i < 0) {            /* is i negative? */
  360. X    ret[c++] = '-';        /* then put a minus */
  361. X    i = abs(i);
  362. X  }
  363. X  
  364. X  while (i >0) {        /* compose the number */
  365. X    ret[c++] = (i % 10) + '0';
  366. X    i /= 10;
  367. X  }
  368. X  i = c-1;
  369. X  
  370. X  for (c =0; c < i; c++) {    /* reverse the number */
  371. X    tmp = ret[c];
  372. X    ret[c] = ret[i-c];
  373. X    ret[i-c] = tmp;
  374. X  } 
  375. X
  376. X  return ret;
  377. X}
  378. X 
  379. X
  380. END_OF_FILE
  381.   if test 1285 -ne `wc -c <'danlib.c'`; then
  382.     echo shar: \"'danlib.c'\" unpacked with wrong size!
  383.   fi
  384.   # end of 'danlib.c'
  385. fi
  386. if test -f 'danlib.h' -a "${1}" != "-c" ; then 
  387.   echo shar: Will not clobber existing file \"'danlib.h'\"
  388. else
  389.   echo shar: Extracting \"'danlib.h'\" \(187 characters\)
  390.   sed "s/^X//" >'danlib.h' <<'END_OF_FILE'
  391. X#ifndef __DANLIB__
  392. X#define __DANLIB
  393. X
  394. X#define CHAR2NUM(x) ((x) - '0')
  395. X#define LAST_INDEX(x) (sizeof x / sizeof x[0])
  396. X
  397. Xint isAllNums();
  398. Xvoid initStr();
  399. Xchar * numSuffix(), *itoa();
  400. X
  401. X#endif
  402. END_OF_FILE
  403.   if test 187 -ne `wc -c <'danlib.h'`; then
  404.     echo shar: \"'danlib.h'\" unpacked with wrong size!
  405.   fi
  406.   # end of 'danlib.h'
  407. fi
  408. if test -f 'error.c' -a "${1}" != "-c" ; then 
  409.   echo shar: Will not clobber existing file \"'error.c'\"
  410. else
  411.   echo shar: Extracting \"'error.c'\" \(589 characters\)
  412.   sed "s/^X//" >'error.c' <<'END_OF_FILE'
  413. X#include "error.h"
  414. X
  415. Xextern int errno, sys_nerr;
  416. Xextern char *sys_errlist[], *progname;
  417. X
  418. Xvoid die (s1,s2)    /* print error message and die */
  419. Xchar *s1, *s2;
  420. X{
  421. X  if (progname)
  422. X    fprintf(stderr, "%s: ", progname);
  423. X  fprintf(stderr, s1, s2);
  424. X  if (errno > 0 && errno < sys_nerr)
  425. X    fprintf(stderr, " (%s)\n", sys_errlist[errno]);
  426. X  exit(1);
  427. X}
  428. X
  429. Xvoid warn (s1,s2) /* print error message but don't die */
  430. Xchar *s1, *s2;
  431. X{
  432. X  if (progname)
  433. X    fprintf(stderr, "%s: ", progname);
  434. X  fprintf(stderr, s1, s2);
  435. X  if (errno > 0 && errno < sys_nerr)
  436. X    fprintf(stderr, " (%s)\n", sys_errlist[errno]);
  437. X}
  438. END_OF_FILE
  439.   if test 589 -ne `wc -c <'error.c'`; then
  440.     echo shar: \"'error.c'\" unpacked with wrong size!
  441.   fi
  442.   # end of 'error.c'
  443. fi
  444. if test -f 'error.h' -a "${1}" != "-c" ; then 
  445.   echo shar: Will not clobber existing file \"'error.h'\"
  446. else
  447.   echo shar: Extracting \"'error.h'\" \(102 characters\)
  448.   sed "s/^X//" >'error.h' <<'END_OF_FILE'
  449. X#ifndef __ERROR__
  450. X#define __ERROR__
  451. X#include <stdio.h>
  452. X#include <errno.h>
  453. X
  454. Xvoid die(), warn();
  455. X#endif
  456. END_OF_FILE
  457.   if test 102 -ne `wc -c <'error.h'`; then
  458.     echo shar: \"'error.h'\" unpacked with wrong size!
  459.   fi
  460.   # end of 'error.h'
  461. fi
  462. if test -f 'greg.c' -a "${1}" != "-c" ; then 
  463.   echo shar: Will not clobber existing file \"'greg.c'\"
  464. else
  465.   echo shar: Extracting \"'greg.c'\" \(2697 characters\)
  466.   sed "s/^X//" >'greg.c' <<'END_OF_FILE'
  467. X#include "greg.h"
  468. X
  469. X/* greg.c gregorian calendar module for hebrew calendar program
  470. X   By Danny Sadinoff
  471. X   (C) 1992
  472. X
  473. X*/
  474. X
  475. Xchar * eMonths[] = { 
  476. X  "January","February","March","April","May","June","July",
  477. X  "August","September","October","November","December"
  478. X  };
  479. X              
  480. Xint MonthLengths[][12] ={ 
  481. X  {31,28,31,30,31,30,31,31,30,31,30,31},
  482. X  {31,29,31,30,31,30,31,31,30,31,30,31}
  483. X};
  484. X
  485. Xchar * DayNames[] = {
  486. X  "Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"
  487. X  };
  488. X
  489. Xchar * ShortDayNames[] = {
  490. X  "Sun","Mon","Tue","Wed","Thu","Fri","Sat"
  491. X  };
  492. X
  493. Xstatic void checkRange (dt,routine)
  494. Xdate_t dt;
  495. Xchar * routine;
  496. X{
  497. X  if ((dt.mm > 13)||(dt.dd > 31) || (dt.yy > 7000) || 
  498. X      (dt.mm <0)  ||(dt.dd <0  ) || (dt.yy < -7000))
  499. X    die("Date out of range from routine %s.",routine);
  500. X}
  501. X
  502. Xstatic long int daysSinceOrigin (dt)
  503. Xdate_t dt;
  504. X{
  505. X  int m,y;
  506. X  long int days = 0L;
  507. X
  508. X  checkRange(dt,"daysSinceOrigin");
  509. X
  510. X  for (y =1; y < dt.yy; y++)
  511. X    days += DAYS_IN(y);
  512. X  y = dt.yy;
  513. X  for (m= JAN; m < dt.mm; m++)
  514. X    days += MonthLengths[LEAP(y)][m];
  515. X  days += dt.dd -1;
  516. X  return days;
  517. X}
  518. X
  519. Xint diffDays(d1,d2)
  520. Xdate_t d1, d2;
  521. X{
  522. X  return (int) (daysSinceOrigin(d1) - daysSinceOrigin(d2));
  523. X}
  524. X
  525. Xint exceeds (d1,d2)
  526. Xdate_t d1, d2;
  527. X{
  528. X  if (d1.yy > d2.yy)
  529. X    return 1;
  530. X  else if (d1.yy < d2.yy)
  531. X    return 0;
  532. X  else if (d1.mm > d2.mm)
  533. X    return 1;
  534. X  else if (d1.mm < d2.mm)
  535. X    return 0;
  536. X  else if (d1.dd > d2.dd)
  537. X    return 1;
  538. X  else return 0;
  539. X}
  540. X
  541. Xvoid decDate (dt,n) /* decrements dt by n days */
  542. Xdate_t *dt;
  543. Xint n;
  544. X{
  545. X/*under construction*/
  546. X/*  while (n > 365) {
  547. X    n -= DAYS_IN(dt->yy -1);
  548. X    dt ->yy--;
  549. X  }
  550. X
  551. X
  552. X  if ((dt->mm == FEB) && (dt->dd == 29) && !LEAP(dt->yy))
  553. X    dt->dd--;
  554. X*/
  555. X  
  556. X  while (n--) 
  557. X    if (dt->dd ==1) {
  558. X      if (dt->mm == JAN) {
  559. X    dt->yy--;
  560. X    dt->mm = DEC;
  561. X    dt->dd = 31;
  562. X      }
  563. X      else {
  564. X    dt->mm--;
  565. X    dt->dd = MonthLengths[LEAP(dt->yy)][dt->mm];
  566. X      }
  567. X    }
  568. X    else dt->dd--;
  569. X}
  570. X
  571. Xvoid incDate (dt,n)   /* increments dt by n days */
  572. Xdate_t *dt;
  573. Xint n;
  574. X{
  575. X/*  while (n > 365) {
  576. X    n -= DAYS_IN(dt->yy);
  577. X    dt->yy++;
  578. X  }
  579. X
  580. X  if ((dt->mm == FEB) && (dt->dd == 29) && !LEAP(dt->yy) ) {
  581. X    dt-> mm = MAR;
  582. X    dt-> dd = 1;
  583. X  }
  584. X*/
  585. X  while (n--) 
  586. X   if ((dt->dd + 1) > MonthLengths[LEAP(dt->yy)][dt->mm]) 
  587. X     if (dt->mm == DEC) {
  588. X       dt->yy++;
  589. X       dt->mm = JAN;
  590. X       dt->dd = 1;
  591. X     }
  592. X     else {
  593. X       dt->mm++;
  594. X       dt->dd =1;
  595. X     }
  596. X   else 
  597. X     dt->dd ++;
  598. X}
  599. X
  600. Xint dayOfWeek(d1)  /* sunday = 0 */
  601. Xdate_t d1;
  602. X{
  603. X  return (int) ((daysSinceOrigin(d1) + 1) % 7 ) ;
  604. X}
  605. X
  606. Xvoid setDate (d) 
  607. Xdate_t *d;
  608. X{
  609. X  time_t secs;
  610. X  struct tm *loctm;
  611. X
  612. X  secs = time(NULL);
  613. X  loctm = localtime(&secs);
  614. X  d->yy = 1900 + loctm->tm_year;
  615. X  d->mm = loctm->tm_mon;
  616. X  d->dd = loctm->tm_mday;
  617. X}
  618. X
  619. X
  620. END_OF_FILE
  621.   if test 2697 -ne `wc -c <'greg.c'`; then
  622.     echo shar: \"'greg.c'\" unpacked with wrong size!
  623.   fi
  624.   # end of 'greg.c'
  625. fi
  626. if test -f 'greg.h' -a "${1}" != "-c" ; then 
  627.   echo shar: Will not clobber existing file \"'greg.h'\"
  628. else
  629.   echo shar: Extracting \"'greg.h'\" \(875 characters\)
  630.   sed "s/^X//" >'greg.h' <<'END_OF_FILE'
  631. X#ifndef __GREG__
  632. X#define __GREG__
  633. X
  634. X#include <stdio.h>
  635. X#include <sys/types.h>
  636. X#include <time.h>
  637. X#include "error.h"
  638. X
  639. X#define LEAP(x) (!((x) % 4) && ( ((x) % 100) || !((x) % 400)))
  640. X#define DAYS_IN(x) (LEAP((x))?366:365)
  641. X
  642. X#define JAN 0
  643. X#define FEB 1
  644. X#define MAR 2
  645. X#define APR 3
  646. X#define MAY 4
  647. X#define JUN 5
  648. X#define JUL 6
  649. X#define AUG 7
  650. X#define SEP 8
  651. X#define OCT 9
  652. X#define NOV 10
  653. X#define DEC 11
  654. X
  655. X#define SUN 0
  656. X#define MON 1
  657. X#define TUE 2
  658. X#define WED 3
  659. X#define THU 4
  660. X#define FRI 5
  661. X#define SAT 6
  662. X
  663. Xextern char * eMonths[];
  664. Xextern int MonthLengths[][12] ;
  665. Xextern char * DayNames[] ;
  666. Xextern char * ShortDayNames[];
  667. Xextern char * eDays[] ;
  668. X
  669. Xtypedef struct {
  670. X  int mm;    /* months since january 0,11*/
  671. X  int dd;    /* day of month 1,31 */
  672. X  int yy;    /* years since year 1 BCE i.e. -1 = 2 BCE */
  673. X  } date_t;
  674. X
  675. Xint diffDays(), exceeds(), dayOfWeek();
  676. Xvoid decDate (), incDate(), setDate();
  677. X
  678. X#endif
  679. END_OF_FILE
  680.   if test 875 -ne `wc -c <'greg.h'`; then
  681.     echo shar: \"'greg.h'\" unpacked with wrong size!
  682.   fi
  683.   # end of 'greg.h'
  684. fi
  685. if test -f 'hebcal.1' -a "${1}" != "-c" ; then 
  686.   echo shar: Will not clobber existing file \"'hebcal.1'\"
  687. else
  688.   echo shar: Extracting \"'hebcal.1'\" \(4582 characters\)
  689.   sed "s/^X//" >'hebcal.1' <<'END_OF_FILE'
  690. X.TH HEBCAL 1 "Hebcal Version 2.0" "Danny Sadinoff"
  691. X.SH NAME
  692. Xhebcal - a Jewish calendar generator
  693. X.SH SYNOPSIS
  694. X.B hebcal
  695. X[ 
  696. X\-dehosStTw
  697. X] [ 
  698. X\-i
  699. X.I file
  700. X] [[
  701. X.I month
  702. X[
  703. X.I day
  704. X]]
  705. X.I year
  706. X]
  707. X.br
  708. X.B hebcal help
  709. X.SH DESCRIPTION
  710. XWith no arguments, 
  711. X.B hebcal
  712. Xwill print to stdout the 
  713. Xdates of the Jewish holidays in the current
  714. Xsecular year.  Each line is prefixed with a gregorian date of the form
  715. Xmm/dd/yy.  
  716. X.sp
  717. XBy specifying 
  718. X.I month,
  719. X.I day,
  720. Xor 
  721. X.I year 
  722. Xoutput can be limited to a particular month or date
  723. Xin a particular year.  
  724. X.sp
  725. X.I year
  726. Xis an integer (it can be negative).  So 92 is in the early Christian
  727. Xera, not the late twentieth century.
  728. X.sp
  729. X.I month
  730. Xis a number from 1..12.
  731. X.sp
  732. X.I day 
  733. Xis a number from 1..31.
  734. X.sp
  735. XFor example, the command
  736. X.nf
  737. X
  738. X    hebcal 10 1992
  739. X
  740. X.fi
  741. Xwill print out the holidays occurring in October of 1992.
  742. X.PP
  743. XA few other bells and whistles include the weekly 
  744. X.I sedra
  745. Xas well as the day of the week, the count of the 
  746. X.I omer,
  747. Xand the Hebrew date.
  748. X.PP
  749. XOutput from hebcal can be used to drive calendar(1).  
  750. XDay\-to\-day use for hebcal is provided for in the 
  751. X.B -T
  752. X and 
  753. X.B -t
  754. Xswitches, which print out Jewish calendar entries for the current date.
  755. X.PP
  756. X.SH OPTIONS
  757. X.TP 1.0i
  758. X.B "  -d"
  759. XAdd the Hebrew date to the output.
  760. X.TP
  761. X.B "  -e"
  762. XChange the output format to European\-style dates: dd.mm.yyyy
  763. X.TP
  764. X.B "  -h"
  765. XSuppress holidays in output.  User defined calendar events are
  766. Xunaffected by this switch.
  767. X.TP
  768. X.B "  -i "
  769. XRead extra events from specified file.  These events are printed
  770. Xregardless of the 
  771. X.B -h 
  772. Xsuppress holidays switch.
  773. X.br
  774. XThere is one holiday per line in 
  775. X.I file,
  776. Xeach with the format
  777. X.br
  778. X.I month day description
  779. X.br
  780. Xwhere 
  781. X.I month 
  782. Xis a number from 1 to 12,
  783. X.I day
  784. Xis a number from 1 to 30, and 
  785. X.I description
  786. Xis a newline-terminated string describing the holiday.
  787. X.br
  788. XHere is the list of Hebrew months and their code numbers:
  789. X.br
  790. X1    Tishrei
  791. X.br
  792. X2    Cheshvan
  793. X.br
  794. X3    Kislev
  795. X.br
  796. X4    Tevet
  797. X.br
  798. X5    Shvat
  799. X.br
  800. X6    Adar (Adar II on leap years)
  801. X.br
  802. X6a    Adar (Adar I on leap years)
  803. X.br
  804. X6b    same as 6
  805. X.br
  806. X7    Nisan
  807. X.br
  808. X8    Iyyar
  809. X.br
  810. X9    Sivan
  811. X.br
  812. X10    Tamuz
  813. X.br
  814. X11    Av
  815. X.br
  816. X12    Elul
  817. X.br 
  818. XPlease note the special option associated with Adar.  If a birthday
  819. Xoccurs in Adar of a non-leap year, It ought to get the 6a month
  820. Xcode.  Only people born on leap years in Adar II should have their
  821. Xbirthdays on 6b. 
  822. X.br
  823. X.br
  824. XA similar but opposite rule applies to 
  825. X.I  yahrtzeits.
  826. XIf a person died in Adar of a non-leap year, the
  827. X.I yahrtzeit
  828. Xlands in Adar II of a leap year, so the event gets the 6b (or 6) month
  829. Xcode.  Only people who died on leap years in Adar II should have their
  830. X.I yahrtzeits
  831. Xon 6a.
  832. X.TP
  833. X.B "  -o"
  834. XAdd the count of the 
  835. X.I omer
  836. Xto the output.
  837. X.TP
  838. X.B "  -s"
  839. XAdd the weekly 
  840. X.I sedra 
  841. Xto the output on Saturdays.
  842. X.TP
  843. X.B "  -S"
  844. XAdd the weekly 
  845. X.I sedra 
  846. Xto the output every day.
  847. X.TP
  848. X.B "  -t"
  849. XPrint calendar information for today's date only.  -d is
  850. Xasserted with this option. 
  851. X.TP
  852. X.B "  -T"
  853. XSame as -t, only without the gregorian date.  This option is useful in
  854. Xlogin scripts, just to see what's happening today in the Jewish calendar.
  855. X.TP
  856. X.B "  -w"
  857. XAdd the day of the week to the output.
  858. X.SH EXAMPLES
  859. X.LP
  860. XTo find the days of the 
  861. X.I omer 
  862. Xin 1997, printing the days of the week:
  863. X.RS
  864. X.nf
  865. X.ft B
  866. Xexample% hebcal -how 1997
  867. X.br
  868. X4/23/97 Wed, 1st day of the Omer
  869. X.br
  870. X4/24/97 Thu, 2nd day of the Omer
  871. X.br
  872. X4/25/97 Fri, 3rd day of the Omer
  873. X.br
  874. X .
  875. X.br
  876. X .
  877. X.br
  878. X .
  879. X.br
  880. X6/9/97 Mon, 48th day of the Omer
  881. X.br
  882. X6/10/97 Tue, 49th day of the Omer
  883. X.RE
  884. X.LP
  885. XTo just print the weekly 
  886. X.I sedrot
  887. Xof December 2000
  888. X.RS
  889. X.nf
  890. X.ft B
  891. Xexample% hebcal -hp 12 2000
  892. X.br
  893. X12/2/00 Parshat Toldot
  894. X.br
  895. X12/9/00 Parshat Vayetzei
  896. X.br
  897. X12/16/00 Parshat Vayishlach
  898. X.br
  899. X12/23/00 Parshat Vayeshev
  900. X.br
  901. X12/30/00 Parshat Miketz
  902. X.br
  903. X.RE
  904. X.LP 
  905. XTo find out what's happening in the Jewish calendar today , use
  906. X.RS
  907. X.nf
  908. X.ft B
  909. Xexample% hebcal -ToS
  910. X.br
  911. X19 of Nisan, 5752
  912. X.br
  913. XParshat Achrei Mot
  914. X.br
  915. XPesach V (CH"M)
  916. X.br
  917. X4th day of the Omer
  918. X.br
  919. X.RE
  920. X.SH AUTHOR
  921. XDanny Sadinoff, University of Pennsylvania
  922. X.SH SEE ALSO
  923. Xcalendar(1), hcal(1), hdate(1), omer(1), rise(1)
  924. X.sp
  925. XThe motivation for the algorithms in this program is the
  926. X.I "Tur Shulchan Aruch.  "
  927. XA well written treatment of the Jewish calendar is given in 
  928. X.I Understanding the Jewish Calendar
  929. Xby Rabbi Nathan Bushwick.  A more complete bibliography on the topic
  930. Xcan be found there.
  931. X.SH BUGS
  932. XHebcal performs no checking for changes between the julian and
  933. Xgregorian calendar, so secular dates before 1752 are untrustworthy.
  934. X.sp 
  935. XHebcal cannot currently handle date computations before 2 C.E.  sorry.
  936. X.SH BUG REPORTS TO
  937. XDanny Sadinoff    sadinoff@eniac.seas.upenn.edu
  938. END_OF_FILE
  939.   if test 4582 -ne `wc -c <'hebcal.1'`; then
  940.     echo shar: \"'hebcal.1'\" unpacked with wrong size!
  941.   fi
  942.   # end of 'hebcal.1'
  943. fi
  944. if test -f 'hebcal.c' -a "${1}" != "-c" ; then 
  945.   echo shar: Will not clobber existing file \"'hebcal.c'\"
  946. else
  947.   echo shar: Extracting \"'hebcal.c'\" \(20368 characters\)
  948.   sed "s/^X//" >'hebcal.c' <<'END_OF_FILE'
  949. X#include "hebcal.h"
  950. X#include "danlib.h"
  951. X#include <string.h>
  952. X  
  953. X  
  954. X  /* hebcal.c main module for hebrew calendar program
  955. X     By Danny Sadinoff
  956. X     (C) 1992
  957. X     
  958. X     $Date: 93/02/12 16:22:16 $
  959. X     $Revision: 2.0 $
  960. X     
  961. X  */ 
  962. X  
  963. X  
  964. X  int sedrot_sw, hebDates_sw, euroDates_sw, specMonth_sw,specDay_sw,
  965. X  inputFile_sw, weekday_sw, suppressHolidays_sw, suppressGreg_sw, 
  966. X  printOmer_sw, sedraAllWeek_sw, omer;
  967. X
  968. XFILE *inFile;
  969. X
  970. Xholstorep_t holidays[13][MAXDAYS],union_Adar[MAXDAYS];
  971. X
  972. Xyear_t legend[2][8] = {
  973. X  {                /* stam years */
  974. X    {"1BX",353,29,29,1,1,1,1,0,1,1},    /* BX */
  975. X    {"1BS",355,30,30,1,1,1,1,1,1,1},    /* BS */
  976. X    {"2GC",354,29,30,1,1,1,1,1,1,1},    /* GC */
  977. X    {"4HC",354,29,30,1,1,1,1,0,1,0},    /* HC */ 
  978. X    {"0error - HX",354,29,29,1,1,1,1,0,1,0},    /* error! hx */
  979. X    {"4HS",355,30,30,0,1,1,1,0,1,0},    /* HS */
  980. X    {"6ZX",353,29,29,1,1,1,1,0,1,0},    /* ZX */
  981. X    {"6ZS",355,30,30,1,1,1,1,0,1,1},    /* ZS */
  982. X  },
  983. X  {                /* leap years */
  984. X    {"1BX",383,29,29,0,0,0,0,1,1,1},    /* BX */
  985. X    {"1BS",385,30,30,0,0,0,0,0,1,0},    /* BS */
  986. X    {"2GC",384,29,30,0,0,0,0,0,1,0},    /* GC */
  987. X    {"0error - HC",383,29,30,0,0,0,0,0,0,0},    /* error ! hc */
  988. X    {"4HX",383,29,29,0,0,0,0,0,0,0},    /* HX */
  989. X    {"4HS",385,30,30,0,0,0,0,0,0,1},    /* HS */
  990. X    {"6ZX",383,29,29,0,0,0,0,0,1,1},    /* ZX */
  991. X    {"6ZS",385,30,30,0,0,0,0,1,1,1},    /* ZS */
  992. X  }
  993. X};
  994. X
  995. Xint leapYears[] = {0,0,1,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,1};
  996. X/*enum {BX,BS,GC,HC,HX,HS,ZX,ZS}; */
  997. X#define BX 0
  998. X#define BS 1
  999. X#define GC 2
  1000. X#define HC 3
  1001. X#define HX 4
  1002. X#define HS 5
  1003. X#define ZX 6
  1004. X#define ZS 7
  1005. X
  1006. Xint luach[][19] = 
  1007. X{
  1008. X  {HC,BX,HS,HC,BS,ZX,HC,BS,BX,HS,GC,BS,ZX,GC,BS,ZS,HX,GC,ZS},
  1009. X  {ZS,HC,BX,ZS,HC,BX,ZS,HS,HC,BX,HS,HC,BS,ZX,HC,BS,ZX,HS,GC},
  1010. X  {BS,ZX,GC,BS,ZS,HX,GC,ZS,ZS,HC,BX,ZS,HC,BS,BX,HC,BS,BS,ZX},
  1011. X  {HC,HS,ZX,HC,HS,ZS,ZX,GC,BS,ZS,HX,GC,ZS,HS,HC,BX,HS,HC,BX},
  1012. X  {ZS,HC,BS,BX,HC,BS,BS,ZX,HC,BS,ZX,HS,GC,ZS,ZS,HC,BX,ZS,HX},
  1013. X  {GC,ZS,HS,HC,BX,HS,HC,BX,ZS,HC,BS,BX,HS,GC,BS,ZX,GC,BS,ZS},
  1014. X  {ZX,GC,ZS,ZS,HC,BX,ZS,HX,GC,ZS,HS,HC,BX,HS,HC,BS,ZX,HC,BS},
  1015. X  {BS,ZX,GC,BS,ZS,HX,GC,ZS,ZX,GC,ZS,ZS,HC,BX,ZS,HC,BS,BX,HS},
  1016. X  {HC,BS,ZX,HC,BS,ZX,HS,GC,BS,ZX,GC,BS,ZS,HX,GC,ZS,HS,HC,BX},
  1017. X  {ZS,HC,BX,ZS,HC,BS,BX,HS,HC,BS,ZX,HC,BS,ZX,HS,GC,ZS,ZX,GC},
  1018. X  {BS,ZS,HX,GC,ZS,HS,HC,BX,ZS,HC,BX,ZS,HC,BS,BX,HS,GC,BS,ZX}, /* 10,11 GX? */
  1019. X  {HC,BS,ZS,ZX,GC,ZS,ZS,HX,GC,ZS,HX,GC,ZS,HS,HC,BX,HS,HC,BS},
  1020. X  {BX,HC,BS,BS,ZX,GC,BS,ZX,HS,GC,ZS,ZS,HC,BX,ZS,HC,BX,ZS,HS}
  1021. X};
  1022. X
  1023. Xstruct {
  1024. X  char * name;
  1025. X  int length;
  1026. X}hMonths[][14] = {
  1027. X  {  
  1028. X    {"Tishrei",30}, {"Cheshvan",29}, {"Kislev",30},
  1029. X    {"Tevet",29}, {"Shvat",30}, {"Adar",29},
  1030. X    {"Nisan",30}, {"Iyyar",29}, {"Sivan",30},
  1031. X    {"Tamuz",29}, {"Av",30},{"Elul",29},{"Tishrei",30}},
  1032. X  {
  1033. X    {"Tishrei",30}, {"Cheshvan",29}, {"Kislev",30},
  1034. X    {"Tevet",29}, {"Shvat",30}, {"Adar I",29}, {"Adar II",30},
  1035. X    {"Nisan",30}, {"Iyyar",29}, {"Sivan",30},
  1036. X    {"Tamuz",29}, {"Av",30},{"Elul",29},{"Tishrei",30}}    
  1037. X};
  1038. X
  1039. X#define TISHREI 0
  1040. X#define CHESHVAN 1
  1041. X#define KISLEV 2
  1042. X#define ADAR_2 6
  1043. X
  1044. Xchar * sedrot[] = { 
  1045. X  "Bereshit", "Noach", "Lech Lecha", "Vayera", "Chayei Sara",
  1046. X  "Toldot", "Vayetzei", "Vayishlach", "Vayeshev", "Miketz", "Vayigash",
  1047. X  "Vayechi",
  1048. X  
  1049. X  "Sh'mot", "Vaera", "Bo", "Beshalach", "Yitro", "Mishpatim",
  1050. X  "Terumah", "Tetzaveh", "Ki Tisa", "Vayakhel", "Pekudei",
  1051. X  
  1052. X  "Vayikra", "Tzav", "Shmini", "Tazria", "Metzora", "Achrei Mot",
  1053. X  "Kedoshim", "Emor", "Behar", "Bechukosai",
  1054. X  
  1055. X  "Bamidbar", "Nasso", "Beha'aloscha", "Sh'lach", "Korach", "Chukat",
  1056. X  "Balak", "Pinchas", "Matot", "Masei",
  1057. X  
  1058. X  "Devarim", "Vaetchanan", "Eikev", "Re'eh", "Shoftim", 
  1059. X  "Ki Teitzei", "Ki Tavo", "Nitzavim", "Vayeilech", "Ha'Azinu", 
  1060. X  "V'Zot Habracha"
  1061. X  };
  1062. X
  1063. X#define VAYAKHEL 21
  1064. X#define TAZRIA 26
  1065. X#define ACHREI 28
  1066. X#define BEHAR 31
  1067. X#define CHUKAT 38
  1068. X#define MATOT 41
  1069. X#define NITZAVIM 50
  1070. X
  1071. X#define NM_LEN 30
  1072. X
  1073. X#define OWNSEDRA 1
  1074. X#define NIDCHE 2
  1075. X#define MUKDAM 4
  1076. X#define MUKDAM2 8
  1077. X#define SKIP_NORMAL_ADAR 16
  1078. X#define USER_EVENT 32
  1079. X
  1080. Xholinput_t inp_holidays[] = {    /* 5 = Adar I */
  1081. X  /* 6 = Adar = Adar II */
  1082. X  {{0,1},"Rosh Hashana I",OWNSEDRA},{{0,2},"Rosh Hashana II",OWNSEDRA},
  1083. X  {{0,3},"Tzom Gedalia",NIDCHE},
  1084. X  {{0,9},"Erev Yom Kippur"},
  1085. X  {{0,10},"Yom Kippur",OWNSEDRA},
  1086. X  
  1087. X  {{0,15},"Sukkot I",OWNSEDRA},{{0,16},"Sukkot II",OWNSEDRA},
  1088. X  {{0,17},"Sukkot III (CH\"M)",OWNSEDRA},{{0,18},"Sukkot IV (CH\"M)",OWNSEDRA},
  1089. X  {{0,19},"Sukkot V (CH\"M)",OWNSEDRA},{{0,20},"Sukkot VI (CH\"M)",OWNSEDRA},
  1090. X  {{0,21},"Sukkot VII (Hoshana Raba)",OWNSEDRA},
  1091. X  {{0,22},"Shmini Atzeret",OWNSEDRA},{{0,23},"Simchat Torah",OWNSEDRA},
  1092. X  
  1093. X  {{2,25},"Chanukah I"},
  1094. X  {{2,26},"Chanukah II"},{{2,27},"Chanukah III"},{{2,28},"Chanukah IV"},
  1095. X  {{3,10},"Asara B'Tevet",NIDCHE},
  1096. X  
  1097. X  {{4,15},"Tu B'Shvat"}  /*NIDCHE?*/,
  1098. X  
  1099. X  {{5,15},"Purim katan",SKIP_NORMAL_ADAR},
  1100. X  {{6,13},"Ta'anit Esther",MUKDAM},{{6,14},"Purim"},
  1101. X  {{6,15},"Shushan Purim"}, 
  1102. X  
  1103. X  {{7,14},"Erev Pesach - Taanit B'chorot",0},
  1104. X#define PESACH2_STR "Pesach II"
  1105. X  {{7,15},"Pesach I",OWNSEDRA},{{7,16},PESACH2_STR,OWNSEDRA},
  1106. X  {{7,17},"Pesach III (CH\"M)",OWNSEDRA},{{7,18},"Pesach IV (CH\"M)",OWNSEDRA},
  1107. X  {{7,19},"Pesach V (CH\"M)",OWNSEDRA},{{7,20},"Pesach VI (CH\"M)",OWNSEDRA},
  1108. X  {{7,21},"Pesach VII",OWNSEDRA},
  1109. X  {{7,22},"Pesach VIII",OWNSEDRA},
  1110. X  
  1111. X  {{7,27},"Yom HaShoah"},
  1112. X  {{8,4},"Yom HaZikaron",MUKDAM2},
  1113. X  {{8,5},"Yom Ha'atzmaut",MUKDAM},
  1114. X  {{8,28},"Yom Yerushalayim",MUKDAM},  /* not certain about mukdam status  of the yoms */
  1115. X#define SHAVUOT_STR "Shavuot I"
  1116. X  {{9,6},SHAVUOT_STR,OWNSEDRA},{{9,7},"Shavuot II",OWNSEDRA},
  1117. X  {{10,17},"Shiva Assar B'Tamuz",NIDCHE},
  1118. X  {{11,9},"Tish'a B'Av",NIDCHE},
  1119. X  {{12,29},"Erev Rosh Hashana"}
  1120. X};
  1121. X
  1122. Xholstore_t chanukah_arr[5] =
  1123. X{
  1124. X  {""},
  1125. X  {"Chanukah V"},
  1126. X  {"Chanukah VI"}, 
  1127. X  {"Chanukah VII"},
  1128. X  {"Chanukah VIII"}
  1129. X};
  1130. X
  1131. X#define SIMCHAT_DAY 23
  1132. X
  1133. X/* = {
  1134. X   {{0,0},"Shabbat Shekalim"},
  1135. X   {{0,0},"Shabbat Zachor"},
  1136. X   {{0,0},"Parshat HaChodesh"},
  1137. X   {{0,0},"Parshat Parah"},
  1138. X   
  1139. X   };*/
  1140. X
  1141. X
  1142. X#define LEAP_YR_HEB(x) (leapYears[((x) -1) % 19])
  1143. X#define MONTHS_IN_HEB(x) (LEAP_YR_HEB(x) ? 13 :12)
  1144. X
  1145. Xyear_t yearData(yr)
  1146. X     int yr;
  1147. X{
  1148. X  return legend[LEAP_YR_HEB(yr)][luach[((yr-1)/19+7)%13][(yr-1) %19]];
  1149. X}
  1150. X
  1151. Xint daysInHebMonth(month, year) 
  1152. X     int month, year;
  1153. X{
  1154. X  year_t theYear;
  1155. X  
  1156. X  theYear = yearData(year);
  1157. X  if (month == CHESHVAN) 
  1158. X    return theYear.daysInCheshvan;
  1159. X  else if (month == KISLEV)
  1160. X    return theYear.daysInKislev;
  1161. X  else return hMonths[LEAP_YR_HEB(year)][month].length;
  1162. X}
  1163. X
  1164. Xdate_t nextHebDate (dth) 
  1165. X     date_t dth;
  1166. X{
  1167. X  dth.dd++;
  1168. X  if (dth.dd > daysInHebMonth(dth.mm,dth.yy))
  1169. X    if (dth.mm ==  MONTHS_IN_HEB(dth.yy)-1)
  1170. X      {
  1171. X    dth.yy++;
  1172. X    dth.mm =0;
  1173. X    dth.dd =1;
  1174. X      }
  1175. X    else 
  1176. X      {
  1177. X    dth.mm++;
  1178. X    dth.dd =1;
  1179. X      }
  1180. X  return dth;
  1181. X}
  1182. X
  1183. Xdate_t prevHebDate (dth) 
  1184. X     date_t dth;
  1185. X{
  1186. X  dth.dd--;
  1187. X  if (dth.dd == 0)
  1188. X    if (dth.mm == 0)
  1189. X      {
  1190. X    dth.yy--;
  1191. X    dth.mm = MONTHS_IN_HEB(dth.yy) -1 ;
  1192. X    dth.dd = daysInHebMonth(dth.mm,dth.yy);
  1193. X      }
  1194. X    else 
  1195. X      {
  1196. X    dth.mm--;
  1197. X    dth.dd = daysInHebMonth(dth.mm,dth.yy);
  1198. X      }
  1199. X  return dth;
  1200. X}
  1201. X
  1202. Xholstorep_t getHolstorep (s)    /* return a pointer to a new */
  1203. Xchar *s;            /* holiday */
  1204. X{
  1205. X  holstorep_t tmp;
  1206. X  if (!(tmp = (holstorep_t)malloc ( (size_t) sizeof (holstore_t))))
  1207. X    die("Unable to allocate memory for holiday. Called from %s",s);
  1208. X  tmp->next = NULL;
  1209. X  tmp->name = NULL;
  1210. X  tmp->typeMask = 0;
  1211. X  return tmp;
  1212. X}
  1213. X
  1214. Xint PushHoliday (hp,lp)    /*pushes a copy of a holiday on to a holiday list */
  1215. X     holstorep_t 
  1216. X       hp,            /* the holiday to be added */
  1217. X       *lp;            /* pointer to the list to be added to.*/
  1218. X{
  1219. X  holstorep_t temp;
  1220. X
  1221. X  temp = getHolstorep("PushHoliday");
  1222. X  initStr(&temp->name,MAX_LINE_LEN);
  1223. X  strcpy(temp->name,hp->name);
  1224. X  temp->typeMask = hp->typeMask;
  1225. X
  1226. X  if (!*lp)
  1227. X    /* if there are no holidays here yet, start a new bucket*/
  1228. X    *lp = temp; 
  1229. X  else 
  1230. X    {
  1231. X      temp->next = *lp;        /* put hp at the head of the list */
  1232. X      *lp = temp;
  1233. X    }
  1234. X  return temp->typeMask;
  1235. X}
  1236. X
  1237. X
  1238. Xvoid InitHolidays(roshDt)    /* set up the stored holidays array */
  1239. X     date_t roshDt;
  1240. X{
  1241. X
  1242. X  int d,m;
  1243. X  holstorep_t tmpholp;
  1244. X  holinputp_t todayinp;
  1245. X
  1246. X  for (m = 0; m<= 12; m++)    /* clear holidays buckets */
  1247. X    for (d = 0; d < MAXDAYS; d++)
  1248. X      holidays[m][d] = NULL;
  1249. X  
  1250. X  for (m = 0,todayinp = inp_holidays; /* load holiday buckets */
  1251. X       m < LAST_INDEX(inp_holidays); 
  1252. X       m++, todayinp++)
  1253. X    {
  1254. X      tmpholp = getHolstorep("InitHolidays");      /* allocate hsnode*/
  1255. X      tmpholp->typeMask = todayinp->typeMask;      /* load the new holiday into it. */
  1256. X      tmpholp->name = todayinp->name;
  1257. X      PushHoliday(tmpholp,&holidays[todayinp->date.mm][todayinp->date.dd]);
  1258. X      if ((todayinp->date.mm == 5 || todayinp->date.mm == 6) && 
  1259. X      !(tmpholp->typeMask & SKIP_NORMAL_ADAR))
  1260. X    PushHoliday(tmpholp,&union_Adar[todayinp->date.dd]);
  1261. X    }
  1262. X  
  1263. X  if (inputFile_sw)        /* get user-defined "holidays" */
  1264. X    {
  1265. X      char *s,*monthStr,*adarp,*eventStr,nextChar;
  1266. X      int index,hYear,inMonth,inDay,lineNum = 1;
  1267. X
  1268. X
  1269. X      hYear = JUL2HEB(roshDt.yy)+1;
  1270. X      initStr(&s,MAX_LINE_LEN);
  1271. X      initStr(&monthStr,MAX_LINE_LEN);
  1272. X      nextChar = (char) getc(inFile); /* priming getc */
  1273. X      while (!feof(inFile))
  1274. X    {
  1275. X      ungetc(nextChar,inFile); 
  1276. X      if (!fgets(s,MAX_LINE_LEN,inFile))
  1277. X        die ("input file read error at line number %s.\n",itoa(lineNum));
  1278. X
  1279. X      if (!sscanf(s,"%s %d%n",monthStr,&inDay,&index))
  1280. X        die ("Error in input file at line %s\n",itoa(lineNum));
  1281. X
  1282. X      if (isAllNums(monthStr) && (inMonth = atoi(monthStr)) < 6)
  1283. X        inMonth--;
  1284. X      else if (adarp = strchr(monthStr,'a'))
  1285. X        {
  1286. X          *adarp = '\0';    /* terminate the string at the 'a' */
  1287. X          if (isAllNums(monthStr))
  1288. X        inMonth = atoi(monthStr)-1;
  1289. X          else die ("Error in input file at line %s\n",itoa(lineNum));
  1290. X        }
  1291. X      else if (adarp = strchr(monthStr,'b'))
  1292. X        {      /* this case puts the event in month 6 = Adar II*/
  1293. X          *adarp = '\0';    
  1294. X          if (isAllNums(monthStr))
  1295. X        inMonth = atoi(monthStr); /* note no decrement */
  1296. X          else die ("Error in input file at line %s\n",itoa(lineNum));
  1297. X        }
  1298. X
  1299. X      if (inMonth >12 || inMonth <0)
  1300. X        die ("Month out of range in input file at line %s\n",itoa(lineNum));
  1301. X      
  1302. X      if(inDay <0 || inDay >30)
  1303. X        die ("Date out of range in input file at line %s\n",itoa(lineNum));
  1304. X
  1305. X#if 0
  1306. X      if ((inMonth == 5) && !LEAP_YR_HEB(hYear))
  1307. X        warn("Warning:user event scheduled on Adar I in nonleap year. line %s\n",
  1308. X         itoa(lineNum));
  1309. X#endif     
  1310. X      if (inDay > daysInHebMonth(inMonth,hYear))
  1311. X        warn("Warning:user event scheduled on date not appearing this year. line %s\n",
  1312. X         itoa(lineNum));
  1313. X
  1314. X      eventStr = s +index +1; /* get the name of the event */
  1315. X      eventStr[strlen(eventStr)-1] = '\0'; /* chop off the \n */
  1316. X    
  1317. X            /* store the holiday in the LUT */
  1318. X      tmpholp = getHolstorep("InitHolidays:inputFile");
  1319. X      initStr(&tmpholp->name,MAX_LINE_LEN);
  1320. X      strcpy(tmpholp->name,eventStr); /* load the user holiday into it. */
  1321. X      tmpholp->typeMask = USER_EVENT;
  1322. X      PushHoliday(tmpholp,&holidays[inMonth][inDay]);
  1323. X      if (inMonth == 5 || inMonth == 6) 
  1324. X          PushHoliday(tmpholp,&union_Adar[inDay]);
  1325. X
  1326. X      lineNum++;
  1327. X      nextChar = (char) getc(inFile); /* force an EOF */
  1328. X    }
  1329. X    }
  1330. X}      
  1331. X
  1332. X
  1333. X
  1334. Xvoid getHebHolidays (dth,weekday, holiList) 
  1335. X     /* returns a linked list of holidays for that date*/ 
  1336. X     date_t dth;    
  1337. X     int weekday;        
  1338. X     holstorep_t *holiList;    /* the typeMask on the first element of */
  1339. X                /* the returned list must reflect */
  1340. X                /* the union of all component masks */
  1341. X{
  1342. X  char * funName = "getHebHolidays";
  1343. X  int tmpMask;
  1344. X  holstorep_t tmpholip, chp;
  1345. X  static holstorep_t todayp, yesterp, morrowp, morrow2p;
  1346. X  static int chanukah_day,first;
  1347. X
  1348. X#define CORRECTION(yy,mm) (LEAP_YR_HEB(yy) ? 0 : (((mm) > 4) ? 1: 0))
  1349. X
  1350. X  if (first) 
  1351. X    {
  1352. X      todayp  = holidays[dth.mm][dth.dd];
  1353. X      yesterp = holidays[prevHebDate(dth).mm][prevHebDate(dth).dd];
  1354. X      morrowp = holidays[nextHebDate(dth).mm][nextHebDate(dth).dd];
  1355. X      morrow2p = holidays[nextHebDate(nextHebDate(dth)).mm]
  1356. X                    [nextHebDate(nextHebDate(dth)).dd];
  1357. X      first = 0;
  1358. X    }
  1359. X  else 
  1360. X    {
  1361. X      date_t morrow2dt;
  1362. X      
  1363. X      morrow2dt = nextHebDate(nextHebDate(dth));
  1364. X      yesterp = todayp;
  1365. X      todayp = morrowp;
  1366. X      morrowp = morrow2p;
  1367. X      if (!LEAP_YR_HEB(dth.yy) && morrow2dt.mm == 5)
  1368. X    morrow2p = union_Adar[morrow2dt.dd];
  1369. X      else
  1370. X    morrow2p = holidays[morrow2dt.mm +CORRECTION(dth.yy,morrow2dt.mm)]
  1371. X                           [morrow2dt.dd];
  1372. X    }
  1373. X  
  1374. X  tmpMask =0;
  1375. X  *holiList = NULL;
  1376. X  
  1377. X  for (chp = todayp; chp; chp = chp->next)
  1378. X    {
  1379. X      /* for normal holidays */
  1380. X      if (!(weekday == SAT && chp->typeMask & NIDCHE) &&
  1381. X      !(chp->typeMask & MUKDAM &&
  1382. X        (weekday == FRI || weekday == SAT)) &&
  1383. X      !(chp->typeMask & MUKDAM2 &&
  1384. X        (weekday == THU || weekday == FRI)))
  1385. X    {            /* do normal holidays*/
  1386. X      tmpMask |= PushHoliday(chp,holiList);
  1387. X      if (!strcmp(chp->name,PESACH2_STR)) omer++;
  1388. X      if (omer && !strcmp(chp->name,SHAVUOT_STR)) omer=0;
  1389. X    }
  1390. X    }
  1391. X  
  1392. X  if (weekday == SUN && yesterp)      /* fast days which are nidche */
  1393. X    for (chp = yesterp; chp; chp = chp->next)
  1394. X      if (chp->typeMask & NIDCHE)
  1395. X    {
  1396. X      char *st;
  1397. X      
  1398. X      initStr(&st,NM_LEN);
  1399. X      strncat(st,chp->name,NM_LEN);
  1400. X      strncat(st," [nidche]",NM_LEN);
  1401. X      tmpMask |= PushHoliday(chp,holiList); 
  1402. X      (*holiList)->name = st;
  1403. X    }
  1404. X
  1405. X      /* if the date actually falls */
  1406. X      /* on friday or shabbat*/
  1407. X  if (weekday == THU)
  1408. X    {
  1409. X      for (chp = morrowp; chp; chp = chp->next)
  1410. X    if (chp->typeMask & MUKDAM)
  1411. X      tmpMask |= PushHoliday(chp,holiList);
  1412. X      for (chp = morrow2p; chp; chp = chp->next)
  1413. X    if (chp->typeMask & MUKDAM)
  1414. X      tmpMask |= PushHoliday(chp,holiList);
  1415. X    }
  1416. X      
  1417. X      /* if the date actually falls */
  1418. X      /* on thursday or friday*/
  1419. X  if (weekday == WED)
  1420. X    {
  1421. X      for (chp = morrowp; chp; chp = chp->next)
  1422. X    if (chp->typeMask & MUKDAM2)
  1423. X      tmpMask |= PushHoliday(chp,holiList);
  1424. X      for (chp = morrow2p; chp; chp = chp->next)
  1425. X    if (chp->typeMask & MUKDAM2)
  1426. X      tmpMask |= PushHoliday(chp,holiList);
  1427. X    }
  1428. X
  1429. X  /* Lag B'Omer Processing */
  1430. X  if (omer == 33) {
  1431. X    tmpholip = getHolstorep(funName);
  1432. X    initStr(&tmpholip->name,NM_LEN); 
  1433. X    strncpy(tmpholip->name,"Lag B'Omer",NM_LEN);
  1434. X    tmpMask |= PushHoliday(tmpholip,holiList);
  1435. X  }
  1436. X  
  1437. X  if (dth.dd == 29 && dth.mm == 2) 
  1438. X    chanukah_day = 1;
  1439. X  
  1440. X  if (chanukah_day) {
  1441. X    tmpMask |= PushHoliday(&chanukah_arr[chanukah_day],holiList);
  1442. X    if (chanukah_day == 4)
  1443. X      chanukah_day = 0;
  1444. X    else chanukah_day++;
  1445. X  }
  1446. X  
  1447. X  
  1448. X  /* rosh Chodesh Processing... */
  1449. X  if (dth.dd == 1 && dth.mm){    /* every 1st of the month except tishrei */
  1450. X    tmpholip = getHolstorep(funName);
  1451. X    initStr(&tmpholip->name,NM_LEN); 
  1452. X    strcat(tmpholip->name,"Rosh Chodesh ");
  1453. X    strncat(tmpholip->name,hMonths[LEAP_YR_HEB(dth.yy)][dth.mm].name,NM_LEN);
  1454. X    tmpMask |= PushHoliday(tmpholip,holiList);
  1455. X  }
  1456. X  if (dth.dd == 30){
  1457. X    tmpholip = getHolstorep(funName);
  1458. X    initStr(&tmpholip->name,NM_LEN);
  1459. X    strcat(tmpholip->name,"Rosh Chodesh ");
  1460. X    strncat(tmpholip->name,hMonths[LEAP_YR_HEB(dth.yy)][dth.mm+1].name,NM_LEN);
  1461. X    tmpMask |= PushHoliday(tmpholip,holiList);
  1462. X  }
  1463. X
  1464. X  if (*holiList) (*holiList)->typeMask = tmpMask;
  1465. X    
  1466. X}
  1467. X
  1468. Xvoid incHebJulDate(dth,dtj,wkday)
  1469. X     date_t *dth, *dtj;
  1470. X     int *wkday;
  1471. X{
  1472. X  /* increments both hebrew and julian calendars */
  1473. X  
  1474. X  incDate (dtj,1);
  1475. X  *wkday = dayOfWeek(*dtj);
  1476. X  *dth = nextHebDate(*dth);
  1477. X}   
  1478. X
  1479. Xvoid PrintWeekday (dt) 
  1480. X     date_t dt;
  1481. X{
  1482. X  printf ("%s, ",ShortDayNames[dayOfWeek(dt)]);
  1483. X}
  1484. X     
  1485. Xvoid PrintJulDate (dt) 
  1486. X     date_t dt;
  1487. X{
  1488. X  if (!suppressGreg_sw) 
  1489. X    if (euroDates_sw)
  1490. X      printf ("%d.%d.%d ",dt.dd,dt.mm+1,dt.yy);
  1491. X    else
  1492. X      printf ("%d/%d/%d ",dt.mm+1,dt.dd,dt.yy);
  1493. X
  1494. X  if (weekday_sw)
  1495. X    PrintWeekday(dt);
  1496. X}
  1497. X
  1498. X
  1499. Xchar *DoSedra (sedra, ydat,increment) /* returns a string "Parshat <parsha>" */
  1500. X     int *sedra,increment;    /* based on the current parsha number */
  1501. X     year_t ydat;
  1502. X{
  1503. X#define PLENGTH 40
  1504. X  static char s[PLENGTH+1];
  1505. X  
  1506. X  if (increment) increment = 1;
  1507. X  *s = '\0';
  1508. X  strncat(s,"Parshat ",PLENGTH);
  1509. X  strncat(s,sedrot[*sedra],PLENGTH);
  1510. X  switch (*sedra) {
  1511. X  case VAYAKHEL :
  1512. X    if (ydat.vayakhelPikudei){
  1513. X      strncat(s,"-",PLENGTH);
  1514. X      strncat(s,sedrot[*sedra+1],PLENGTH);
  1515. X      *sedra += 2*increment;
  1516. X    }
  1517. X    else *sedra += 1*increment;
  1518. X    break;
  1519. X  case TAZRIA:
  1520. X    if (ydat.tazriaMetzorah){
  1521. X      strncat(s,"-",PLENGTH);
  1522. X      strncat(s,sedrot[*sedra+1],PLENGTH);
  1523. X      *sedra += 2*increment;
  1524. X    }
  1525. X    else *sedra += 1*increment;
  1526. X    break;
  1527. X  case ACHREI :
  1528. X    if (ydat.achreiKedoshim){
  1529. X      strncat(s,"-",PLENGTH);
  1530. X      strncat(s,sedrot[*sedra+1],PLENGTH);
  1531. X      *sedra += 2*increment;
  1532. X    }
  1533. X    else *sedra += 1*increment;
  1534. X    break;
  1535. X  case BEHAR :
  1536. X    if (ydat.beharBech){
  1537. X      strncat(s,"-",PLENGTH);
  1538. X      strncat(s,sedrot[*sedra+1],PLENGTH);
  1539. X      *sedra += 2*increment;
  1540. X    }
  1541. X    else *sedra += 1*increment;
  1542. X    break;
  1543. X  case CHUKAT :
  1544. X    if (ydat.chukatBalak){
  1545. X      strncat(s,"-",PLENGTH);
  1546. X      strncat(s,sedrot[*sedra+1],PLENGTH);
  1547. X      *sedra += 2*increment;
  1548. X    }
  1549. X    else *sedra += 1*increment;
  1550. X    break;
  1551. X  case MATOT :
  1552. X    if (ydat.matotMasei){
  1553. X      strncat(s,"-",PLENGTH);
  1554. X      strncat(s,sedrot[*sedra+1],PLENGTH);
  1555. X      *sedra += 2*increment;
  1556. X    }
  1557. X    else *sedra += 1*increment;
  1558. X    break;
  1559. X  case NITZAVIM :
  1560. X    if (ydat.nitzavimVayelech){
  1561. X      strncat(s,"-",PLENGTH);
  1562. X      strncat(s,sedrot[*sedra+1],PLENGTH);
  1563. X      *sedra += 2*increment;
  1564. X    }
  1565. X    else *sedra += 1*increment;
  1566. X    break;
  1567. X  case LAST_INDEX(sedrot)-1:
  1568. X    *sedra = 0;
  1569. X    break;
  1570. X  default:
  1571. X    *sedra += 1*increment;
  1572. X  }
  1573. X  strncat(s,"\n",PLENGTH);
  1574. X  return s;
  1575. X}
  1576. X
  1577. Xvoid DoCalendar (roshDt,justMonth,justDay)
  1578. X     date_t roshDt;        /* rosh Hashana of preceeding year */
  1579. X     int justMonth,        /* print this month  */
  1580. X       justDay;            /* print this day */
  1581. X{
  1582. X  int sedra,weekday;
  1583. X  date_t todayj, todayh;
  1584. X  holstorep_t holip;        /* a list of holidays for today */
  1585. X  year_t theYear;
  1586. X  todayj = roshDt;
  1587. X  
  1588. X  todayh.mm = 0;
  1589. X  todayh.dd = 1;
  1590. X  todayh.yy = JUL2HEB(roshDt.yy) + 1; /* because it's after R"H */
  1591. X  
  1592. X  
  1593. X  theYear = yearData(todayh.yy);
  1594. X  
  1595. X  if (CHAR2NUM(theYear.name[0]) != dayOfWeek(roshDt))
  1596. X    die ("Bad Day!\n","");  
  1597. X  
  1598. X  /* first scan forward to simchat Torah, keeping track of dates only. */
  1599. X  while (todayh.dd != SIMCHAT_DAY)
  1600. X    incHebJulDate(&todayh, &todayj,&weekday);
  1601. X
  1602. X  sedra = 0;        /* initialize sedra */
  1603. X  
  1604. X  /* then continue until january 1st. */
  1605. X  do 
  1606. X    {
  1607. X      getHebHolidays(todayh,weekday,&holip);
  1608. X      if (weekday == SAT && !(holip && holip->typeMask & OWNSEDRA)) 
  1609. X    DoSedra(&sedra,theYear,1);
  1610. X      incHebJulDate(&todayh,&todayj,&weekday);
  1611. X    } while (!(todayj.mm==0 && todayj.dd==1));
  1612. X  
  1613. X  /* -------Main Year Loop-------*/
  1614. X  do {
  1615. X    if (hebDates_sw && 
  1616. X    (!specMonth_sw || (justMonth== todayj.mm)) &&
  1617. X    (!specDay_sw   || (justDay == todayj.dd))) 
  1618. X      {
  1619. X    PrintJulDate(todayj);
  1620. X    printf ("%d%s of %s, %d\n",todayh.dd, /* print the hebrew date */
  1621. X        numSuffix(todayh.dd),
  1622. X        hMonths[LEAP_YR_HEB(todayh.yy)][todayh.mm].name,
  1623. X        todayh.yy);
  1624. X      }
  1625. X    getHebHolidays(todayh,weekday,&holip); 
  1626. X    
  1627. X    if (todayh.mm == TISHREI && todayh.dd == 1)
  1628. X      theYear = yearData(todayh.yy); /* if R"H reset YearData */
  1629. X    
  1630. X
  1631. X
  1632. X    if (sedraAllWeek_sw ||
  1633. X    (sedrot_sw && weekday==SAT && 
  1634. X     !(holip && holip->typeMask & OWNSEDRA)))
  1635. X      {
  1636. X    if ((!specMonth_sw || (justMonth == todayj.mm)) &&
  1637. X        (!specDay_sw   || (justDay == todayj.dd)))
  1638. X      {
  1639. X        PrintJulDate(todayj);
  1640. X        printf("%s",DoSedra(&sedra,theYear,weekday==SAT && 
  1641. X                !(holip && holip->typeMask & OWNSEDRA)));
  1642. X      }
  1643. X    else DoSedra(&sedra,theYear,weekday==SAT && 
  1644. X             !(holip && holip->typeMask & OWNSEDRA));
  1645. X      }
  1646. X
  1647. X
  1648. X    if (sedrot_sw && 
  1649. X    todayh.mm == TISHREI && /* reset the sedra on simchat torah */
  1650. X    todayh.dd == SIMCHAT_DAY) 
  1651. X      sedra =0; 
  1652. X
  1653. X    if ((!specMonth_sw || (justMonth == todayj.mm)) &&
  1654. X    (!specDay_sw   || (justDay == todayj.dd))) 
  1655. X      for (;holip;holip = holip->next) 
  1656. X    if (!suppressHolidays_sw || (holip->typeMask & USER_EVENT))
  1657. X      {
  1658. X        PrintJulDate(todayj);
  1659. X        printf ("%s\n",holip->name);
  1660. X      }
  1661. X    
  1662. X    /* print the omer if desired */
  1663. X    if (omer && printOmer_sw && 
  1664. X    (!specMonth_sw || (justMonth == todayj.mm)) &&
  1665. X    (!specDay_sw   || (justDay == todayj.dd))) 
  1666. X      {
  1667. X    char *omerStr;
  1668. X    initStr(&omerStr,NM_LEN); 
  1669. X    strncat(omerStr,itoa(omer),NM_LEN);
  1670. X    strncat(omerStr,numSuffix(omer),NM_LEN);
  1671. X    strncat(omerStr," day of the Omer",NM_LEN);
  1672. X    PrintJulDate(todayj);
  1673. X    printf ("%s\n",omerStr);
  1674. X      }
  1675. X    if (omer) omer++;
  1676. X       
  1677. X    incHebJulDate(&todayh,&todayj,&weekday);
  1678. X  } while (!(specMonth_sw && todayj.mm > justMonth) &&
  1679. X       (todayj.mm!=0 || todayj.dd!=1)); /* continue to january 1st */
  1680. X}
  1681. END_OF_FILE
  1682.   if test 20368 -ne `wc -c <'hebcal.c'`; then
  1683.     echo shar: \"'hebcal.c'\" unpacked with wrong size!
  1684.   fi
  1685.   # end of 'hebcal.c'
  1686. fi
  1687. if test -f 'hebcal.h' -a "${1}" != "-c" ; then 
  1688.   echo shar: Will not clobber existing file \"'hebcal.h'\"
  1689. else
  1690.   echo shar: Extracting \"'hebcal.h'\" \(746 characters\)
  1691.   sed "s/^X//" >'hebcal.h' <<'END_OF_FILE'
  1692. X#ifndef __HEBCAL__
  1693. X#define __HEBCAL__
  1694. X#include <stdio.h>
  1695. X#include "greg.h"
  1696. X#include "error.h"
  1697. X#define MAXDAYS 31
  1698. X#define JUL2HEB(x) ((x)+ 3760)
  1699. X#define MAX_LINE_LEN 100
  1700. X
  1701. Xtypedef struct {
  1702. X  
  1703. X  char * name;
  1704. X  int length;
  1705. X  
  1706. X  int daysInCheshvan;
  1707. X  int daysInKislev;
  1708. X  
  1709. X  int vayakhelPikudei;    /* double parsha flags */
  1710. X  int tazriaMetzorah;
  1711. X  int achreiKedoshim;
  1712. X  int beharBech;
  1713. X  int chukatBalak; 
  1714. X  int matotMasei;
  1715. X  int nitzavimVayelech;
  1716. X  
  1717. X} year_t;
  1718. X
  1719. Xtypedef struct hinode{
  1720. X  date_t date;
  1721. X  char *name;
  1722. X  int typeMask;
  1723. X  struct hinode *next;
  1724. X} holinput_t, *holinputp_t;
  1725. X
  1726. Xtypedef struct hsnode{
  1727. X  char *name;
  1728. X  int typeMask;
  1729. X  struct hsnode *next;
  1730. X} holstore_t, *holstorep_t;
  1731. X
  1732. Xyear_t yearData();
  1733. Xvoid InitHolidays();
  1734. Xvoid DoCalendar ();
  1735. X
  1736. X#endif
  1737. END_OF_FILE
  1738.   if test 746 -ne `wc -c <'hebcal.h'`; then
  1739.     echo shar: \"'hebcal.h'\" unpacked with wrong size!
  1740.   fi
  1741.   # end of 'hebcal.h'
  1742. fi
  1743. if test -f 'start.c' -a "${1}" != "-c" ; then 
  1744.   echo shar: Will not clobber existing file \"'start.c'\"
  1745. else
  1746.   echo shar: Extracting \"'start.c'\" \(4960 characters\)
  1747.   sed "s/^X//" >'start.c' <<'END_OF_FILE'
  1748. X#include <stdio.h>
  1749. X#include "hebcal.h"
  1750. X
  1751. Xextern int sedrot_sw, hebDates_sw, euroDates_sw, specMonth_sw,specDay_sw,
  1752. X    inputFile_sw, weekday_sw, suppressHolidays_sw, suppressGreg_sw, 
  1753. X    printOmer_sw, sedraAllWeek_sw, omer;
  1754. X
  1755. Xextern FILE *inFile;
  1756. X
  1757. Xvoid RollBack(dtg,target) /* move rosh hashana dtj back until it's */
  1758. X     date_t *dtg;          /* in the year before target */
  1759. X     int target;
  1760. X{
  1761. X  int days,theyear;
  1762. X  
  1763. X  for (days = 0,theyear = dtg->yy ;theyear > target -1; theyear--)
  1764. X    days +=yearData(JUL2HEB(theyear)).length;
  1765. X  decDate (dtg,days); 
  1766. X  
  1767. X}
  1768. X
  1769. Xvoid RollForward(dtg,target)   /* move rosh hashana dtg forward until it's*/
  1770. X     date_t *dtg;               /*  in the year before target*/
  1771. X     int target; 
  1772. X{
  1773. X  int days,theyear;
  1774. X  
  1775. X  for (days = 0,theyear = dtg->yy ;theyear < target -1; theyear++)
  1776. X    days +=yearData(JUL2HEB(theyear+1)).length;
  1777. X  incDate (dtg,days); 
  1778. X  
  1779. X}
  1780. X
  1781. Xstatic int theYear,theMonth,theDay,yearDirty;
  1782. X
  1783. Xvoid handleArgs(argc, argv)
  1784. X     int argc;
  1785. X     char *argv[];
  1786. X{
  1787. X  char *c;
  1788. X  date_t tempdt;
  1789. X
  1790. X  char * usage = "usage: hebcal [-dehosStTw] [-i file] [[month [day]] year]\n               hebcal help\n";  
  1791. X
  1792. X  setDate(&tempdt);        /* do this year */
  1793. X  theYear = tempdt.yy;
  1794. X
  1795. X  for (argv++, argc--; argc; argv++, argc--)
  1796. X    if (isAllNums(*argv))
  1797. X      if ((argc-1) && isAllNums(*(argv+1)) && !yearDirty) 
  1798. X    if ((argc-2) && isAllNums(*(argv+2))) {
  1799. X      specMonth_sw =1;
  1800. X      specDay_sw =1;
  1801. X      theMonth = atoi(*argv) -1; /* year and month specified */
  1802. X      theDay = atoi(*++argv); /* print theDay of theMonth */
  1803. X      theYear = atoi(*++argv); /* print theMonth of theYear */
  1804. X      yearDirty =1;
  1805. X      argc -=2;
  1806. X    }
  1807. X    else {
  1808. X      specMonth_sw =1;
  1809. X      theMonth = atoi(*argv) -1; /* year and month specified */
  1810. X      theYear = atoi(*++argv); /* print theMonth of theYear */
  1811. X      yearDirty =1;
  1812. X      argc--;
  1813. X    }
  1814. X      else if (!yearDirty) {
  1815. X    theYear = atoi(*argv);    /* just year specified */
  1816. X    yearDirty = 1;        /* print whole year */
  1817. X      }
  1818. X      else     die(usage,"");
  1819. X    else if (**argv == '-')
  1820. X      for (c = *argv,c++;*c;c++)
  1821. X    switch (*c) {
  1822. X    case 'd' :        /* print hebrew dates */
  1823. X      hebDates_sw = 1;
  1824. X      break;
  1825. X    case 'i' :
  1826. X      inputFile_sw =1;
  1827. X      if (!(inFile = fopen(*++argv,"r"))) 
  1828. X        die("could not open input file %s.",*argv);
  1829. X      argc--;
  1830. X      break;
  1831. X    case 'e':
  1832. X      euroDates_sw =1;
  1833. X      break;
  1834. X    case 'h':
  1835. X      suppressHolidays_sw =1;
  1836. X      break;
  1837. X    case 'o':
  1838. X      printOmer_sw =1;
  1839. X      break;
  1840. X    case 's' :        /* print sedrot */
  1841. X      sedrot_sw = 1;
  1842. X      break;
  1843. X    case 'S':        /* print sedra every day. */
  1844. X      sedraAllWeek_sw =1;
  1845. X      break;
  1846. X    case 't':        /* do hebcal for today. */
  1847. X      specMonth_sw =1;
  1848. X      specDay_sw =1;
  1849. X      theMonth = tempdt.mm; /* year and month specified */
  1850. X      theDay = tempdt.dd; /* print theDay of theMonth */
  1851. X      yearDirty =1;
  1852. X      break;
  1853. X    case 'T':        /* do hebcal for today, omit gregorian date. */
  1854. X      suppressGreg_sw = 1;
  1855. X      specMonth_sw =1;
  1856. X      specDay_sw =1;
  1857. X      theMonth = tempdt.mm; /* year and month specified */
  1858. X      theDay = tempdt.dd; /* print theDay of theMonth */
  1859. X      yearDirty =1;
  1860. X      printOmer_sw =1;
  1861. X      break;
  1862. X    case 'w' :        /* print days of the week */
  1863. X      weekday_sw = 1;
  1864. X      break;
  1865. X    default: die(usage,"");
  1866. X    }
  1867. X    else if (!strcmp(*argv,"help")) {
  1868. X      printf ("Hebcal Version 2.0\n\n");
  1869. X      printf ("Hebcal prints out hebrew calendars one solar year at a time.\n");
  1870. X      printf ("Given one numeric argument, it will print out the calendar \n");
  1871. X      printf ("for that year.  Given two numeric argumetnts mm yyyy, it\n");
  1872. X      printf ("prints out the calendar for month mm of year yyyy. \n");
  1873. X      printf (usage);
  1874. X      printf ("\nOPTIONS:\n   -d : add hebrew dates\n");
  1875. X      printf ("   -e : use european dates for OUTPUT ONLY (input format the same)\n");
  1876. X      printf ("   -h : suppress holidays\n");
  1877. X      printf ("   -i : get user events from specified file\n");
  1878. X      printf ("   -o : add days of the omer\n");
  1879. X      printf ("   -s : add weekly sedrot on Saturday\n");
  1880. X      printf ("   -S : print sedrah of the week on all calendar days\n");
  1881. X      printf ("   -t : only output for today's date\n");
  1882. X      printf ("   -T : print today's pertinent information, no gregorian date\n");
  1883. X      printf ("   -w : add day of the week\n\n");
  1884. X      printf ("       hebcal help --- prints this message\n"); 
  1885. X      printf ("\nExample: \n");
  1886. X      printf ("   hebcal -ho\n");
  1887. X      printf ("will just print out the days of the omer for the current year.\n");
  1888. X      exit(0);
  1889. X    }
  1890. X    else die (usage,"");
  1891. X}
  1892. X
  1893. Xchar * progname;
  1894. X
  1895. Xint main (argc, argv)
  1896. X     int argc;
  1897. X     char *argv[];
  1898. X{
  1899. X  date_t startDate;
  1900. X  
  1901. X   progname = argv[0];
  1902. X  
  1903. X  startDate.dd = 28;
  1904. X  startDate.mm = SEP; /* any ol' rosh hashana */
  1905. X  startDate.yy = 1992;
  1906. X
  1907. X  handleArgs(argc,argv);
  1908. X  
  1909. X  if (specDay_sw) hebDates_sw = 1;
  1910. X  
  1911. X  if (theYear < startDate.yy +1) /* go to R"H of the year before */
  1912. X    RollBack(&startDate,theYear);
  1913. X  else if (theYear > startDate.yy +1) /* start from there */
  1914. X    RollForward(&startDate,theYear);
  1915. X
  1916. X  InitHolidays(startDate);
  1917. X  DoCalendar(startDate,theMonth,theDay);   
  1918. X  
  1919. X  return 0;
  1920. X}
  1921. END_OF_FILE
  1922.   if test 4960 -ne `wc -c <'start.c'`; then
  1923.     echo shar: \"'start.c'\" unpacked with wrong size!
  1924.   fi
  1925.   # end of 'start.c'
  1926. fi
  1927. echo shar: End of archive 1 \(of 1\).
  1928. cp /dev/null ark1isdone
  1929. MISSING=""
  1930. for I in 1 ; do
  1931.     if test ! -f ark${I}isdone ; then
  1932.     MISSING="${MISSING} ${I}"
  1933.     fi
  1934. done
  1935. if test "${MISSING}" = "" ; then
  1936.     echo You have the archive.
  1937.     rm -f ark[1-9]isdone
  1938. else
  1939.     echo You still must unpack the following archives:
  1940.     echo "        " ${MISSING}
  1941. fi
  1942. exit 0
  1943. exit 0 # Just in case...
  1944.