[apple/icu.git] / icuSources / tools / tzcode / icuzdump.cpp

// © 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
/*
*******************************************************************************
*
*   Copyright (C) 2007-2016, International Business Machines
*   Corporation and others.  All Rights Reserved.
*
*******************************************************************************
*   file name:  icuzdump.cpp
*   encoding:   UTF-8
*   tab size:   8 (not used)
*   indentation:4
*
*   created on: 2007-04-02
*   created by: Yoshito Umaoka
*
*   This tool write out timezone transitions for ICU timezone.  This tool
*   is used as a part of tzdata update process to check if ICU timezone
*   code works as well as the corresponding Olson stock localtime/zdump.
*/

#include <cstdlib>
#include <cstring>
#include <fstream>
#include <sstream>
#include <iostream>

#include "unicode/utypes.h"
#include "unicode/ustring.h"
#include "unicode/timezone.h"
#include "unicode/simpletz.h"
#include "unicode/smpdtfmt.h"
#include "unicode/decimfmt.h"
#include "unicode/gregocal.h"
#include "unicode/ustream.h"
#include "unicode/putil.h"

#include "cmemory.h"
#include "uoptions.h"

using namespace std;

class DumpFormatter {
public:
    DumpFormatter() {
        UErrorCode status = U_ZERO_ERROR;
        stz = new SimpleTimeZone(0, "");
        sdf = new SimpleDateFormat((UnicodeString)"yyyy-MM-dd EEE HH:mm:ss", Locale::getEnglish(), status);
        DecimalFormatSymbols *symbols = new DecimalFormatSymbols(Locale::getEnglish(), status);
        decf = new DecimalFormat("00", symbols, status);
    }
    ~DumpFormatter() {
    }

    UnicodeString& format(UDate time, int32_t offset, UBool isDst, UnicodeString& appendTo) {
        stz->setRawOffset(offset);
        sdf->setTimeZone(*stz);
        UnicodeString str = sdf->format(time, appendTo);
        if (offset < 0) {
            appendTo += "-";
            offset = -offset;
        } else {
            appendTo += "+";
        }

        int32_t hour, min, sec;

        offset /= 1000;
        sec = offset % 60;
        offset = (offset - sec) / 60;
        min = offset % 60;
        hour = offset / 60;

        decf->format(hour, appendTo);
        decf->format(min, appendTo);
        decf->format(sec, appendTo);
        appendTo += "[DST=";
        if (isDst) {
            appendTo += "1";
        } else {
            appendTo += "0";
        }
        appendTo += "]";
        return appendTo;
    }
private:
    SimpleTimeZone*     stz;
    SimpleDateFormat*   sdf;
    DecimalFormat*      decf;
};

class ICUZDump {
public:
    ICUZDump() {
        formatter = new DumpFormatter();
        loyear = 1902;
        hiyear = 2050;
        tick = 1000;
        linesep = NULL;
    }

    ~ICUZDump() {
    }

    void setLowYear(int32_t lo) {
        loyear = lo;
    }

    void setHighYear(int32_t hi) {
        hiyear = hi;
    }

    void setTick(int32_t t) {
        tick = t;
    }

    void setTimeZone(TimeZone* tz) {
        timezone = tz;
    }

    void setDumpFormatter(DumpFormatter* fmt) {
        formatter = fmt;
    }

    void setLineSeparator(const char* sep) {
        linesep = sep;
    }

