home *** CD-ROM | disk | FTP | other *** search
/ The Fred Fish Collection 1.5 / ffcollection-1-5-1992-11.iso / ff_progs / business / calend2.lzh / CALENDAR / TIME.C < prev    next >
C/C++ Source or Header  |  1991-11-01  |  6KB  |  338 lines
  1. #include <time.h>
  2. #include "month.h"
  3.  
  4. short month, year, day;
  5. short this_month, this_day, this_year;
  6. short start_day;
  7.  
  8. extern short dhour, dminute, dsecond, days;
  9.  
  10. get_current_date()
  11. {
  12. #ifdef AMIGA
  13.     long now;
  14. #else
  15.     struct timeval tp;
  16.     struct timezone tzp;
  17. #endif
  18.     struct tm *tmp, *localtime();
  19.  
  20. #ifdef AMIGA
  21.     now = time(NULL);
  22.     tmp = localtime(&now);
  23. #else
  24.     gettimeofday(&tp, &tzp);
  25.     tmp = localtime(&tp.tv_sec);
  26. #endif
  27.     year = this_year = 1900 + tmp->tm_year;
  28.     month = this_month = tmp->tm_mon + 1;
  29.     day = this_day = tmp->tm_mday;
  30.     dhour = tmp->tm_hour;
  31.     dminute = tmp->tm_min;
  32.     dsecond = tmp->tm_sec;
  33. }
  34.  
  35. jan1(year)
  36. register year;
  37. {
  38.     register day;
  39.  
  40.     day = 4 + year + (year + 3) / 4;
  41.  
  42.     if (year > 1800) {
  43.         day -= (year - 1701) / 100;
  44.         day += (year - 1601) / 400;
  45.     }
  46.  
  47.     if(year > 1752)
  48.         day += 3;
  49.  
  50.     return(day % 7);
  51. }
  52.  
  53. is_leap_year(year)
  54. int year;
  55. {
  56.     int day;
  57.  
  58.     day = jan1(year);
  59.     return((((jan1(year + 1) + 7 - day) % 7) == 2) ? 1 : 0);
  60. }
  61.  
  62. get_start_day(month, year)
  63. register month, year;
  64. {
  65.     short day, i;
  66.  
  67.     day = jan1(year);
  68.  
  69.     for (i = 1; i < month; i++) {
  70.         day = (day + days_in(i, year)) % 7;
  71.     }
  72.     return(day);
  73. }
  74.  
  75. days_in(month, year)
  76. register month, year;
  77. {
  78.     int days;
  79.  
  80.     switch(month) {
  81.     case 1:
  82.     case 3:
  83.     case 5:
  84.     case 7:
  85.     case 8:
  86.     case 10:
  87.     case 12:
  88.         days = 31;
  89.         break;
  90.     case 4:
  91.     case 6:
  92.     case 9:
  93.     case 11:
  94.         days = 30;
  95.         break;
  96.     case 2:
  97.         days = 28 + is_leap_year(year);
  98.         break;
  99.     }
  100.     return(days);
  101. }
  102.  
  103. is_passed_event(event)
  104. struct event_rec *event;
  105. {
  106.     if (event->monthly || event->yearly || event->every ||
  107.         (event->event_year > this_year)) {
  108.         return(0);
  109.     }
  110.     if (event->event_year < this_year) {
  111.         return(1);
  112.     }
  113.     /* now we know it's this year */
  114.     if (event->event_month > this_month) {
  115.         return(0);
  116.     }
  117.     if (event->event_month < this_month) {
  118.         return(1);
  119.     }
  120.     /* now we know it's this month */
  121.     if (event->event_day < this_day) {
  122.         return(1);
  123.     }
  124.     return(0);
  125. }
  126.  
  127. is_before(m, d, y, month, day, year)
  128. register m, d, y, month, day, year;
  129. {
  130.     if (y < year) {
  131.         return(1);
  132.     }
  133.     if (y > year) {
  134.         return(0);
  135.     }
  136.     if (m < month) {
  137.         return(1);
  138.     }
  139.     if (m > month) {
  140.         return(0);
  141.     }
  142.     if (d < day) {
  143.         return(1);
  144.     }
  145.     return(0);
  146. }
  147.  
  148. has_smtwtfs(smtwtfs)
  149. register char *smtwtfs;
  150. {
  151.     register i;
  152.  
  153.     for (i = 0; i < 7; i++) {
  154.         if (smtwtfs[i]) {
  155.             return(1);
  156.         }
  157.     }
  158.     return(0);
  159. }
  160.  
  161. event_matches_date(event)
  162. register struct event_rec *event;
  163. {
  164.     short last;
  165.     int n;
  166.     /* check if current date is before start date of event */
  167.  
  168.     if (is_before(month, day, year, event->event_month, event->event_day,
  169.         event->event_year)) {
  170.         return(0);
  171.     }
  172.  
  173.     /* one time events */
  174.  
  175.     if ((event->event_year == year) && (event->event_month == month) &&
  176.         (event->event_day == day) && !event->every &&
  177.         !event->nth_is_on && !event->last) {
  178.         return(1);
  179.     }
  180.  
  181.     /* once monthly or once yearly events */
  182.  
  183.     if (!event->every && !event->nth_is_on && !event->last) {
  184.         if (event->monthly) {
  185.             if (event->event_day == day) {
  186.                 return(1);
  187.             }
  188.         } else if (event->yearly) {
  189.             if ((event->event_month == month) &&
  190.                 (event->event_day == day)) {
  191.                 return(1);
  192.             }
  193.         }
  194.     }
  195.     if ((event->monthly || event->yearly) && !event->every &&
  196.         !event->nth_is_on && !event->last) {
  197.         if (event->monthly && (event->event_day == day)) {
  198.             return(1);
  199.         }
  200.         if (event->yearly && (event->event_month == month) &&
  201.             (event->event_day == day)) {
  202.             return(1);
  203.         }
  204.     }
  205.     if (!event->smtwtfs[(day-1+start_day)%7]) {
  206.         return(0);
  207.     }
  208.     /* everys */
  209.  
  210.     if (event->every) {
  211.  
  212.         /* every smtwtf */
  213.  
  214.         if (!event->nth_is_on && !event->last) {
  215. EVDAY:              if (event->smtwtfs[((day-1+start_day)%7)]) {
  216.             return(1);
  217.             }
  218.             return(0);
  219.         }
  220.  
  221.         /* every monthly/yearly */
  222.  
  223.         if (event->monthly || event->yearly) {
  224.             /* every monthly not-1st2nd3rdlast */
  225.             if (!event->nth_is_on && !event->last) {
  226.                 goto EVDAY;
  227.             }
  228.  
  229.             /* every monthly/yearly with one of 1st2nd3rdlast */
  230.  
  231.             if (event->nth_is_on) {
  232.                 if (event->monthly &&
  233.                     (nth_smtwtfs_of_month(&last) ==
  234.                     (event->nth - 1))) {
  235.                     return(1);
  236.                 }
  237.                 if (event->yearly &&
  238.                     (nth_smtwtfs_of_year(&last) ==
  239.                     (event->nth - 1))) {
  240.                     return(1);
  241.                 }
  242.             }
  243.             if (event->last) {
  244.                 if (event->monthly) {
  245.                     nth_smtwtfs_of_month(&last);
  246.                     if (last) {
  247.                         return(1);
  248.                     }
  249.                 }
  250.                 if (event->yearly) {
  251.                     nth_smtwtfs_of_year(&last);
  252.                     if (last) {
  253.                         return(1);
  254.                     }
  255.                 }
  256.             }
  257.  
  258.         } else {
  259.             /* every not-monthly and not-yearly */
  260.             if (!event->nth_is_on && !event->last) {
  261.                 goto EVDAY;
  262.             }
  263.             /* every nth/dayofweek */
  264.             if (event->nth == 1) {
  265.                 return(1);
  266.             }
  267.             n = how_many_since(event->event_month,
  268.                 event->event_day, event->event_year);
  269.             if ((n % (event->nth)) == 1) {
  270.                 return(1);
  271.             }
  272.         }
  273.     }
  274.     return(0);
  275. }
  276.  
  277. nth_smtwtfs_of_month(last)
  278. short *last;
  279. {
  280.     *last = ((day + 7) > days) ? 1 : 0;
  281.     return((day - 1) / 7);
  282. }
  283.  
  284. nth_smtwtfs_of_year(last)
  285. short *last;
  286. {
  287.     short days, i;
  288.  
  289.     for (i = 1, days = day; i < month; i++) {
  290.         days += days_in(i, year);
  291.     }
  292.  
  293.     *last = ((days + 7) > (365 + is_leap_year(year))) ? 1 : 0;
  294.     return((days-1) / 7);
  295. }
  296.  
  297. how_many_since(m, d, y)
  298. int m, d, y;
  299. {
  300.     register total_days_passed;
  301.     int i;
  302.  
  303.     if (y < year) {
  304.         total_days_passed = 0;
  305.         for (i = m; i <= 12; i++) {
  306.             total_days_passed += days_in(i, y);
  307.         }
  308.         total_days_passed -= (d - 1);
  309.         for (i = (y + 1); i < year; i++) {
  310.             total_days_passed += (365 + is_leap_year(i));
  311.         }
  312.         for (i = 1; i < month; i++) {
  313.             total_days_passed += days_in(i, year);
  314.         }
  315.         total_days_passed += day;
  316.     } else if (m == month) {
  317.         total_days_passed = day - d + 1;
  318.     } else {
  319.         total_days_passed = 1 - d;
  320.         for (i = m; i < month; i++) {
  321.             total_days_passed += days_in(i, year);
  322.         }
  323.         total_days_passed += day;
  324.     }
  325.     return((((total_days_passed - 1) / 7) + 1));
  326. }
  327.  
  328. days_since_jan1(month, day, year)
  329. {
  330.     int days = 0, i;
  331.  
  332.     for (i = 1; i < month; i++) {
  333.         days += days_in(i, year);
  334.     }
  335.     days += day;
  336.     return(days);
  337. }
  338.