Home | History | Annotate | Download | only in cal
      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
    763