| /* | |
| ********************************************************************** | |
| * Copyright (C) 1998-2012, International Business Machines Corporation | |
| * and others. All Rights Reserved. | |
| ********************************************************************** | |
| * | |
| * File date.c | |
| * | |
| * Modification History: | |
| * | |
| * Date Name Description | |
| * 06/16/99 stephen Creation. | |
| ******************************************************************************* | |
| */ | |
| #include <stdio.h> | |
| #include <string.h> | |
| #include <stdlib.h> | |
| #include "unicode/uloc.h" | |
| #include "unicode/udat.h" | |
| #include "unicode/ucal.h" | |
| #include "unicode/ustring.h" | |
| #include "unicode/uclean.h" | |
| #include "uprint.h" | |
| #if UCONFIG_NO_FORMATTING | |
| int main(int argc, char **argv) | |
| { | |
| printf("%s: Sorry, UCONFIG_NO_FORMATTING was turned on (see uconfig.h). No formatting can be done. \n", argv[0]); | |
| return 0; | |
| } | |
| #else | |
| /* Protos */ | |
| static void usage(void); | |
| static void version(void); | |
| static void cal(int32_t month, int32_t year, | |
| UBool useLongNames, UErrorCode *status); | |
| static void get_symbols(const UDateFormat *fmt, | |
| UDateFormatSymbolType type, | |
| UChar *array[], | |
| int32_t arrayLength, | |
| int32_t lowestIndex, | |
| int32_t firstIndex, | |
| UErrorCode *status); | |
| static void free_symbols(UChar *array[], | |
| int32_t arrayLength); | |
| static void get_days(const UDateFormat *fmt, | |
| UChar *days [], UBool useLongNames, | |
| int32_t fdow, UErrorCode *status); | |
| static void free_days(UChar *days[]); | |
| static void get_months(const UDateFormat *fmt, | |
| UChar *months [], UBool useLongNames, | |
| UErrorCode *status); | |
| static void free_months(UChar *months[]); | |
| static void indent(int32_t count, FILE *f); | |
| static void print_days(UChar *days [], FILE *f, UErrorCode *status); | |
| static void print_month(UCalendar *c, | |
| UChar *days [], | |
| UBool useLongNames, int32_t fdow, | |
| UErrorCode *status); | |
| static void print_year(UCalendar *c, | |
| UChar *days [], UChar *months [], | |
| UBool useLongNames, int32_t fdow, | |
| UErrorCode *status); | |
| /* The version of cal */ | |
| #define CAL_VERSION "1.0" | |
| /* Number of days in a week */ | |
| #define DAY_COUNT 7 | |
| /* Number of months in a year (yes, 13) */ | |
| #define MONTH_COUNT 13 | |
| /* Separation between months in year view */ | |
| #define MARGIN_WIDTH 4 | |
| /* Size of stack buffers */ | |
| #define BUF_SIZE 64 | |
| /* Patterm string - "MMM yyyy" */ | |
| static const UChar sShortPat [] = { 0x004D, 0x004D, 0x004D, 0x0020, | |
| 0x0079, 0x0079, 0x0079, 0x0079 }; | |
| /* Pattern string - "MMMM yyyy" */ | |
| static const UChar sLongPat [] = { 0x004D, 0x004D, 0x004D, 0x004D, 0x0020, | |
| 0x0079, 0x0079, 0x0079, 0x0079 }; | |
| int | |
| main(int argc, | |
| char **argv) | |
| { | |
| int printUsage = 0; | |
| int printVersion = 0; | |
| UBool useLongNames = 0; | |
| int optInd = 1; | |
| char *arg; | |
| int32_t month = -1, year = -1; | |
| UErrorCode status = U_ZERO_ERROR; | |
| /* parse the options */ | |
| for(optInd = 1; optInd < argc; ++optInd) { | |
| arg = argv[optInd]; | |
| /* version info */ | |
| if(strcmp(arg, "-v") == 0 || strcmp(arg, "--version") == 0) { | |
| printVersion = 1; | |
| } | |
| /* usage info */ | |
| else if(strcmp(arg, "-h") == 0 || strcmp(arg, "--help") == 0) { | |
| printUsage = 1; | |
| } | |
| /* use long day names */ | |
| else if(strcmp(arg, "-l") == 0 || strcmp(arg, "--long") == 0) { | |
| useLongNames = 1; | |
| } | |
| /* POSIX.1 says all arguments after -- are not options */ | |
| else if(strcmp(arg, "--") == 0) { | |
| /* skip the -- */ | |
| ++optInd; | |
| break; | |
| } | |
| /* unrecognized option */ | |
| else if(strncmp(arg, "-", strlen("-")) == 0) { | |
| printf("cal: invalid option -- %s\n", arg+1); | |
| printUsage = 1; | |
| } | |
| /* done with options, display cal */ | |
| else { | |
| break; | |
| } | |
| } | |
| /* Get the month and year to display, if specified */ | |
| if(optInd != argc) { | |
| /* Month and year specified */ | |
| if(argc - optInd == 2) { | |
| sscanf(argv[optInd], "%d", (int*)&month); | |
| sscanf(argv[optInd + 1], "%d", (int*)&year); | |
| /* Make sure the month value is legal */ | |
| if(month < 0 || month > 12) { | |
| printf("icucal: Bad value for month -- %d\n", (int)month); | |
| /* Display usage */ | |
| printUsage = 1; | |
| } | |
| /* Adjust because months are 0-based */ | |
| --month; | |
| } | |
| /* Only year specified */ | |
| else { | |
| sscanf(argv[optInd], "%d", (int*)&year); | |
| } | |
| } | |
| /* print usage info */ | |
| if(printUsage) { | |
| usage(); | |
| return 0; | |
| } | |
| /* print version info */ | |
| if(printVersion) { | |
| version(); | |
| return 0; | |
| } | |
| /* print the cal */ | |
| cal(month, year, useLongNames, &status); | |
| /* ICU cleanup. Deallocate any memory ICU may be holding. */ | |
| u_cleanup(); | |
| return (U_FAILURE(status) ? 1 : 0); | |
| } | |
| /* Usage information */ | |
| static void | |
| usage() | |
| { | |
| puts("Usage: icucal [OPTIONS] [[MONTH] YEAR]"); | |
| puts(""); | |
| puts("Options:"); | |
| puts(" -h, --help Print this message and exit."); | |
| puts(" -v, --version Print the version number of cal and exit."); | |
| puts(" -l, --long Use long names."); | |
| puts(""); | |
| puts("Arguments (optional):"); | |
| puts(" MONTH An integer (1-12) indicating the month to display"); | |
| puts(" YEAR An integer indicating the year to display"); | |
| puts(""); | |
| puts("For an interesting calendar, look at October 1582"); | |
| } | |
| /* Version information */ | |
| static void | |
| version() | |
| { | |
| printf("icucal version %s (ICU version %s), created by Stephen F. Booth.\n", | |
| CAL_VERSION, U_ICU_VERSION); | |
| puts(U_COPYRIGHT_STRING); | |
| } | |
| static void | |
| cal(int32_t month, | |
| int32_t year, | |
| UBool useLongNames, | |
| UErrorCode *status) | |
| { | |
| UCalendar *c; | |
| UChar *days [DAY_COUNT]; | |
| UChar *months [MONTH_COUNT]; | |
| int32_t fdow; | |
| if(U_FAILURE(*status)) return; | |
| /* Create a new calendar */ | |
| c = ucal_open(0, -1, uloc_getDefault(), UCAL_TRADITIONAL, status); | |
| /* Determine if we are printing a calendar for one month or for a year */ | |
| /* Print an entire year */ | |
| if(month == -1 && year != -1) { | |
| /* Set the year */ | |
| ucal_set(c, UCAL_YEAR, year); | |
| /* Determine the first day of the week */ | |
| fdow = ucal_getAttribute(c, UCAL_FIRST_DAY_OF_WEEK); | |
| /* Print the calendar for the year */ | |
| print_year(c, days, months, useLongNames, fdow, status); | |
| } | |
| /* Print only one month */ | |
| else { | |
| /* Set the month and the year, if specified */ | |
| if(month != -1) | |
| ucal_set(c, UCAL_MONTH, month); | |
| if(year != -1) | |
| ucal_set(c, UCAL_YEAR, year); | |
| /* Determine the first day of the week */ | |
| fdow = ucal_getAttribute(c, UCAL_FIRST_DAY_OF_WEEK); | |
| /* Print the calendar for the month */ | |
| print_month(c, days, useLongNames, fdow, status); | |
| } | |
| /* Clean up */ | |
| ucal_close(c); | |
| } | |
| /* | |
| * Get a set of DateFormat symbols of a given type. | |
| * | |
| * lowestIndex is the index of the first symbol to fetch. | |
| * (e.g. it will be one to fetch day names, since Sunday is | |
| * day 1 *not* day 0.) | |
| * | |
| * firstIndex is the index of the symbol to place first in | |
| * the output array. This is used when fetching day names | |
| * in locales where the week doesn't start on Sunday. | |
| */ | |
| static void get_symbols(const UDateFormat *fmt, | |
| UDateFormatSymbolType type, | |
| UChar *array[], | |
| int32_t arrayLength, | |
| int32_t lowestIndex, | |
| int32_t firstIndex, | |
| UErrorCode *status) | |
| { | |
| int32_t count, i; | |
| if (U_FAILURE(*status)) { | |
| return; | |
| } | |
| count = udat_countSymbols(fmt, type); | |
| if(count != arrayLength + lowestIndex) { | |
| return; | |
| } | |
| for(i = 0; i < arrayLength; i++) { | |
| int32_t idx = (i + firstIndex) % arrayLength; | |
| int32_t size = 1 + udat_getSymbols(fmt, type, idx + lowestIndex, NULL, 0, status); | |
| array[idx] = (UChar *) malloc(sizeof(UChar) * size); | |
| *status = U_ZERO_ERROR; | |
| udat_getSymbols(fmt, type, idx + lowestIndex, array[idx], size, status); | |
| } | |
| } | |
| /* Free the symbols allocated by get_symbols(). */ | |
| static void free_symbols(UChar *array[], | |
| int32_t arrayLength) | |
| { | |
| int32_t i; | |
| for(i = 0; i < arrayLength; i++) { | |
| free(array[i]); | |
| } | |
| } | |
| /* Get the day names for the specified locale, in either long or short | |
| form. Also, reorder the days so that they are in the proper order | |
| for the locale (not all locales begin weeks on Sunday; in France, | |
| weeks start on Monday) */ | |
| static void | |
| get_days(const UDateFormat *fmt, | |
| UChar *days [], | |
| UBool useLongNames, | |
| int32_t fdow, | |
| UErrorCode *status) | |
| { | |
| UDateFormatSymbolType dayType = (useLongNames ? UDAT_WEEKDAYS : UDAT_SHORT_WEEKDAYS); | |
| if(U_FAILURE(*status)) | |
| return; | |
| /* fdow is 1-based */ | |
| --fdow; | |
| get_symbols(fmt, dayType, days, DAY_COUNT, 1, fdow, status); | |
| } | |
| static void free_days(UChar *days[]) | |
| { | |
| free_symbols(days, DAY_COUNT); | |
| } | |
| /* Get the month names for the specified locale, in either long or | |
| short form. */ | |
| static void | |
| get_months(const UDateFormat *fmt, | |
| UChar *months [], | |
| UBool useLongNames, | |
| UErrorCode *status) | |
| { | |
| UDateFormatSymbolType monthType = (useLongNames ? UDAT_MONTHS : UDAT_SHORT_MONTHS); | |
| if(U_FAILURE(*status)) | |
| return; | |
| get_symbols(fmt, monthType, months, MONTH_COUNT - 1, 0, 0, status); /* some locales have 13 months, no idea why */ | |
| } | |
| static void free_months(UChar *months[]) | |
| { | |
| free_symbols(months, MONTH_COUNT - 1); | |
| } | |
| /* Indent a certain number of spaces */ | |
| static void | |
| indent(int32_t count, | |
| FILE *f) | |
| { | |
| char c [BUF_SIZE]; | |
| if(count <= 0) | |
| { | |
| return; | |
| } | |
| if(count < BUF_SIZE) { | |
| memset(c, (int)' ', count); | |
| fwrite(c, sizeof(char), count, f); | |
| } | |
| else { | |
| int32_t i; | |
| for(i = 0; i < count; ++i) | |
| putc(' ', f); | |
| } | |
| } | |
| /* Print the days */ | |
| static void | |
| print_days(UChar *days [], | |
| FILE *f, | |
| UErrorCode *status) | |
| { | |
| int32_t i; | |
| if(U_FAILURE(*status)) return; | |
| /* Print the day names */ | |
| for(i = 0; i < DAY_COUNT; ++i) { | |
| uprint(days[i], f, status); | |
| putc(' ', f); | |
| } | |
| } | |
| /* Print out a calendar for c's current month */ | |
| static void | |
| print_month(UCalendar *c, | |
| UChar *days [], | |
| UBool useLongNames, | |
| int32_t fdow, | |
| UErrorCode *status) | |
| { | |
| int32_t width, pad, i, day; | |
| int32_t lens [DAY_COUNT]; | |
| int32_t firstday, current; | |
| UNumberFormat *nfmt; | |
| UDateFormat *dfmt; | |
| UChar s [BUF_SIZE]; | |
| const UChar *pat = (useLongNames ? sLongPat : sShortPat); | |
| int32_t len = (useLongNames ? 9 : 8); | |
| if(U_FAILURE(*status)) return; | |
| /* ========== Generate the header containing the month and year */ | |
| /* Open a formatter with a month and year only pattern */ | |
| dfmt = udat_open(UDAT_PATTERN,UDAT_PATTERN,NULL,NULL,0,pat, len,status); | |
| /* Format the date */ | |
| udat_format(dfmt, ucal_getMillis(c, status), s, BUF_SIZE, 0, status); | |
| /* ========== Get the day names */ | |
| get_days(dfmt, days, useLongNames, fdow, status); | |
| /* ========== Print the header */ | |
| /* Calculate widths for justification */ | |
| width = 6; /* 6 spaces, 1 between each day name */ | |
| for(i = 0; i < DAY_COUNT; ++i) { | |
| lens[i] = u_strlen(days[i]); | |
| width += lens[i]; | |
| } | |
| /* Print the header, centered among the day names */ | |
| pad = width - u_strlen(s); | |
| indent(pad / 2, stdout); | |
| uprint(s, stdout, status); | |
| putc('\n', stdout); | |
| /* ========== Print the day names */ | |
| print_days(days, stdout, status); | |
| putc('\n', stdout); | |
| /* ========== Print the calendar */ | |
| /* Get the first of the month */ | |
| ucal_set(c, UCAL_DATE, 1); | |
| firstday = ucal_get(c, UCAL_DAY_OF_WEEK, status); | |
| /* The day of the week for the first day of the month is based on | |
| 1-based days of the week, which were also reordered when placed | |
| in the days array. Account for this here by offsetting by the | |
| first day of the week for the locale, which is also 1-based. */ | |
| firstday -= fdow; | |
| /* Open the formatter */ | |
| nfmt = unum_open(UNUM_DECIMAL, NULL,0,NULL,NULL, status); | |
| /* Indent the correct number of spaces for the first week */ | |
| current = firstday; | |
| if(current < 0) | |
| { | |
| current += 7; | |
| } | |
| for(i = 0; i < current; ++i) | |
| indent(lens[i] + 1, stdout); | |
| /* Finally, print out the days */ | |
| day = ucal_get(c, UCAL_DATE, status); | |
| do { | |
| /* Format the current day string */ | |
| unum_format(nfmt, day, s, BUF_SIZE, 0, status); | |
| /* Calculate the justification and indent */ | |
| pad = lens[current] - u_strlen(s); | |
| indent(pad, stdout); | |
| /* Print the day number out, followed by a space */ | |
| uprint(s, stdout, status); | |
| putc(' ', stdout); | |
| /* Update the current day */ | |
| ++current; | |
| current %= DAY_COUNT; | |
| /* If we're at day 0 (first day of the week), insert a newline */ | |
| if(current == 0) { | |
| putc('\n', stdout); | |
| } | |
| /* Go to the next day */ | |
| ucal_add(c, UCAL_DATE, 1, status); | |
| day = ucal_get(c, UCAL_DATE, status); | |
| } while(day != 1); | |
| /* Output a trailing newline */ | |
| putc('\n', stdout); | |
| /* Clean up */ | |
| free_days(days); | |
| unum_close(nfmt); | |
| udat_close(dfmt); | |
| } | |
| /* Print out a calendar for c's current year */ | |
| static void | |
| print_year(UCalendar *c, | |
| UChar *days [], | |
| UChar *months [], | |
| UBool useLongNames, | |
| int32_t fdow, | |
| UErrorCode *status) | |
| { | |
| int32_t width, pad, i, j; | |
| int32_t lens [DAY_COUNT]; | |
| UNumberFormat *nfmt; | |
| UDateFormat *dfmt; | |
| UChar s [BUF_SIZE]; | |
| const UChar pat [] = { 0x0079, 0x0079, 0x0079, 0x0079 }; | |
| int32_t len = 4; | |
| UCalendar *left_cal, *right_cal; | |
| int32_t left_day, right_day; | |
| int32_t left_firstday, right_firstday, left_current, right_current; | |
| int32_t left_month, right_month; | |
| if(U_FAILURE(*status)) return; | |
| /* Alias */ | |
| left_cal = c; | |
| /* ========== Generate the header containing the year (only) */ | |
| /* Open a formatter with a month and year only pattern */ | |
| dfmt = udat_open(UDAT_PATTERN,UDAT_PATTERN,NULL,NULL,0,pat, len, status); | |
| /* Format the date */ | |
| udat_format(dfmt, ucal_getMillis(left_cal, status), s, BUF_SIZE, 0, status); | |
| /* ========== Get the month and day names */ | |
| get_days(dfmt, days, useLongNames, fdow, status); | |
| get_months(dfmt, months, useLongNames, status); | |
| /* ========== Print the header, centered */ | |
| /* Calculate widths for justification */ | |
| width = 6; /* 6 spaces, 1 between each day name */ | |
| for(i = 0; i < DAY_COUNT; ++i) { | |
| lens[i] = u_strlen(days[i]); | |
| width += lens[i]; | |
| } | |
| /* width is the width for 1 calendar; we are displaying in 2 cols | |
| with MARGIN_WIDTH spaces between months */ | |
| /* Print the header, centered among the day names */ | |
| pad = 2 * width + MARGIN_WIDTH - u_strlen(s); | |
| indent(pad / 2, stdout); | |
| uprint(s, stdout, status); | |
| putc('\n', stdout); | |
| putc('\n', stdout); | |
| /* Generate a copy of the calendar to use */ | |
| right_cal = ucal_open(0, -1, uloc_getDefault(), UCAL_TRADITIONAL, status); | |
| ucal_setMillis(right_cal, ucal_getMillis(left_cal, status), status); | |
| /* Open the formatter */ | |
| nfmt = unum_open(UNUM_DECIMAL,NULL, 0,NULL,NULL, status); | |
| /* ========== Calculate and display the months, two at a time */ | |
| for(i = 0; i < MONTH_COUNT - 1; i += 2) { | |
| /* Print the month names for the two current months */ | |
| pad = width - u_strlen(months[i]); | |
| indent(pad / 2, stdout); | |
| uprint(months[i], stdout, status); | |
| indent(pad / 2 + MARGIN_WIDTH, stdout); | |
| pad = width - u_strlen(months[i + 1]); | |
| indent(pad / 2, stdout); | |
| uprint(months[i + 1], stdout, status); | |
| putc('\n', stdout); | |
| /* Print the day names, twice */ | |
| print_days(days, stdout, status); | |
| indent(MARGIN_WIDTH, stdout); | |
| print_days(days, stdout, status); | |
| putc('\n', stdout); | |
| /* Setup the two calendars */ | |
| ucal_set(left_cal, UCAL_MONTH, i); | |
| ucal_set(left_cal, UCAL_DATE, 1); | |
| ucal_set(right_cal, UCAL_MONTH, i + 1); | |
| ucal_set(right_cal, UCAL_DATE, 1); | |
| left_firstday = ucal_get(left_cal, UCAL_DAY_OF_WEEK, status); | |
| right_firstday = ucal_get(right_cal, UCAL_DAY_OF_WEEK, status); | |
| /* The day of the week for the first day of the month is based on | |
| 1-based days of the week. However, the days were reordered | |
| when placed in the days array. Account for this here by | |
| offsetting by the first day of the week for the locale, which | |
| is also 1-based. */ | |
| /* We need to mod by DAY_COUNT since fdow can be > firstday. IE, | |
| if fdow = 2 = Monday (like in France) and the first day of the | |
| month is a 1 = Sunday, we want firstday to be 6, not -1 */ | |
| left_firstday += (DAY_COUNT - fdow); | |
| left_firstday %= DAY_COUNT; | |
| right_firstday += (DAY_COUNT - fdow); | |
| right_firstday %= DAY_COUNT; | |
| left_current = left_firstday; | |
| right_current = right_firstday; | |
| left_day = ucal_get(left_cal, UCAL_DATE, status); | |
| right_day = ucal_get(right_cal, UCAL_DATE, status); | |
| left_month = ucal_get(left_cal, UCAL_MONTH, status); | |
| right_month = ucal_get(right_cal, UCAL_MONTH, status); | |
| /* Finally, print out the days */ | |
| while(left_month == i || right_month == i + 1) { | |
| /* If the left month is finished printing, but the right month | |
| still has days to be printed, indent the width of the days | |
| strings and reset the left calendar's current day to 0 */ | |
| if(left_month != i && right_month == i + 1) { | |
| indent(width + 1, stdout); | |
| left_current = 0; | |
| } | |
| while(left_month == i) { | |
| /* If the day is the first, indent the correct number of | |
| spaces for the first week */ | |
| if(left_day == 1) { | |
| for(j = 0; j < left_current; ++j) | |
| indent(lens[j] + 1, stdout); | |
| } | |
| /* Format the current day string */ | |
| unum_format(nfmt, left_day, s, BUF_SIZE, 0, status); | |
| /* Calculate the justification and indent */ | |
| pad = lens[left_current] - u_strlen(s); | |
| indent(pad, stdout); | |
| /* Print the day number out, followed by a space */ | |
| uprint(s, stdout, status); | |
| putc(' ', stdout); | |
| /* Update the current day */ | |
| ++left_current; | |
| left_current %= DAY_COUNT; | |
| /* Go to the next day */ | |
| ucal_add(left_cal, UCAL_DATE, 1, status); | |
| left_day = ucal_get(left_cal, UCAL_DATE, status); | |
| /* Determine the month */ | |
| left_month = ucal_get(left_cal, UCAL_MONTH, status); | |
| /* If we're at day 0 (first day of the week), break and go to | |
| the next month */ | |
| if(left_current == 0) { | |
| break; | |
| } | |
| }; | |
| /* If the current day isn't 0, indent to make up for missing | |
| days at the end of the month */ | |
| if(left_current != 0) { | |
| for(j = left_current; j < DAY_COUNT; ++j) | |
| indent(lens[j] + 1, stdout); | |
| } | |
| /* Indent between the two months */ | |
| indent(MARGIN_WIDTH, stdout); | |
| while(right_month == i + 1) { | |
| /* If the day is the first, indent the correct number of | |
| spaces for the first week */ | |
| if(right_day == 1) { | |
| for(j = 0; j < right_current; ++j) | |
| indent(lens[j] + 1, stdout); | |
| } | |
| /* Format the current day string */ | |
| unum_format(nfmt, right_day, s, BUF_SIZE, 0, status); | |
| /* Calculate the justification and indent */ | |
| pad = lens[right_current] - u_strlen(s); | |
| indent(pad, stdout); | |
| /* Print the day number out, followed by a space */ | |
| uprint(s, stdout, status); | |
| putc(' ', stdout); | |
| /* Update the current day */ | |
| ++right_current; | |
| right_current %= DAY_COUNT; | |
| /* Go to the next day */ | |
| ucal_add(right_cal, UCAL_DATE, 1, status); | |
| right_day = ucal_get(right_cal, UCAL_DATE, status); | |
| /* Determine the month */ | |
| right_month = ucal_get(right_cal, UCAL_MONTH, status); | |
| /* If we're at day 0 (first day of the week), break out */ | |
| if(right_current == 0) { | |
| break; | |
| } | |
| }; | |
| /* Output a newline */ | |
| putc('\n', stdout); | |
| } | |
| /* Output a trailing newline */ | |
| putc('\n', stdout); | |
| } | |
| /* Clean up */ | |
| free_months(months); | |
| free_days(days); | |
| udat_close(dfmt); | |
| unum_close(nfmt); | |
| ucal_close(right_cal); | |
| } | |
| #endif |