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

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