icuSources/samples/cal/cal.c

   1 /*
   2 **********************************************************************
   3 * Copyright (C) 1998-2012, International Business Machines Corporation
   4 * and others.  All Rights Reserved.
   5 **********************************************************************
   6 *
   7 * File date.c
   8 *
   9 * Modification History:
  10 *
  11 *   Date        Name        Description
  12 *   06/16/99    stephen     Creation.
  13 *******************************************************************************
  14 */
  15
  16 #include <stdio.h>
  17 #include <string.h>
  18 #include <stdlib.h>
  19
  20 #include "unicode/uloc.h"
  21 #include "unicode/udat.h"
  22 #include "unicode/ucal.h"
  23 #include "unicode/ustring.h"
  24 #include "unicode/uclean.h"
  25
  26 #include "uprint.h"
  27
  28 #if UCONFIG_NO_FORMATTING
  29
  30 int main(int argc, char **argv)
  31 {
  32   printf("%s: Sorry, UCONFIG_NO_FORMATTING was turned on (see uconfig.h). No formatting can be done. \n", argv[0]);
  33   return 0;
  34 }
  35 #else
  36
  37
  38 /* Protos */
  39 static void usage(void);
  40
  41 static void version(void);
  42
  43 static void cal(int32_t month, int32_t year,
  44                 UBool useLongNames, UErrorCode *status);
  45
  46 static void get_symbols(const UDateFormat *fmt,
  47                         UDateFormatSymbolType type,
  48                         UChar *array[],
  49                         int32_t arrayLength,
  50                         int32_t lowestIndex,
  51                         int32_t firstIndex,
  52                         UErrorCode *status);
  53
  54 static void free_symbols(UChar *array[],
  55                          int32_t arrayLength);
  56
  57 static void get_days(const UDateFormat *fmt,
  58                      UChar *days [], UBool useLongNames,
  59                      int32_t fdow, UErrorCode *status);
  60
  61 static void free_days(UChar *days[]);
  62
  63 static void get_months(const UDateFormat *fmt,
  64                        UChar *months [], UBool useLongNames,
  65                        UErrorCode *status);
  66
  67 static void free_months(UChar *months[]);
  68
  69 static void indent(int32_t count, FILE *f);
  70
  71 static void print_days(UChar *days [], FILE *f, UErrorCode *status);
  72
  73 static void  print_month(UCalendar *c,
  74                          UChar *days [],
  75                          UBool useLongNames, int32_t fdow,
  76                          UErrorCode *status);
  77
  78 static void  print_year(UCalendar *c,
  79                         UChar *days [], UChar *months [],
  80                         UBool useLongNames, int32_t fdow,
  81                         UErrorCode *status);
  82
  83 /* The version of cal */
  84 #define CAL_VERSION "1.0"
  85
  86 /* Number of days in a week */
  87 #define DAY_COUNT 7
  88
  89 /* Number of months in a year (yes, 13) */
  90 #define MONTH_COUNT 13
  91
  92 /* Separation between months in year view */
  93 #define MARGIN_WIDTH 4
  94
  95 /* Size of stack buffers */
  96 #define BUF_SIZE 64
  97
  98 /* Patterm string - "MMM yyyy" */
  99 static const UChar sShortPat [] = { 0x004D, 0x004D, 0x004D, 0x0020,
 100 0x0079, 0x0079, 0x0079, 0x0079 };
 101 /* Pattern string - "MMMM yyyy" */
 102 static const UChar sLongPat [] = { 0x004D, 0x004D, 0x004D, 0x004D, 0x0020,
 103 0x0079, 0x0079, 0x0079, 0x0079 };
 104
 105
 106 int
 107 main(int argc,
 108      char **argv)
 109 {
 110     int printUsage = 0;
 111     int printVersion = 0;
 112     UBool useLongNames = 0;
 113     int optInd = 1;
 114     char *arg;
 115     int32_t month = -1, year = -1;
 116     UErrorCode status = U_ZERO_ERROR;
 117
 118
 119     /* parse the options */
 120     for(optInd = 1; optInd < argc; ++optInd) {
 121         arg = argv[optInd];
 122
 123         /* version info */
 124         if(strcmp(arg, "-v") == 0 || strcmp(arg, "--version") == 0) {
 125             printVersion = 1;
 126         }
 127         /* usage info */
 128         else if(strcmp(arg, "-h") == 0 || strcmp(arg, "--help") == 0) {
 129             printUsage = 1;
 130         }
 131         /* use long day names */
 132         else if(strcmp(arg, "-l") == 0 || strcmp(arg, "--long") == 0) {
 133             useLongNames = 1;
 134         }
 135         /* POSIX.1 says all arguments after -- are not options */
 136         else if(strcmp(arg, "--") == 0) {
 137             /* skip the -- */
 138             ++optInd;
 139             break;
 140         }
 141         /* unrecognized option */
 142         else if(strncmp(arg, "-", strlen("-")) == 0) {
 143             printf("cal: invalid option -- %s\n", arg+1);
 144             printUsage = 1;
 145         }
 146         /* done with options, display cal */
 147         else {
 148             break;
 149         }
 150     }
 151
 152     /* Get the month and year to display, if specified */
 153     if(optInd != argc) {
 154
 155         /* Month and year specified */
 156         if(argc - optInd == 2) {
 157             sscanf(argv[optInd], "%d", (int*)&month);
 158             sscanf(argv[optInd + 1], "%d", (int*)&year);
 159
 160             /* Make sure the month value is legal */
 161             if(month < 0 || month > 12) {
 162                 printf("icucal: Bad value for month -- %d\n", (int)month);
 163
 164                 /* Display usage */
 165                 printUsage = 1;
 166             }
 167
 168             /* Adjust because months are 0-based */
 169             --month;
 170         }
 171         /* Only year specified */
 172         else {
 173             sscanf(argv[optInd], "%d", (int*)&year);
 174         }
 175     }
 176
 177     /* print usage info */
 178     if(printUsage) {
 179         usage();
 180         return 0;
 181     }
 182
 183     /* print version info */
 184     if(printVersion) {
 185         version();
 186         return 0;
 187     }
 188
 189     /* print the cal */
 190     cal(month, year, useLongNames, &status);
 191
 192     /* ICU cleanup.  Deallocate any memory ICU may be holding.  */
 193     u_cleanup();
 194
 195     return (U_FAILURE(status) ? 1 : 0);
 196 }
 197
 198 /* Usage information */
 199 static void
 200 usage()
 201 {
 202     puts("Usage: icucal [OPTIONS] [[MONTH] YEAR]");
 203     puts("");
 204     puts("Options:");
 205     puts("  -h, --help        Print this message and exit.");
 206     puts("  -v, --version     Print the version number of cal and exit.");
 207     puts("  -l, --long        Use long names.");
 208     puts("");
 209     puts("Arguments (optional):");
 210     puts("  MONTH             An integer (1-12) indicating the month to display");
 211     puts("  YEAR              An integer indicating the year to display");
 212     puts("");
 213     puts("For an interesting calendar, look at October 1582");
 214 }
 215
 216 /* Version information */
 217 static void
 218 version()
 219 {
 220     printf("icucal version %s (ICU version %s), created by Stephen F. Booth.\n",
 221         CAL_VERSION, U_ICU_VERSION);
 222     puts(U_COPYRIGHT_STRING);
 223 }
 224
 225 static void
 226 cal(int32_t month,
 227     int32_t year,
 228     UBool useLongNames,
 229     UErrorCode *status)
 230 {
 231     UCalendar *c;
 232     UChar *days [DAY_COUNT];
 233     UChar *months [MONTH_COUNT];
 234     int32_t fdow;
 235
 236     if(U_FAILURE(*status)) return;
 237
 238     /* Create a new calendar */
 239     c = ucal_open(0, -1, uloc_getDefault(), UCAL_TRADITIONAL, status);
 240
 241     /* Determine if we are printing a calendar for one month or for a year */
 242
 243     /* Print an entire year */
 244     if(month == -1 && year != -1) {
 245
 246         /* Set the year */
 247         ucal_set(c, UCAL_YEAR, year);
 248
 249         /* Determine the first day of the week */
 250         fdow = ucal_getAttribute(c, UCAL_FIRST_DAY_OF_WEEK);
 251
 252         /* Print the calendar for the year */
 253         print_year(c, days, months, useLongNames, fdow, status);
 254     }
 255
 256     /* Print only one month */
 257     else {
 258
 259         /* Set the month and the year, if specified */
 260         if(month != -1)
 261             ucal_set(c, UCAL_MONTH, month);
 262         if(year != -1)
 263             ucal_set(c, UCAL_YEAR, year);
 264
 265         /* Determine the first day of the week */
 266         fdow = ucal_getAttribute(c, UCAL_FIRST_DAY_OF_WEEK);
 267
 268         /* Print the calendar for the month */
 269         print_month(c, days, useLongNames, fdow, status);
 270     }
 271
 272     /* Clean up */
 273     ucal_close(c);
 274 }
 275 /*
 276  * Get a set of DateFormat symbols of a given type.
 277  *
 278  * lowestIndex is the index of the first symbol to fetch.
 279  * (e.g. it will be one to fetch day names, since Sunday is
 280  *  day 1 *not* day 0.)
 281  *
 282  * firstIndex is the index of the symbol to place first in
 283  * the output array. This is used when fetching day names
 284  * in locales where the week doesn't start on Sunday.
 285  */
 286 static void get_symbols(const UDateFormat *fmt,
 287                         UDateFormatSymbolType type,
 288                         UChar *array[],
 289                         int32_t arrayLength,
 290                         int32_t lowestIndex,
 291                         int32_t firstIndex,
 292                         UErrorCode *status)
 293 {
 294     int32_t count, i;
 295
 296     if (U_FAILURE(*status)) {
 297         return;
 298     }
 299
 300     count = udat_countSymbols(fmt, type);
 301
 302     if(count != arrayLength + lowestIndex) {
 303         return;
 304     }
 305
 306     for(i = 0; i < arrayLength; i++) {
 307         int32_t idx = (i + firstIndex) % arrayLength;
 308         int32_t size = 1 + udat_getSymbols(fmt, type, idx + lowestIndex, NULL, 0, status);
 309
 310         array[idx] = (UChar *) malloc(sizeof(UChar) * size);
 311
 312         *status = U_ZERO_ERROR;
 313         udat_getSymbols(fmt, type, idx + lowestIndex, array[idx], size, status);
 314     }
 315 }
 316
 317 /* Free the symbols allocated by get_symbols(). */
 318 static void free_symbols(UChar *array[],
 319                          int32_t arrayLength)
 320 {
 321     int32_t i;
 322
 323     for(i = 0; i < arrayLength; i++) {
 324         free(array[i]);
 325     }
 326 }
 327
 328 /* Get the day names for the specified locale, in either long or short
 329 form.  Also, reorder the days so that they are in the proper order
 330 for the locale (not all locales begin weeks on Sunday; in France,
 331 weeks start on Monday) */
 332 static void
 333 get_days(const UDateFormat *fmt,
 334          UChar *days [],
 335          UBool useLongNames,
 336          int32_t fdow,
 337          UErrorCode *status)
 338 {
 339     UDateFormatSymbolType dayType = (useLongNames ? UDAT_WEEKDAYS : UDAT_SHORT_WEEKDAYS);
 340
 341     if(U_FAILURE(*status))
 342         return;
 343
 344     /* fdow is 1-based */
 345     --fdow;
 346
 347     get_symbols(fmt, dayType, days, DAY_COUNT, 1, fdow, status);
 348 }
 349
 350 static void free_days(UChar *days[])
 351 {
 352     free_symbols(days, DAY_COUNT);
 353 }
 354
 355 /* Get the month names for the specified locale, in either long or
 356 short form. */
 357 static void
 358 get_months(const UDateFormat *fmt,
 359            UChar *months [],
 360            UBool useLongNames,
 361            UErrorCode *status)
 362 {
 363     UDateFormatSymbolType monthType = (useLongNames ? UDAT_MONTHS : UDAT_SHORT_MONTHS);
 364
 365     if(U_FAILURE(*status))
 366         return;
 367
 368     get_symbols(fmt, monthType, months, MONTH_COUNT - 1, 0, 0, status); /* some locales have 13 months, no idea why */
 369 }
 370
 371 static void free_months(UChar *months[])
 372 {
 373     free_symbols(months, MONTH_COUNT - 1);
 374 }
 375
 376 /* Indent a certain number of spaces */
 377 static void
 378 indent(int32_t count,
 379        FILE *f)
 380 {
 381     char c [BUF_SIZE];
 382
 383     if(count <= 0)
 384     {
 385         return;
 386     }
 387
 388     if(count < BUF_SIZE) {
 389         memset(c, (int)' ', count);
 390         fwrite(c, sizeof(char), count, f);
 391     }
 392     else {
 393         int32_t i;
 394         for(i = 0; i < count; ++i)
 395             putc(' ', f);
 396     }
 397 }
 398
 399 /* Print the days */
 400 static void
 401 print_days(UChar *days [],
 402            FILE *f,
 403            UErrorCode *status)
 404 {
 405     int32_t i;
 406
 407     if(U_FAILURE(*status)) return;
 408
 409     /* Print the day names */
 410     for(i = 0; i < DAY_COUNT; ++i) {
 411         uprint(days[i], f, status);
 412         putc(' ', f);
 413     }
 414 }
 415
 416 /* Print out a calendar for c's current month */
 417 static void
 418 print_month(UCalendar *c,
 419             UChar *days [],
 420             UBool useLongNames,
 421             int32_t fdow,
 422             UErrorCode *status)
 423 {
 424     int32_t width, pad, i, day;
 425     int32_t lens [DAY_COUNT];
 426     int32_t firstday, current;
 427     UNumberFormat *nfmt;
 428     UDateFormat *dfmt;
 429     UChar s [BUF_SIZE];
 430     const UChar *pat = (useLongNames ? sLongPat : sShortPat);
 431     int32_t len = (useLongNames ? 9 : 8);
 432
 433     if(U_FAILURE(*status)) return;
 434
 435
 436     /* ========== Generate the header containing the month and year */
 437
 438     /* Open a formatter with a month and year only pattern */
 439     dfmt = udat_open(UDAT_PATTERN,UDAT_PATTERN,NULL,NULL,0,pat, len,status);
 440
 441     /* Format the date */
 442     udat_format(dfmt, ucal_getMillis(c, status), s, BUF_SIZE, 0, status);
 443
 444
 445     /* ========== Get the day names */
 446     get_days(dfmt, days, useLongNames, fdow, status);
 447
 448     /* ========== Print the header */
 449
 450     /* Calculate widths for justification */
 451     width = 6; /* 6 spaces, 1 between each day name */
 452     for(i = 0; i < DAY_COUNT; ++i) {
 453         lens[i] = u_strlen(days[i]);
 454         width += lens[i];
 455     }
 456
 457     /* Print the header, centered among the day names */
 458     pad = width - u_strlen(s);
 459     indent(pad / 2, stdout);
 460     uprint(s, stdout, status);
 461     putc('\n', stdout);
 462
 463
 464     /* ========== Print the day names */
 465
 466     print_days(days, stdout, status);
 467     putc('\n', stdout);
 468
 469
 470     /* ========== Print the calendar */
 471
 472     /* Get the first of the month */
 473     ucal_set(c, UCAL_DATE, 1);
 474     firstday = ucal_get(c, UCAL_DAY_OF_WEEK, status);
 475
 476     /* The day of the week for the first day of the month is based on
 477     1-based days of the week, which were also reordered when placed
 478     in the days array.  Account for this here by offsetting by the
 479     first day of the week for the locale, which is also 1-based. */
 480     firstday -= fdow;
 481
 482     /* Open the formatter */
 483     nfmt = unum_open(UNUM_DECIMAL, NULL,0,NULL,NULL, status);
 484
 485     /* Indent the correct number of spaces for the first week */
 486     current = firstday;
 487     if(current < 0)
 488     {
 489        current += 7;
 490     }
 491     for(i = 0; i < current; ++i)
 492         indent(lens[i] + 1, stdout);
 493
 494     /* Finally, print out the days */
 495     day = ucal_get(c, UCAL_DATE, status);
 496     do {
 497
 498         /* Format the current day string */
 499         unum_format(nfmt, day, s, BUF_SIZE, 0, status);
 500
 501         /* Calculate the justification and indent */
 502         pad = lens[current] - u_strlen(s);
 503         indent(pad, stdout);
 504
 505         /* Print the day number out, followed by a space */
 506         uprint(s, stdout, status);
 507         putc(' ', stdout);
 508
 509         /* Update the current day */
 510         ++current;
 511         current %= DAY_COUNT;
 512
 513         /* If we're at day 0 (first day of the week), insert a newline */
 514         if(current == 0) {
 515             putc('\n', stdout);
 516         }
 517
 518         /* Go to the next day */
 519         ucal_add(c, UCAL_DATE, 1, status);
 520         day = ucal_get(c, UCAL_DATE, status);
 521
 522     } while(day != 1);
 523
 524     /* Output a trailing newline */
 525     putc('\n', stdout);
 526
 527     /* Clean up */
 528     free_days(days);
 529     unum_close(nfmt);
 530     udat_close(dfmt);
 531 }
 532
 533 /* Print out a calendar for c's current year */
 534 static void
 535 print_year(UCalendar *c,
 536            UChar *days [],
 537            UChar *months [],
 538            UBool useLongNames,
 539            int32_t fdow,
 540            UErrorCode *status)
 541 {
 542     int32_t width, pad, i, j;
 543     int32_t lens [DAY_COUNT];
 544     UNumberFormat *nfmt;
 545     UDateFormat *dfmt;
 546     UChar s [BUF_SIZE];
 547     const UChar pat [] = { 0x0079, 0x0079, 0x0079, 0x0079 };
 548     int32_t len = 4;
 549     UCalendar  *left_cal, *right_cal;
 550     int32_t left_day, right_day;
 551     int32_t left_firstday, right_firstday, left_current, right_current;
 552     int32_t left_month, right_month;
 553
 554     if(U_FAILURE(*status)) return;
 555
 556     /* Alias */
 557     left_cal = c;
 558
 559     /* ========== Generate the header containing the year (only) */
 560
 561     /* Open a formatter with a month and year only pattern */
 562     dfmt = udat_open(UDAT_PATTERN,UDAT_PATTERN,NULL,NULL,0,pat, len, status);
 563
 564     /* Format the date */
 565     udat_format(dfmt, ucal_getMillis(left_cal, status), s, BUF_SIZE, 0, status);
 566
 567     /* ========== Get the month and day names */
 568     get_days(dfmt, days, useLongNames, fdow, status);
 569     get_months(dfmt, months, useLongNames, status);
 570
 571     /* ========== Print the header, centered */
 572
 573     /* Calculate widths for justification */
 574     width = 6; /* 6 spaces, 1 between each day name */
 575     for(i = 0; i < DAY_COUNT; ++i) {
 576         lens[i] = u_strlen(days[i]);
 577         width += lens[i];
 578     }
 579
 580     /* width is the width for 1 calendar; we are displaying in 2 cols
 581     with MARGIN_WIDTH spaces between months */
 582
 583     /* Print the header, centered among the day names */
 584     pad = 2 * width + MARGIN_WIDTH - u_strlen(s);
 585     indent(pad / 2, stdout);
 586     uprint(s, stdout, status);
 587     putc('\n', stdout);
 588     putc('\n', stdout);
 589
 590     /* Generate a copy of the calendar to use */
 591     right_cal = ucal_open(0, -1, uloc_getDefault(), UCAL_TRADITIONAL, status);
 592     ucal_setMillis(right_cal, ucal_getMillis(left_cal, status), status);
 593
 594     /* Open the formatter */
 595     nfmt = unum_open(UNUM_DECIMAL,NULL, 0,NULL,NULL, status);
 596
 597     /* ========== Calculate and display the months, two at a time */
 598     for(i = 0; i < MONTH_COUNT - 1; i += 2) {
 599
 600         /* Print the month names for the two current months */
 601         pad = width - u_strlen(months[i]);
 602         indent(pad / 2, stdout);
 603         uprint(months[i], stdout, status);
 604         indent(pad / 2 + MARGIN_WIDTH, stdout);
 605         pad = width - u_strlen(months[i + 1]);
 606         indent(pad / 2, stdout);
 607         uprint(months[i + 1], stdout, status);
 608         putc('\n', stdout);
 609
 610         /* Print the day names, twice  */
 611         print_days(days, stdout, status);
 612         indent(MARGIN_WIDTH, stdout);
 613         print_days(days, stdout, status);
 614         putc('\n', stdout);
 615
 616         /* Setup the two calendars */
 617         ucal_set(left_cal, UCAL_MONTH, i);
 618         ucal_set(left_cal, UCAL_DATE, 1);
 619         ucal_set(right_cal, UCAL_MONTH, i + 1);
 620         ucal_set(right_cal, UCAL_DATE, 1);
 621
 622         left_firstday = ucal_get(left_cal, UCAL_DAY_OF_WEEK, status);
 623         right_firstday = ucal_get(right_cal, UCAL_DAY_OF_WEEK, status);
 624
 625         /* The day of the week for the first day of the month is based on
 626         1-based days of the week.  However, the days were reordered
 627         when placed in the days array.  Account for this here by
 628         offsetting by the first day of the week for the locale, which
 629         is also 1-based. */
 630
 631         /* We need to mod by DAY_COUNT since fdow can be > firstday.  IE,
 632         if fdow = 2 = Monday (like in France) and the first day of the
 633         month is a 1 = Sunday, we want firstday to be 6, not -1 */
 634         left_firstday += (DAY_COUNT - fdow);
 635         left_firstday %= DAY_COUNT;
 636
 637         right_firstday += (DAY_COUNT - fdow);
 638         right_firstday %= DAY_COUNT;
 639
 640         left_current = left_firstday;
 641         right_current = right_firstday;
 642
 643         left_day = ucal_get(left_cal, UCAL_DATE, status);
 644         right_day = ucal_get(right_cal, UCAL_DATE, status);
 645
 646         left_month = ucal_get(left_cal, UCAL_MONTH, status);
 647         right_month = ucal_get(right_cal, UCAL_MONTH, status);
 648
 649         /* Finally, print out the days */
 650         while(left_month == i || right_month == i + 1) {
 651
 652         /* If the left month is finished printing, but the right month
 653         still has days to be printed, indent the width of the days
 654             strings and reset the left calendar's current day to 0 */
 655             if(left_month != i && right_month == i + 1) {
 656                 indent(width + 1, stdout);
 657                 left_current = 0;
 658             }
 659
 660             while(left_month == i) {
 661
 662             /* If the day is the first, indent the correct number of
 663                 spaces for the first week */
 664                 if(left_day == 1) {
 665                     for(j = 0; j < left_current; ++j)
 666                         indent(lens[j] + 1, stdout);
 667                 }
 668
 669                 /* Format the current day string */
 670                 unum_format(nfmt, left_day, s, BUF_SIZE, 0, status);
 671
 672                 /* Calculate the justification and indent */
 673                 pad = lens[left_current] - u_strlen(s);
 674                 indent(pad, stdout);
 675
 676                 /* Print the day number out, followed by a space */
 677                 uprint(s, stdout, status);
 678                 putc(' ', stdout);
 679
 680                 /* Update the current day */
 681                 ++left_current;
 682                 left_current %= DAY_COUNT;
 683
 684                 /* Go to the next day */
 685                 ucal_add(left_cal, UCAL_DATE, 1, status);
 686                 left_day = ucal_get(left_cal, UCAL_DATE, status);
 687
 688                 /* Determine the month */
 689                 left_month = ucal_get(left_cal, UCAL_MONTH, status);
 690
 691                 /* If we're at day 0 (first day of the week), break and go to
 692                 the next month */
 693                 if(left_current == 0) {
 694                     break;
 695                 }
 696             };
 697
 698             /* If the current day isn't 0, indent to make up for missing
 699             days at the end of the month */
 700             if(left_current != 0) {
 701                 for(j = left_current; j < DAY_COUNT; ++j)
 702                     indent(lens[j] + 1, stdout);
 703             }
 704
 705             /* Indent between the two months */
 706             indent(MARGIN_WIDTH, stdout);
 707
 708             while(right_month == i + 1) {
 709
 710             /* If the day is the first, indent the correct number of
 711                 spaces for the first week */
 712                 if(right_day == 1) {
 713                     for(j = 0; j < right_current; ++j)
 714                         indent(lens[j] + 1, stdout);
 715                 }
 716
 717                 /* Format the current day string */
 718                 unum_format(nfmt, right_day, s, BUF_SIZE, 0, status);
 719
 720                 /* Calculate the justification and indent */
 721                 pad = lens[right_current] - u_strlen(s);
 722                 indent(pad, stdout);
 723
 724                 /* Print the day number out, followed by a space */
 725                 uprint(s, stdout, status);
 726                 putc(' ', stdout);
 727
 728                 /* Update the current day */
 729                 ++right_current;
 730                 right_current %= DAY_COUNT;
 731
 732                 /* Go to the next day */
 733                 ucal_add(right_cal, UCAL_DATE, 1, status);
 734                 right_day = ucal_get(right_cal, UCAL_DATE, status);
 735
 736                 /* Determine the month */
 737                 right_month = ucal_get(right_cal, UCAL_MONTH, status);
 738
 739                 /* If we're at day 0 (first day of the week), break out */
 740                 if(right_current == 0) {
 741                     break;
 742                 }
 743
 744             };
 745
 746             /* Output a newline */
 747             putc('\n', stdout);
 748         }
 749
 750         /* Output a trailing newline */
 751         putc('\n', stdout);
 752   }
 753
 754   /* Clean up */
 755   free_months(months);
 756   free_days(days);
 757   udat_close(dfmt);
 758   unum_close(nfmt);
 759   ucal_close(right_cal);
 760 }
 761
 762 #endif