    void dump(ostream& out) {
        UErrorCode status = U_ZERO_ERROR;
        UDate SEARCH_INCREMENT = 12 * 60 * 60 * 1000; // half day
        UDate t, cutlo, cuthi;
        int32_t rawOffset, dstOffset;
        UnicodeString str;

        getCutOverTimes(cutlo, cuthi);
        t = cutlo;
        timezone->getOffset(t, FALSE, rawOffset, dstOffset, status);
        while (t < cuthi) {
            int32_t newRawOffset, newDstOffset;
            UDate newt = t + SEARCH_INCREMENT;

            timezone->getOffset(newt, FALSE, newRawOffset, newDstOffset, status);

            UBool bSameOffset = (rawOffset + dstOffset) == (newRawOffset + newDstOffset);
            UBool bSameDst = ((dstOffset != 0) && (newDstOffset != 0)) || ((dstOffset == 0) && (newDstOffset == 0));

            if (!bSameOffset || !bSameDst) {
                // find the boundary
                UDate lot = t;
                UDate hit = newt;
                while (true) {
                    int32_t diff = (int32_t)(hit - lot);
                    if (diff <= tick) {
                        break;
                    }
                    UDate medt = lot + ((diff / 2) / tick) * tick;
                    int32_t medRawOffset, medDstOffset;
                    timezone->getOffset(medt, FALSE, medRawOffset, medDstOffset, status);

                    bSameOffset = (rawOffset + dstOffset) == (medRawOffset + medDstOffset);
                    bSameDst = ((dstOffset != 0) && (medDstOffset != 0)) || ((dstOffset == 0) && (medDstOffset == 0));

                    if (!bSameOffset || !bSameDst) {
                        hit = medt;
                    } else {
                        lot = medt;
                    }
                }
                // write out the boundary
                str.remove();
                formatter->format(lot, rawOffset + dstOffset, (dstOffset == 0 ? FALSE : TRUE), str);
                out << str << " > ";
                str.remove();
                formatter->format(hit, newRawOffset + newDstOffset, (newDstOffset == 0 ? FALSE : TRUE), str);
                out << str;
                if (linesep != NULL) {
                    out << linesep;
                } else {
                    out << endl;
                }

                rawOffset = newRawOffset;
                dstOffset = newDstOffset;
            }
            t = newt;
        }
    }

private:
    void getCutOverTimes(UDate& lo, UDate& hi) {
        UErrorCode status = U_ZERO_ERROR;
        GregorianCalendar* gcal = new GregorianCalendar(timezone, Locale::getEnglish(), status);
        gcal->clear();
        gcal->set(loyear, 0, 1, 0, 0, 0);
        lo = gcal->getTime(status);
        gcal->set(hiyear, 0, 1, 0, 0, 0);
        hi = gcal->getTime(status);
    }

    TimeZone*   timezone;
    int32_t     loyear;
    int32_t     hiyear;
    int32_t     tick;

    DumpFormatter*  formatter;
    const char*  linesep;
};

class ZoneIterator {
public:
    ZoneIterator(UBool bAll = FALSE) {
        if (bAll) {
            zenum = TimeZone::createEnumeration();
        }
        else {
            zenum = NULL;
            zids = NULL;
            idx = 0;
            numids = 1;
        }
    }

    ZoneIterator(const char** ids, int32_t num) {
        zenum = NULL;
        zids = ids;
        idx = 0;
        numids = num;
    }

    ~ZoneIterator() {
        if (zenum != NULL) {
            delete zenum;
        }
    }

    TimeZone* next() {
        TimeZone* tz = NULL;
        if (zenum != NULL) {
            UErrorCode status = U_ZERO_ERROR;
            const UnicodeString* zid = zenum->snext(status);
            if (zid != NULL) {
                tz = TimeZone::createTimeZone(*zid);
            }
        }
        else {
            if (idx < numids) {
                if (zids != NULL) {
                    tz = TimeZone::createTimeZone((const UnicodeString&)zids[idx]);
                }
                else {
                    tz = TimeZone::createDefault();
                }
                idx++;
            }
        }
        return tz;
    }

private:
    const char** zids;
    StringEnumeration* zenum;
    int32_t idx;
    int32_t numids;
};

enum { 
  kOptHelpH = 0,
  kOptHelpQuestionMark,
  kOptAllZones,
  kOptCutover,
  kOptDestDir,
  kOptLineSep
};

static UOption options[]={
    UOPTION_HELP_H,
    UOPTION_HELP_QUESTION_MARK,
    UOPTION_DEF("allzones", 'a', UOPT_NO_ARG),
    UOPTION_DEF("cutover", 'c', UOPT_REQUIRES_ARG),
    UOPTION_DEF("destdir", 'd', UOPT_REQUIRES_ARG),
    UOPTION_DEF("linesep", 'l', UOPT_REQUIRES_ARG)
};

