1 /* $selId: jewish.c,v 2.0 1995/10/24 01:13:06 lees Exp $
2 * Copyright 1993-1995, Scott E. Lee, all rights reserved.
3 * Permission granted to use, copy, modify, distribute and sell so long as
4 * the above copyright and this permission statement are retained in all
5 * copies. THERE IS NO WARRANTY - USE AT YOUR OWN RISK.
6 */
7
8 /**************************************************************************
9 *
10 * These are the externally visible components of this file:
11 *
12 * void
13 * SdnToJewish(
14 * long int sdn,
15 * int *pYear,
16 * int *pMonth,
17 * int *pDay);
18 *
19 * Convert a SDN to a Jewish calendar date. If the input SDN is before the
20 * first day of year 1, the three output values will all be set to zero,
21 * otherwise *pYear will be > 0; *pMonth will be in the range 1 to 13
22 * inclusive; *pDay will be in the range 1 to 30 inclusive. Note that Adar
23 * II is assigned the month number 7 and Elul is always 13.
24 *
25 * long int
26 * JewishToSdn(
27 * int year,
28 * int month,
29 * int day);
30 *
31 * Convert a Jewish calendar date to a SDN. Zero is returned when the
32 * input date is detected as invalid or out of the supported range. The
33 * return value will be > 0 for all valid, supported dates, but there are
34 * some invalid dates that will return a positive value. To verify that a
35 * date is valid, convert it to SDN and then back and compare with the
36 * original.
37 *
38 * char *JewishMonthName[14];
39 *
40 * Convert a Jewish month number (1 to 13) to the name of the Jewish month
41 * (null terminated). An index of zero will return a zero length string.
42 *
43 * VALID RANGE
44 *
45 * Although this software can handle dates all the way back to the year
46 * 1 (3761 B.C.), such use may not be meaningful.
47 *
48 * The Jewish calendar has been in use for several thousand years, but
49 * in the early days there was no formula to determine the start of a
50 * month. A new month was started when the new moon was first
51 * observed.
52 *
53 * It is not clear when the current rule based calendar replaced the
54 * observation based calendar. According to the book "Jewish Calendar
55 * Mystery Dispelled" by George Zinberg, the patriarch Hillel II
56 * published these rules in 358 A.D. But, according to The
57 * Encyclopedia Judaica, Hillel II may have only published the 19 year
58 * rule for determining the occurrence of leap years.
59 *
60 * I have yet to find a specific date when the current set of rules
61 * were known to be in use.
62 *
63 * CALENDAR OVERVIEW
64 *
65 * The Jewish calendar is based on lunar as well as solar cycles. A
66 * month always starts on or near a new moon and has either 29 or 30
67 * days (a lunar cycle is about 29 1/2 days). Twelve of these
68 * alternating 29-30 day months gives a year of 354 days, which is
69 * about 11 1/4 days short of a solar year.
70 *
71 * Since a month is defined to be a lunar cycle (new moon to new moon),
72 * this 11 1/4 day difference cannot be overcome by adding days to a
73 * month as with the Gregorian calendar, so an entire month is
74 * periodically added to the year, making some years 13 months long.
75 *
76 * For astronomical as well as ceremonial reasons, the start of a new
77 * year may be delayed until a day or two after the new moon causing
78 * years to vary in length. Leap years can be from 383 to 385 days and
79 * common years can be from 353 to 355 days. These are the months of
80 * the year and their possible lengths:
81 *
82 * COMMON YEAR LEAP YEAR
83 * 1 Tishri 30 30 30 30 30 30
84 * 2 Heshvan 29 29 30 29 29 30 (variable)
85 * 3 Kislev 29 30 30 29 30 30 (variable)
86 * 4 Tevet 29 29 29 29 29 29
87 * 5 Shevat 30 30 30 30 30 30
88 * 6 Adar I -- -- -- 30 30 30 (optional)
89 * 7 Adar (II) 29 29 29 29 29 29
90 * 8 Nisan 30 30 30 30 30 30
91 * 9 Iyyar 29 29 29 29 29 29
92 * 10 Sivan 30 30 30 30 30 30
93 * 11 Tammuz 29 29 29 29 29 29
94 * 12 Av 30 30 30 30 30 30
95 * 13 Elul 29 29 29 29 29 29
96 * --- --- --- --- --- ---
97 * 353 354 355 383 384 385
98 *
99 * Note that the month names and other words that appear in this file
100 * have multiple possible spellings in the Roman character set. I have
101 * chosen to use the spellings found in the Encyclopedia Judaica.
102 *
103 * Adar I, the month added for leap years, is sometimes referred to as
104 * the 13th month, but I have chosen to assign it the number 6 to keep
105 * the months in chronological order. This may not be consistent with
106 * other numbering schemes.
107 *
108 * Leap years occur in a fixed pattern of 19 years called the metonic
109 * cycle. The 3rd, 6th, 8th, 11th, 14th, 17th and 19th years of this
110 * cycle are leap years. The first metonic cycle starts with Jewish
111 * year 1, or 3761/60 B.C. This is believed to be the year of
112 * creation.
113 *
114 * To construct the calendar for a year, you must first find the length
115 * of the year by determining the first day of the year (Tishri 1, or
116 * Rosh Ha-Shanah) and the first day of the following year. This
117 * selects one of the six possible month length configurations listed
118 * above.
119 *
120 * Finding the first day of the year is the most difficult part.
121 * Finding the date and time of the new moon (or molad) is the first
122 * step. For this purpose, the lunar cycle is assumed to be 29 days 12
123 * hours and 793 halakim. A halakim is 1/1080th of an hour or 3 1/3
124 * seconds. (This assumed value is only about 1/2 second less than the
125 * value used by modern astronomers -- not bad for a number that was
126 * determined so long ago.) The first molad of year 1 occurred on
127 * Sunday at 11:20:11 P.M. This would actually be Monday, because the
128 * Jewish day is considered to begin at sunset.
129 *
130 * Since sunset varies, the day is assumed to begin at 6:00 P.M. for
131 * calendar calculation purposes. So, the first molad was 5 hours 793
132 * halakim after the start of Tishri 1, 0001 (which was Monday
133 * September 7, 4761 B.C. by the Gregorian calendar). All subsequent
134 * molads can be calculated from this starting point by adding the
135 * length of a lunar cycle.
136 *
137 * Once the molad that starts a year is determined the actual start of
138 * the year (Tishri 1) can be determined. Tishri 1 will be the day of
139 * the molad unless it is delayed by one of the following four rules
140 * (called dehiyyot). Each rule can delay the start of the year by one
141 * day, and since rule #1 can combine with one of the other rules, it
142 * can be delayed as much as two days.
143 *
144 * 1. Tishri 1 must never be Sunday, Wednesday or Friday. (This
145 * is largely to prevent certain holidays from occurring on the
146 * day before or after the Sabbath.)
147 *
148 * 2. If the molad occurs on or after noon, Tishri 1 must be
149 * delayed.
150 *
151 * 3. If it is a common (not leap) year and the molad occurs on
152 * Tuesday at or after 3:11:20 A.M., Tishri 1 must be delayed.
153 *
154 * 4. If it is the year following a leap year and the molad occurs
155 * on Monday at or after 9:32:43 and 1/3 sec, Tishri 1 must be
156 * delayed.
157 *
158 * GLOSSARY
159 *
160 * dehiyyot The set of 4 rules that determine when the new year
161 * starts relative to the molad.
162 *
163 * halakim 1/1080th of an hour or 3 1/3 seconds.
164 *
165 * lunar cycle The period of time between mean conjunctions of the
166 * sun and moon (new moon to new moon). This is
167 * assumed to be 29 days 12 hours and 793 halakim for
168 * calendar purposes.
169 *
170 * metonic cycle A 19 year cycle which determines which years are
171 * leap years and which are common years. The 3rd,
172 * 6th, 8th, 11th, 14th, 17th and 19th years of this
173 * cycle are leap years.
174 *
175 * molad The date and time of the mean conjunction of the
176 * sun and moon (new moon). This is the approximate
177 * beginning of a month.
178 *
179 * Rosh Ha-Shanah The first day of the Jewish year (Tishri 1).
180 *
181 * Tishri The first month of the Jewish year.
182 *
183 * ALGORITHMS
184 *
185 * SERIAL DAY NUMBER TO JEWISH DATE
186 *
187 * The simplest approach would be to use the rules stated above to find
188 * the molad of Tishri before and after the given day number. Then use
189 * the molads to find Tishri 1 of the current and following years.
190 * From this the length of the year can be determined and thus the
191 * length of each month. But this method is used as a last resort.
192 *
193 * The first 59 days of the year are the same regardless of the length
194 * of the year. As a result, only the day number of the start of the
195 * year is required.
196 *
197 * Similarly, the last 6 months do not change from year to year. And
198 * since it can be determined whether the year is a leap year by simple
199 * division, the lengths of Adar I and II can be easily calculated. In
200 * fact, all dates after the 3rd month are consistent from year to year
201 * (once it is known whether it is a leap year).
202 *
203 * This means that if the given day number falls in the 3rd month or on
204 * the 30th day of the 2nd month the length of the year must be found,
205 * but in no other case.
206 *
207 * So, the approach used is to take the given day number and round it
208 * to the closest molad of Tishri (first new moon of the year). The
209 * rounding is not really to the *closest* molad, but is such that if
210 * the day number is before the middle of the 3rd month the molad at
211 * the start of the year is found, otherwise the molad at the end of
212 * the year is found.
213 *
214 * Only if the day number is actually found to be in the ambiguous
215 * period of 29 to 31 days is the other molad calculated.
216 *
217 * JEWISH DATE TO SERIAL DAY NUMBER
218 *
219 * The year number is used to find which 19 year metonic cycle contains
220 * the date and which year within the cycle (this is a division and
221 * modulus). This also determines whether it is a leap year.
222 *
223 * If the month is 1 or 2, the calculation is simple addition to the
224 * first of the year.
225 *
226 * If the month is 8 (Nisan) or greater, the calculation is simple
227 * subtraction from beginning of the following year.
228 *
229 * If the month is 4 to 7, it is considered whether it is a leap year
230 * and then simple subtraction from the beginning of the following year
231 * is used.
232 *
233 * Only if it is the 3rd month is both the start and end of the year
234 * required.
235 *
236 * TESTING
237 *
238 * This algorithm has been tested in two ways. First, 510 dates from a
239 * table in "Jewish Calendar Mystery Dispelled" were calculated and
240 * compared to the table. Second, the calculation algorithm described
241 * in "Jewish Calendar Mystery Dispelled" was coded and used to verify
242 * all dates from the year 1 (3761 B.C.) to the year 13760 (10000
243 * A.D.).
244 *
245 * The source code of the verification program is included in this
246 * package.
247 *
248 * REFERENCES
249 *
250 * The Encyclopedia Judaica, the entry for "Calendar"
251 *
252 * The Jewish Encyclopedia
253 *
254 * Jewish Calendar Mystery Dispelled by George Zinberg, Vantage Press,
255 * 1963
256 *
257 * The Comprehensive Hebrew Calendar by Arthur Spier, Behrman House
258 *
259 * The Book of Calendars [note that this work contains many typos]
260 *
261 **************************************************************************/
262
263 #if defined(PHP_WIN32)
264 #pragma setlocale("english")
265 #endif
266
267 #include "sdncal.h"
268
269 #define HALAKIM_PER_HOUR 1080
270 #define HALAKIM_PER_DAY 25920
271 #define HALAKIM_PER_LUNAR_CYCLE ((29 * HALAKIM_PER_DAY) + 13753)
272 #define HALAKIM_PER_METONIC_CYCLE (HALAKIM_PER_LUNAR_CYCLE * (12 * 19 + 7))
273
274 #define JEWISH_SDN_OFFSET 347997
275 #define JEWISH_SDN_MAX 324542846L /* 12/13/887605, greater value raises integer overflow */
276 #define NEW_MOON_OF_CREATION 31524
277
278 #define SUNDAY 0
279 #define MONDAY 1
280 #define TUESDAY 2
281 #define WEDNESDAY 3
282 #define THURSDAY 4
283 #define FRIDAY 5
284 #define SATURDAY 6
285
286 #define NOON (18 * HALAKIM_PER_HOUR)
287 #define AM3_11_20 ((9 * HALAKIM_PER_HOUR) + 204)
288 #define AM9_32_43 ((15 * HALAKIM_PER_HOUR) + 589)
289
290 const int monthsPerYear[19] =
291 {
292 12, 12, 13, 12, 12, 13, 12, 13, 12, 12, 13, 12, 12, 13, 12, 12, 13, 12, 13
293 };
294
295 static const int yearOffset[19] =
296 {
297 0, 12, 24, 37, 49, 61, 74, 86, 99, 111, 123,
298 136, 148, 160, 173, 185, 197, 210, 222
299 };
300
301 /* names for leap (13-month) year */
302 const char * const JewishMonthNameLeap[14] =
303 {
304 "",
305 "Tishri",
306 "Heshvan",
307 "Kislev",
308 "Tevet",
309 "Shevat",
310 "Adar I",
311 "Adar II",
312 "Nisan",
313 "Iyyar",
314 "Sivan",
315 "Tammuz",
316 "Av",
317 "Elul"
318 };
319
320 /* names for regular year */
321 const char * const JewishMonthName[14] =
322 {
323 "",
324 "Tishri",
325 "Heshvan",
326 "Kislev",
327 "Tevet",
328 "Shevat",
329 "",
330 "Adar",
331 "Nisan",
332 "Iyyar",
333 "Sivan",
334 "Tammuz",
335 "Av",
336 "Elul"
337 };
338
339 /* names for leap (13-month) year */
340 const char * const JewishMonthHebNameLeap[14] =
341 {
342 "",
343 "\xFA\xF9\xF8\xE9",
344 "\xE7\xF9\xE5\xEF",
345 "\xEB\xF1\xEC\xE5",
346 "\xE8\xE1\xFA",
347 "\xF9\xE1\xE8",
348 "\xE0\xE3\xF8 \xE0'",
349 "\xE0\xE3\xF8 \xE1'",
350 "\xF0\xE9\xF1\xEF",
351 "\xE0\xE9\xE9\xF8",
352 "\xF1\xE9\xe5\xEF",
353 "\xFA\xEE\xE5\xE6",
354 "\xE0\xE1",
355 "\xE0\xEC\xE5\xEC"
356 };
357
358 /* names for regular year */
359 const char * const JewishMonthHebName[14] =
360 {
361 "",
362 "\xFA\xF9\xF8\xE9",
363 "\xE7\xF9\xE5\xEF",
364 "\xEB\xF1\xEC\xE5",
365 "\xE8\xE1\xFA",
366 "\xF9\xE1\xE8",
367 "",
368 "\xE0\xE3\xF8",
369 "\xF0\xE9\xF1\xEF",
370 "\xE0\xE9\xE9\xF8",
371 "\xF1\xE9\xE5\xEF",
372 "\xFA\xEE\xE5\xE6",
373 "\xE0\xE1",
374 "\xE0\xEC\xE5\xEC"
375 };
376
377 /************************************************************************
378 * Given the year within the 19 year metonic cycle and the time of a molad
379 * (new moon) which starts that year, this routine will calculate what day
380 * will be the actual start of the year (Tishri 1 or Rosh Ha-Shanah). This
381 * first day of the year will be the day of the molad unless one of 4 rules
382 * (called dehiyyot) delays it. These 4 rules can delay the start of the
383 * year by as much as 2 days.
384 */
Tishri1(int metonicYear,zend_long moladDay,zend_long moladHalakim)385 static zend_long Tishri1(
386 int metonicYear,
387 zend_long moladDay,
388 zend_long moladHalakim)
389 {
390 zend_long tishri1;
391 int dow;
392 int leapYear;
393 int lastWasLeapYear;
394
395 tishri1 = moladDay;
396 dow = tishri1 % 7;
397 leapYear = metonicYear == 2 || metonicYear == 5 || metonicYear == 7
398 || metonicYear == 10 || metonicYear == 13 || metonicYear == 16
399 || metonicYear == 18;
400 lastWasLeapYear = metonicYear == 3 || metonicYear == 6
401 || metonicYear == 8 || metonicYear == 11 || metonicYear == 14
402 || metonicYear == 17 || metonicYear == 0;
403
404 /* Apply rules 2, 3 and 4. */
405 if ((moladHalakim >= NOON) ||
406 ((!leapYear) && dow == TUESDAY && moladHalakim >= AM3_11_20) ||
407 (lastWasLeapYear && dow == MONDAY && moladHalakim >= AM9_32_43)) {
408 tishri1++;
409 dow++;
410 if (dow == 7) {
411 dow = 0;
412 }
413 }
414 /* Apply rule 1 after the others because it can cause an additional
415 * delay of one day. */
416 if (dow == WEDNESDAY || dow == FRIDAY || dow == SUNDAY) {
417 tishri1++;
418 }
419 return (tishri1);
420 }
421
422 /************************************************************************
423 * Given a metonic cycle number, calculate the date and time of the molad
424 * (new moon) that starts that cycle. Since the length of a metonic cycle
425 * is a constant, this is a simple calculation, except that it requires an
426 * intermediate value which is bigger that 32 bits. Because this
427 * intermediate value only needs 36 to 37 bits and the other numbers are
428 * constants, the process has been reduced to just a few steps.
429 */
MoladOfMetonicCycle(int metonicCycle,zend_long * pMoladDay,zend_long * pMoladHalakim)430 static void MoladOfMetonicCycle(
431 int metonicCycle,
432 zend_long *pMoladDay,
433 zend_long *pMoladHalakim)
434 {
435 register zend_ulong r1, r2, d1, d2;
436 zend_long chk;
437
438 /* Start with the time of the first molad after creation. */
439 r1 = NEW_MOON_OF_CREATION;
440 chk = (zend_long)metonicCycle;
441
442 if (chk > (ZEND_LONG_MAX - NEW_MOON_OF_CREATION) / (HALAKIM_PER_METONIC_CYCLE & 0xFFFF)) {
443 *pMoladDay = 0;
444 *pMoladHalakim = 0;
445 return;
446 }
447
448 /* Calculate metonicCycle * HALAKIM_PER_METONIC_CYCLE. The upper 32
449 * bits of the result will be in r2 and the lower 16 bits will be
450 * in r1. */
451 r1 += chk * (HALAKIM_PER_METONIC_CYCLE & 0xFFFF);
452
453 if (chk > (ZEND_LONG_MAX - (r1 >> 16)) / ((HALAKIM_PER_METONIC_CYCLE >> 16) & 0xFFFF)) {
454 *pMoladDay = 0;
455 *pMoladHalakim = 0;
456 return;
457 }
458
459 r2 = r1 >> 16;
460 r2 += chk * ((HALAKIM_PER_METONIC_CYCLE >> 16) & 0xFFFF);
461
462 /* Calculate r2r1 / HALAKIM_PER_DAY. The remainder will be in r1, the
463 * upper 16 bits of the quotient will be in d2 and the lower 16 bits
464 * will be in d1. */
465 d2 = r2 / HALAKIM_PER_DAY;
466 r2 -= d2 * HALAKIM_PER_DAY;
467 r1 = (r2 << 16) | (r1 & 0xFFFF);
468 d1 = r1 / HALAKIM_PER_DAY;
469 r1 -= d1 * HALAKIM_PER_DAY;
470
471 *pMoladDay = (d2 << 16) | d1;
472 *pMoladHalakim = r1;
473 }
474
475 /************************************************************************
476 * Given a day number, find the molad of Tishri (the new moon at the start
477 * of a year) which is closest to that day number. It's not really the
478 * *closest* molad that we want here. If the input day is in the first two
479 * months, we want the molad at the start of the year. If the input day is
480 * in the fourth to last months, we want the molad at the end of the year.
481 * If the input day is in the third month, it doesn't matter which molad is
482 * returned, because both will be required. This type of "rounding" allows
483 * us to avoid calculating the length of the year in most cases.
484 */
FindTishriMolad(zend_long inputDay,int * pMetonicCycle,int * pMetonicYear,zend_long * pMoladDay,zend_long * pMoladHalakim)485 static void FindTishriMolad(
486 zend_long inputDay,
487 int *pMetonicCycle,
488 int *pMetonicYear,
489 zend_long *pMoladDay,
490 zend_long *pMoladHalakim)
491 {
492 zend_long moladDay;
493 zend_long moladHalakim;
494 int metonicCycle;
495 int metonicYear;
496
497 /* Estimate the metonic cycle number. Note that this may be an under
498 * estimate because there are 6939.6896 days in a metonic cycle not
499 * 6940, but it will never be an over estimate. The loop below will
500 * correct for any error in this estimate. */
501 metonicCycle = (inputDay + 310) / 6940;
502
503 /* Calculate the time of the starting molad for this metonic cycle. */
504 MoladOfMetonicCycle(metonicCycle, &moladDay, &moladHalakim);
505
506 /* If the above was an under estimate, increment the cycle number until
507 * the correct one is found. For modern dates this loop is about 98.6%
508 * likely to not execute, even once, because the above estimate is
509 * really quite close. */
510 while (moladDay < inputDay - 6940 + 310) {
511 metonicCycle++;
512 moladHalakim += HALAKIM_PER_METONIC_CYCLE;
513 moladDay += moladHalakim / HALAKIM_PER_DAY;
514 moladHalakim = moladHalakim % HALAKIM_PER_DAY;
515 }
516
517 /* Find the molad of Tishri closest to this date. */
518 for (metonicYear = 0; metonicYear < 18; metonicYear++) {
519 if (moladDay > inputDay - 74) {
520 break;
521 }
522 moladHalakim += HALAKIM_PER_LUNAR_CYCLE * monthsPerYear[metonicYear];
523 moladDay += moladHalakim / HALAKIM_PER_DAY;
524 moladHalakim = moladHalakim % HALAKIM_PER_DAY;
525 }
526
527 *pMetonicCycle = metonicCycle;
528 *pMetonicYear = metonicYear;
529 *pMoladDay = moladDay;
530 *pMoladHalakim = moladHalakim;
531 }
532
533 /************************************************************************
534 * Given a year, find the number of the first day of that year and the date
535 * and time of the starting molad.
536 */
FindStartOfYear(int year,int * pMetonicCycle,int * pMetonicYear,zend_long * pMoladDay,zend_long * pMoladHalakim,int * pTishri1)537 static void FindStartOfYear(
538 int year,
539 int *pMetonicCycle,
540 int *pMetonicYear,
541 zend_long *pMoladDay,
542 zend_long *pMoladHalakim,
543 int *pTishri1)
544 {
545 *pMetonicCycle = (year - 1) / 19;
546 *pMetonicYear = (year - 1) % 19;
547 MoladOfMetonicCycle(*pMetonicCycle, pMoladDay, pMoladHalakim);
548
549 *pMoladHalakim += HALAKIM_PER_LUNAR_CYCLE * yearOffset[*pMetonicYear];
550 *pMoladDay += *pMoladHalakim / HALAKIM_PER_DAY;
551 *pMoladHalakim = *pMoladHalakim % HALAKIM_PER_DAY;
552
553 *pTishri1 = Tishri1(*pMetonicYear, *pMoladDay, *pMoladHalakim);
554 }
555
556 /************************************************************************
557 * Given a serial day number (SDN), find the corresponding year, month and
558 * day in the Jewish calendar. The three output values will always be
559 * modified. If the input SDN is before the first day of year 1, they will
560 * all be set to zero, otherwise *pYear will be > 0; *pMonth will be in the
561 * range 1 to 13 inclusive; *pDay will be in the range 1 to 30 inclusive.
562 */
SdnToJewish(zend_long sdn,int * pYear,int * pMonth,int * pDay)563 void SdnToJewish(
564 zend_long sdn,
565 int *pYear,
566 int *pMonth,
567 int *pDay)
568 {
569 zend_long inputDay;
570 zend_long day;
571 zend_long halakim;
572 int metonicCycle;
573 int metonicYear;
574 int tishri1;
575 int tishri1After;
576 int yearLength;
577
578 if (sdn <= JEWISH_SDN_OFFSET || sdn > JEWISH_SDN_MAX) {
579 *pYear = 0;
580 *pMonth = 0;
581 *pDay = 0;
582 return;
583 }
584 inputDay = sdn - JEWISH_SDN_OFFSET;
585
586 FindTishriMolad(inputDay, &metonicCycle, &metonicYear, &day, &halakim);
587 tishri1 = Tishri1(metonicYear, day, halakim);
588
589 if (inputDay >= tishri1) {
590 /* It found Tishri 1 at the start of the year. */
591 *pYear = metonicCycle * 19 + metonicYear + 1;
592 if (inputDay < tishri1 + 59) {
593 if (inputDay < tishri1 + 30) {
594 *pMonth = 1;
595 *pDay = inputDay - tishri1 + 1;
596 } else {
597 *pMonth = 2;
598 *pDay = inputDay - tishri1 - 29;
599 }
600 return;
601 }
602 /* We need the length of the year to figure this out, so find
603 * Tishri 1 of the next year. */
604 halakim += HALAKIM_PER_LUNAR_CYCLE * monthsPerYear[metonicYear];
605 day += halakim / HALAKIM_PER_DAY;
606 halakim = halakim % HALAKIM_PER_DAY;
607 tishri1After = Tishri1((metonicYear + 1) % 19, day, halakim);
608 } else {
609 /* It found Tishri 1 at the end of the year. */
610 *pYear = metonicCycle * 19 + metonicYear;
611 if (inputDay >= tishri1 - 177) {
612 /* It is one of the last 6 months of the year. */
613 if (inputDay > tishri1 - 30) {
614 *pMonth = 13;
615 *pDay = inputDay - tishri1 + 30;
616 } else if (inputDay > tishri1 - 60) {
617 *pMonth = 12;
618 *pDay = inputDay - tishri1 + 60;
619 } else if (inputDay > tishri1 - 89) {
620 *pMonth = 11;
621 *pDay = inputDay - tishri1 + 89;
622 } else if (inputDay > tishri1 - 119) {
623 *pMonth = 10;
624 *pDay = inputDay - tishri1 + 119;
625 } else if (inputDay > tishri1 - 148) {
626 *pMonth = 9;
627 *pDay = inputDay - tishri1 + 148;
628 } else {
629 *pMonth = 8;
630 *pDay = inputDay - tishri1 + 178;
631 }
632 return;
633 } else {
634 if (monthsPerYear[(*pYear - 1) % 19] == 13) {
635 *pMonth = 7;
636 *pDay = inputDay - tishri1 + 207;
637 if (*pDay > 0)
638 return;
639 (*pMonth)--;
640 (*pDay) += 30;
641 if (*pDay > 0)
642 return;
643 (*pMonth)--;
644 (*pDay) += 30;
645 } else {
646 *pMonth = 7;
647 *pDay = inputDay - tishri1 + 207;
648 if (*pDay > 0)
649 return;
650 (*pMonth) -= 2;
651 (*pDay) += 30;
652 }
653 if (*pDay > 0)
654 return;
655 (*pMonth)--;
656 (*pDay) += 29;
657 if (*pDay > 0)
658 return;
659
660 /* We need the length of the year to figure this out, so find
661 * Tishri 1 of this year. */
662 tishri1After = tishri1;
663 FindTishriMolad(day - 365,
664 &metonicCycle, &metonicYear, &day, &halakim);
665 tishri1 = Tishri1(metonicYear, day, halakim);
666 }
667 }
668
669 yearLength = tishri1After - tishri1;
670 day = inputDay - tishri1 - 29;
671 if (yearLength == 355 || yearLength == 385) {
672 /* Heshvan has 30 days */
673 if (day <= 30) {
674 *pMonth = 2;
675 *pDay = day;
676 return;
677 }
678 day -= 30;
679 } else {
680 /* Heshvan has 29 days */
681 if (day <= 29) {
682 *pMonth = 2;
683 *pDay = day;
684 return;
685 }
686 day -= 29;
687 }
688
689 /* It has to be Kislev. */
690 *pMonth = 3;
691 *pDay = day;
692 }
693
694 /************************************************************************
695 * Given a year, month and day in the Jewish calendar, find the
696 * corresponding serial day number (SDN). Zero is returned when the input
697 * date is detected as invalid. The return value will be > 0 for all valid
698 * dates, but there are some invalid dates that will return a positive
699 * value. To verify that a date is valid, convert it to SDN and then back
700 * and compare with the original.
701 */
JewishToSdn(int year,int month,int day)702 zend_long JewishToSdn(
703 int year,
704 int month,
705 int day)
706 {
707 zend_long sdn;
708 int metonicCycle;
709 int metonicYear;
710 int tishri1;
711 int tishri1After;
712 zend_long moladDay;
713 zend_long moladHalakim;
714 int yearLength;
715 int lengthOfAdarIAndII;
716
717 if (year <= 0 || day <= 0 || day > 30) {
718 return (0);
719 }
720 switch (month) {
721 case 1:
722 case 2:
723 /* It is Tishri or Heshvan - don't need the year length. */
724 FindStartOfYear(year, &metonicCycle, &metonicYear,
725 &moladDay, &moladHalakim, &tishri1);
726 if (month == 1) {
727 sdn = tishri1 + day - 1;
728 } else {
729 sdn = tishri1 + day + 29;
730 }
731 break;
732
733 case 3:
734 /* It is Kislev - must find the year length. */
735
736 /* Find the start of the year. */
737 FindStartOfYear(year, &metonicCycle, &metonicYear,
738 &moladDay, &moladHalakim, &tishri1);
739
740 /* Find the end of the year. */
741 moladHalakim += HALAKIM_PER_LUNAR_CYCLE * monthsPerYear[metonicYear];
742 moladDay += moladHalakim / HALAKIM_PER_DAY;
743 moladHalakim = moladHalakim % HALAKIM_PER_DAY;
744 tishri1After = Tishri1((metonicYear + 1) % 19, moladDay, moladHalakim);
745
746 yearLength = tishri1After - tishri1;
747
748 if (yearLength == 355 || yearLength == 385) {
749 sdn = tishri1 + day + 59;
750 } else {
751 sdn = tishri1 + day + 58;
752 }
753 break;
754
755 case 4:
756 case 5:
757 case 6:
758 /* It is Tevet, Shevat or Adar I - don't need the year length. */
759
760 FindStartOfYear(year + 1, &metonicCycle, &metonicYear,
761 &moladDay, &moladHalakim, &tishri1After);
762
763 if (monthsPerYear[(year - 1) % 19] == 12) {
764 lengthOfAdarIAndII = 29;
765 } else {
766 lengthOfAdarIAndII = 59;
767 }
768
769 if (month == 4) {
770 sdn = tishri1After + day - lengthOfAdarIAndII - 237;
771 } else if (month == 5) {
772 sdn = tishri1After + day - lengthOfAdarIAndII - 208;
773 } else {
774 sdn = tishri1After + day - lengthOfAdarIAndII - 178;
775 }
776 break;
777
778 default:
779 /* It is Adar II or later - don't need the year length. */
780 FindStartOfYear(year + 1, &metonicCycle, &metonicYear,
781 &moladDay, &moladHalakim, &tishri1After);
782
783 switch (month) {
784 case 7:
785 sdn = tishri1After + day - 207;
786 break;
787 case 8:
788 sdn = tishri1After + day - 178;
789 break;
790 case 9:
791 sdn = tishri1After + day - 148;
792 break;
793 case 10:
794 sdn = tishri1After + day - 119;
795 break;
796 case 11:
797 sdn = tishri1After + day - 89;
798 break;
799 case 12:
800 sdn = tishri1After + day - 60;
801 break;
802 case 13:
803 sdn = tishri1After + day - 30;
804 break;
805 default:
806 return (0);
807 }
808 }
809 return (sdn + JEWISH_SDN_OFFSET);
810 }
811
