Home | History | Annotate | Download | only in tzcode 
      1 // Copyright (C) 2016 and later: Unicode, Inc. and others.
      2 // License & terms of use: http://www.unicode.org/copyright.html
      3 /*
      4 *******************************************************************************
      5 *
      6 *   Copyright (C) 2007-2016, International Business Machines
      7 *   Corporation and others.  All Rights Reserved.
      8 *
      9 *******************************************************************************
     10 *   file name:  icuzdump.cpp
     11 *   encoding:   US-ASCII
     12 *   tab size:   8 (not used)
     13 *   indentation:4
     14 *
     15 *   created on: 2007-04-02
     16 *   created by: Yoshito Umaoka
     17 *
     18 *   This tool write out timezone transitions for ICU timezone.  This tool
     19 *   is used as a part of tzdata update process to check if ICU timezone
     20 *   code works as well as the corresponding Olson stock localtime/zdump.
     21 */
     22 
     23 #include <cstdlib>
     24 #include <cstring>
     25 #include <fstream>
     26 #include <sstream>
     27 #include <iostream>
     28 
     29 #include "unicode/utypes.h"
     30 #include "unicode/ustring.h"
     31 #include "unicode/timezone.h"
     32 #include "unicode/simpletz.h"
     33 #include "unicode/smpdtfmt.h"
     34 #include "unicode/decimfmt.h"
     35 #include "unicode/gregocal.h"
     36 #include "unicode/ustream.h"
     37 #include "unicode/putil.h"
     38 
     39 #include "cmemory.h"
     40 #include "uoptions.h"
     41 
     42 using namespace std;
     43 
     44 class DumpFormatter {
     45 public:
     46     DumpFormatter() {
     47         UErrorCode status = U_ZERO_ERROR;
     48         stz = new SimpleTimeZone(0, "");
     49         sdf = new SimpleDateFormat((UnicodeString)"yyyy-MM-dd EEE HH:mm:ss", Locale::getEnglish(), status);
     50         DecimalFormatSymbols *symbols = new DecimalFormatSymbols(Locale::getEnglish(), status);
     51         decf = new DecimalFormat("00", symbols, status);
     52     }
     53     ~DumpFormatter() {
     54     }
     55 
     56     UnicodeString& format(UDate time, int32_t offset, UBool isDst, UnicodeString& appendTo) {
     57         stz->setRawOffset(offset);
     58         sdf->setTimeZone(*stz);
     59         UnicodeString str = sdf->format(time, appendTo);
     60         if (offset < 0) {
     61             appendTo += "-";
     62             offset = -offset;
     63         } else {
     64             appendTo += "+";
     65         }
     66 
     67         int32_t hour, min, sec;
     68 
     69         offset /= 1000;
     70         sec = offset % 60;
     71         offset = (offset - sec) / 60;
     72         min = offset % 60;
     73         hour = offset / 60;
     74 
     75         decf->format(hour, appendTo);
     76         decf->format(min, appendTo);
     77         decf->format(sec, appendTo);
     78         appendTo += "[DST=";
     79         if (isDst) {
     80             appendTo += "1";
     81         } else {
     82             appendTo += "0";
     83         }
     84         appendTo += "]";
     85         return appendTo;
     86     }
     87 private:
     88     SimpleTimeZone*     stz;
     89     SimpleDateFormat*   sdf;
     90     DecimalFormat*      decf;
     91 };
     92 
     93 class ICUZDump {
     94 public:
     95     ICUZDump() {
     96         formatter = new DumpFormatter();
     97         loyear = 1902;
     98         hiyear = 2050;
     99         tick = 1000;
    100         linesep = NULL;
    101     }
    102 
    103     ~ICUZDump() {
    104     }
    105 
    106     void setLowYear(int32_t lo) {
    107         loyear = lo;
    108     }
    109 
    110     void setHighYear(int32_t hi) {
    111         hiyear = hi;
    112     }
    113 
    114     void setTick(int32_t t) {
    115         tick = t;
    116     }
    117 
    118     void setTimeZone(TimeZone* tz) {
    119         timezone = tz;
    120     }
    121 
    122     void setDumpFormatter(DumpFormatter* fmt) {
    123         formatter = fmt;
    124     }
    125 
    126     void setLineSeparator(const char* sep) {
    127         linesep = sep;
    128     }
    129 
    130     void dump(ostream& out) {
    131         UErrorCode status = U_ZERO_ERROR;
    132         UDate SEARCH_INCREMENT = 12 * 60 * 60 * 1000; // half day
    133         UDate t, cutlo, cuthi;
    134         int32_t rawOffset, dstOffset;
    135         UnicodeString str;
    136 
    137         getCutOverTimes(cutlo, cuthi);
    138         t = cutlo;
    139         timezone->getOffset(t, FALSE, rawOffset, dstOffset, status);
    140         while (t < cuthi) {
    141             int32_t newRawOffset, newDstOffset;
    142             UDate newt = t + SEARCH_INCREMENT;
    143 
    144             timezone->getOffset(newt, FALSE, newRawOffset, newDstOffset, status);
    145 
    146             UBool bSameOffset = (rawOffset + dstOffset) == (newRawOffset + newDstOffset);
    147             UBool bSameDst = ((dstOffset != 0) && (newDstOffset != 0)) || ((dstOffset == 0) && (newDstOffset == 0));
    148 
    149             if (!bSameOffset || !bSameDst) {
    150                 // find the boundary
    151                 UDate lot = t;
    152                 UDate hit = newt;
    153                 while (true) {
    154                     int32_t diff = (int32_t)(hit - lot);
    155                     if (diff <= tick) {
    156                         break;
    157                     }
    158                     UDate medt = lot + ((diff / 2) / tick) * tick;
    159                     int32_t medRawOffset, medDstOffset;
    160                     timezone->getOffset(medt, FALSE, medRawOffset, medDstOffset, status);
    161 
    162                     bSameOffset = (rawOffset + dstOffset) == (medRawOffset + medDstOffset);
    163                     bSameDst = ((dstOffset != 0) && (medDstOffset != 0)) || ((dstOffset == 0) && (medDstOffset == 0));
    164 
    165                     if (!bSameOffset || !bSameDst) {
    166                         hit = medt;
    167                     } else {
    168                         lot = medt;
    169                     }
    170                 }
    171                 // write out the boundary
    172                 str.remove();
    173                 formatter->format(lot, rawOffset + dstOffset, (dstOffset == 0 ? FALSE : TRUE), str);
    174                 out << str << " > ";
    175                 str.remove();
    176                 formatter->format(hit, newRawOffset + newDstOffset, (newDstOffset == 0 ? FALSE : TRUE), str);
    177                 out << str;
    178                 if (linesep != NULL) {
    179                     out << linesep;
    180                 } else {
    181                     out << endl;
    182                 }
    183 
    184                 rawOffset = newRawOffset;
    185                 dstOffset = newDstOffset;
    186             }
    187             t = newt;
    188         }
    189     }
    190 
    191 private:
    192     void getCutOverTimes(UDate& lo, UDate& hi) {
    193         UErrorCode status = U_ZERO_ERROR;
    194         GregorianCalendar* gcal = new GregorianCalendar(timezone, Locale::getEnglish(), status);
    195         gcal->clear();
    196         gcal->set(loyear, 0, 1, 0, 0, 0);
    197         lo = gcal->getTime(status);
    198         gcal->set(hiyear, 0, 1, 0, 0, 0);
    199         hi = gcal->getTime(status);
    200     }
    201 
    202     TimeZone*   timezone;
    203     int32_t     loyear;
    204     int32_t     hiyear;
    205     int32_t     tick;
    206 
    207     DumpFormatter*  formatter;
    208     const char*  linesep;
    209 };
    210 
    211 class ZoneIterator {
    212 public:
    213     ZoneIterator(UBool bAll = FALSE) {
    214         if (bAll) {
    215             zenum = TimeZone::createEnumeration();
    216         }
    217         else {
    218             zenum = NULL;
    219             zids = NULL;
    220             idx = 0;
    221             numids = 1;
    222         }
    223     }
    224 
    225     ZoneIterator(const char** ids, int32_t num) {
    226         zenum = NULL;
    227         zids = ids;
    228         idx = 0;
    229         numids = num;
    230     }
    231 
    232     ~ZoneIterator() {
    233         if (zenum != NULL) {
    234             delete zenum;
    235         }
    236     }
    237 
    238     TimeZone* next() {
    239         TimeZone* tz = NULL;
    240         if (zenum != NULL) {
    241             UErrorCode status = U_ZERO_ERROR;
    242             const UnicodeString* zid = zenum->snext(status);
    243             if (zid != NULL) {
    244                 tz = TimeZone::createTimeZone(*zid);
    245             }
    246         }
    247         else {
    248             if (idx < numids) {
    249                 if (zids != NULL) {
    250                     tz = TimeZone::createTimeZone((const UnicodeString&)zids[idx]);
    251                 }
    252                 else {
    253                     tz = TimeZone::createDefault();
    254                 }
    255                 idx++;
    256             }
    257         }
    258         return tz;
    259     }
    260 
    261 private:
    262     const char** zids;
    263     StringEnumeration* zenum;
    264     int32_t idx;
    265     int32_t numids;
    266 };
    267 
    268 enum {
    269   kOptHelpH = 0,
    270   kOptHelpQuestionMark,
    271   kOptAllZones,
    272   kOptCutover,
    273   kOptDestDir,
    274   kOptLineSep
    275 };
    276 
    277 static UOption options[]={
    278     UOPTION_HELP_H,
    279     UOPTION_HELP_QUESTION_MARK,
    280     UOPTION_DEF("allzones", 'a', UOPT_NO_ARG),
    281     UOPTION_DEF("cutover", 'c', UOPT_REQUIRES_ARG),
    282     UOPTION_DEF("destdir", 'd', UOPT_REQUIRES_ARG),
    283     UOPTION_DEF("linesep", 'l', UOPT_REQUIRES_ARG)
    284 };
    285 
    286 extern int
    287 main(int argc, char *argv[]) {
    288     int32_t low = 1902;
    289     int32_t high = 2038;
    290     UBool bAll = FALSE;
    291     const char *dir = NULL;
    292     const char *linesep = NULL;
    293 
    294     U_MAIN_INIT_ARGS(argc, argv);
    295     argc = u_parseArgs(argc, argv, UPRV_LENGTHOF(options), options);
    296 
    297     if (argc < 0) {
    298         cerr << "Illegal command line argument(s)" << endl << endl;
    299     }
    300 
    301     if (argc < 0 || options[kOptHelpH].doesOccur || options[kOptHelpQuestionMark].doesOccur) {
    302         cerr
    303             << "Usage: icuzdump [-options] [zoneid1 zoneid2 ...]" << endl
    304             << endl
    305             << "\tDump all offset transitions for the specified zones." << endl
    306             << endl
    307             << "Options:" << endl
    308             << "\t-a       : Dump all available zones." << endl
    309             << "\t-d <dir> : When specified, write transitions in a file under" << endl
    310             << "\t           the directory for each zone." << endl
    311             << "\t-l <sep> : New line code type used in file outputs. CR or LF (default)"
    312             << "\t           or CRLF." << endl
    313             << "\t-c [<low_year>,]<high_year>" << endl
    314             << "\t         : When specified, dump transitions starting <low_year>" << endl
    315             << "\t           (inclusive) up to <high_year> (exclusive).  The default" << endl
    316             << "\t           values are 1902(low) and 2038(high)." << endl;
    317         return argc < 0 ? U_ILLEGAL_ARGUMENT_ERROR : U_ZERO_ERROR;
    318     }
    319 
    320     bAll = options[kOptAllZones].doesOccur;
    321 
    322     if (options[kOptDestDir].doesOccur) {
    323         dir = options[kOptDestDir].value;
    324     }
    325 
    326     if (options[kOptLineSep].doesOccur) {
    327         if (strcmp(options[kOptLineSep].value, "CR") == 0) {
    328             linesep = "\r";
    329         } else if (strcmp(options[kOptLineSep].value, "CRLF") == 0) {
    330             linesep = "\r\n";
    331         } else if (strcmp(options[kOptLineSep].value, "LF") == 0) {
    332             linesep = "\n";
    333         }
    334     }
    335 
    336     if (options[kOptCutover].doesOccur) {
    337         char* comma = (char*)strchr(options[kOptCutover].value, ',');
    338         if (comma == NULL) {
    339             high = atoi(options[kOptCutover].value);
    340         } else {
    341             *comma = 0;
    342             low = atoi(options[kOptCutover].value);
    343             high = atoi(comma + 1);
    344         }
    345     }
    346 
    347     ICUZDump dumper;
    348     dumper.setLowYear(low);
    349     dumper.setHighYear(high);
    350     if (dir != NULL && linesep != NULL) {
    351         // use the specified line separator only for file output
    352         dumper.setLineSeparator((const char*)linesep);
    353     }
    354 
    355     ZoneIterator* zit;
    356     if (bAll) {
    357         zit = new ZoneIterator(TRUE);
    358     } else {
    359         if (argc <= 1) {
    360             zit = new ZoneIterator();
    361         } else {
    362             zit = new ZoneIterator((const char**)&argv[1], argc - 1);
    363         }
    364     }
    365 
    366     UnicodeString id;
    367     if (dir != NULL) {
    368         // file output
    369         ostringstream path;
    370         ios::openmode mode = ios::out;
    371         if (linesep != NULL) {
    372             mode |= ios::binary;
    373         }
    374         for (;;) {
    375             TimeZone* tz = zit->next();
    376             if (tz == NULL) {
    377                 break;
    378             }
    379             dumper.setTimeZone(tz);
    380             tz->getID(id);
    381 
    382             // target file path
    383             path.str("");
    384             path << dir << U_FILE_SEP_CHAR;
    385             id = id.findAndReplace("/", "-");
    386             path << id;
    387 
    388             ofstream* fout = new ofstream(path.str().c_str(), mode);
    389             if (fout->fail()) {
    390                 cerr << "Cannot open file " << path.str() << endl;
    391                 delete fout;
    392                 delete tz;
    393                 break;
    394             }
    395 
    396             dumper.dump(*fout);
    397             fout->close();
    398             delete fout;
    399             delete tz;
    400         }
    401 
    402     } else {
    403         // stdout
    404         UBool bFirst = TRUE;
    405         for (;;) {
    406             TimeZone* tz = zit->next();
    407             if (tz == NULL) {
    408                 break;
    409             }
    410             dumper.setTimeZone(tz);
    411             tz->getID(id);
    412             if (bFirst) {
    413                 bFirst = FALSE;
    414             } else {
    415                 cout << endl;
    416             }
    417             cout << "ZONE: " << id << endl;
    418             dumper.dump(cout);
    419             delete tz;
    420         }
    421     }
    422     delete zit;
    423 }
    424