extern int
main(int argc, char *argv[]) {
    int32_t low = 1902;
    int32_t high = 2038;
    UBool bAll = FALSE;
    const char *dir = NULL;
    const char *linesep = NULL;

    U_MAIN_INIT_ARGS(argc, argv);
    argc = u_parseArgs(argc, argv, UPRV_LENGTHOF(options), options);

    if (argc < 0) {
        cerr << "Illegal command line argument(s)" << endl << endl;
    }

    if (argc < 0 || options[kOptHelpH].doesOccur || options[kOptHelpQuestionMark].doesOccur) {
        cerr
            << "Usage: icuzdump [-options] [zoneid1 zoneid2 ...]" << endl
            << endl
            << "\tDump all offset transitions for the specified zones." << endl
            << endl
            << "Options:" << endl
            << "\t-a       : Dump all available zones." << endl
            << "\t-d <dir> : When specified, write transitions in a file under" << endl
            << "\t           the directory for each zone." << endl
            << "\t-l <sep> : New line code type used in file outputs. CR or LF (default)"
            << "\t           or CRLF." << endl
            << "\t-c [<low_year>,]<high_year>" << endl
            << "\t         : When specified, dump transitions starting <low_year>" << endl
            << "\t           (inclusive) up to <high_year> (exclusive).  The default" << endl
            << "\t           values are 1902(low) and 2038(high)." << endl;
        return argc < 0 ? U_ILLEGAL_ARGUMENT_ERROR : U_ZERO_ERROR;
    }

    bAll = options[kOptAllZones].doesOccur;

    if (options[kOptDestDir].doesOccur) {
        dir = options[kOptDestDir].value;
    }

    if (options[kOptLineSep].doesOccur) {
        if (strcmp(options[kOptLineSep].value, "CR") == 0) {
            linesep = "\r";
        } else if (strcmp(options[kOptLineSep].value, "CRLF") == 0) {
            linesep = "\r\n";
        } else if (strcmp(options[kOptLineSep].value, "LF") == 0) {
            linesep = "\n";
        }
    }

    if (options[kOptCutover].doesOccur) {
        char* comma = (char*)strchr(options[kOptCutover].value, ',');
        if (comma == NULL) {
            high = atoi(options[kOptCutover].value);
        } else {
            *comma = 0;
            low = atoi(options[kOptCutover].value);
            high = atoi(comma + 1);
        }
    }

    ICUZDump dumper;
    dumper.setLowYear(low);
    dumper.setHighYear(high);
    if (dir != NULL && linesep != NULL) {
        // use the specified line separator only for file output
        dumper.setLineSeparator((const char*)linesep);
    }

    ZoneIterator* zit;
    if (bAll) {
        zit = new ZoneIterator(TRUE);
    } else {
        if (argc <= 1) {
            zit = new ZoneIterator();
        } else {
            zit = new ZoneIterator((const char**)&argv[1], argc - 1);
        }
    }

    UnicodeString id;
    if (dir != NULL) {
        // file output
        ostringstream path;
        ios::openmode mode = ios::out;
        if (linesep != NULL) {
            mode |= ios::binary;
        }
        for (;;) {
            TimeZone* tz = zit->next();
            if (tz == NULL) {
                break;
            }
            dumper.setTimeZone(tz);
            tz->getID(id);

            // target file path
            path.str("");
            path << dir << U_FILE_SEP_CHAR;
            id = id.findAndReplace("/", "-");
            path << id;

            ofstream* fout = new ofstream(path.str().c_str(), mode);
            if (fout->fail()) {
                cerr << "Cannot open file " << path.str() << endl;
                delete fout;
                delete tz;
                break;
            }

            dumper.dump(*fout);
            fout->close();
            delete fout;
            delete tz;
        }

    } else {
        // stdout
        UBool bFirst = TRUE;
        for (;;) {
            TimeZone* tz = zit->next();
            if (tz == NULL) {
                break;
            }
            dumper.setTimeZone(tz);
            tz->getID(id);
            if (bFirst) {
                bFirst = FALSE;
            } else {
                cout << endl;
            }
            cout << "ZONE: " << id << endl;
            dumper.dump(cout);
            delete tz;
        }
    }
    delete zit;
}
Commit	Line	Data
f3c0d7a5 A	1	// © 2016 and later: Unicode, Inc. and others.
f3c0d7a5 A	2	// License & terms of use: http://www.unicode.org/copyright.html
4162bf98 A	3	/*
	4	*******************************************************************************
	5	*
a0b4f637	6	* Copyright (C) 2007-2016, International Business Machines
4162bf98 A	7	* Corporation and others. All Rights Reserved.
	8	*
	9	*******************************************************************************
	10	* file name: icuzdump.cpp
f3c0d7a5	11	* encoding: UTF-8
4162bf98 A	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
2ca993e8	39	#include "cmemory.h"
4162bf98 A	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
4162bf98 A	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);
2ca993e8	295	argc = u_parseArgs(argc, argv, UPRV_LENGTHOF(options), options);
4162bf98 A	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()) {
a0b4f637	390	cerr << "Cannot open file " << path.str() << endl;
4162bf98 A	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	}