🌐 AI搜索 & 代理 主页
Google Git
Sign in
chromium / external / github.com / git / git / refs/tags/v2.35.6 / . / progress.c
blob: 680c6a8bf93b514a7b82510c475984ca32067eb7 [file] [log] [blame]
Nicolas Pitre74b67922007-10-30 19:41:13[diff] [blame]1/*
2 * Simple text-based progress display module for GIT
3 *
Nicolas Pitre03aa8ff2009-09-14 06:41:16[diff] [blame]4 * Copyright (c) 2007 by Nicolas Pitre <nico@fluxnic.net>
Nicolas Pitre74b67922007-10-30 19:41:13[diff] [blame]5 *
6 * This code is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
9 */
10
Đoàn Trần Công Danh3cacb9a2020-04-27 14:22:37[diff] [blame]11#define GIT_TEST_PROGRESS_ONLY
SZEDER Gábor545dc342019-04-12 19:45:15[diff] [blame]12#include "cache.h"
Nguyễn Thái Ngọc Duy754dbc42014-02-21 12:50:18[diff] [blame]13#include "gettext.h"
Nicolas Pitre96a02f82007-04-18 18:27:45[diff] [blame]14#include "progress.h"
Antoine Pelisse079b5462013-04-10 19:03:23[diff] [blame]15#include "strbuf.h"
Karsten Blees83d26fa2014-07-12 00:08:11[diff] [blame]16#include "trace.h"
SZEDER Gábor545dc342019-04-12 19:45:15[diff] [blame]17#include "utf8.h"
Derrick Stolee44a46932019-11-25 21:28:22[diff] [blame]18#include "config.h"
Nicolas Pitre96a02f82007-04-18 18:27:45[diff] [blame]19
Nicolas Pitrecf84d512007-10-30 18:57:34[diff] [blame]20#define TP_IDX_MAX 8
21
22struct throughput {
Nicolas Pitre53ed7b52007-11-06 21:30:28[diff] [blame]23 off_t curr_total;
Nicolas Pitre218558a2007-11-05 03:15:41[diff] [blame]24 off_t prev_total;
Karsten Blees83d26fa2014-07-12 00:08:11[diff] [blame]25 uint64_t prev_ns;
Nicolas Pitre218558a2007-11-05 03:15:41[diff] [blame]26 unsigned int avg_bytes;
Nicolas Pitrecf84d512007-10-30 18:57:34[diff] [blame]27 unsigned int avg_misecs;
Nicolas Pitre53ed7b52007-11-06 21:30:28[diff] [blame]28 unsigned int last_bytes[TP_IDX_MAX];
Nicolas Pitrecf84d512007-10-30 18:57:34[diff] [blame]29 unsigned int last_misecs[TP_IDX_MAX];
30 unsigned int idx;
Jeff King31319772015-09-24 21:05:57[diff] [blame]31 struct strbuf display;
Nicolas Pitrecf84d512007-10-30 18:57:34[diff] [blame]32};
33
Nicolas Pitredc6a0752007-10-30 18:57:32[diff] [blame]34struct progress {
35 const char *title;
Elijah Newrend6861d02017-11-13 20:15:58[diff] [blame]36 uint64_t last_value;
37 uint64_t total;
Nicolas Pitredc6a0752007-10-30 18:57:32[diff] [blame]38 unsigned last_percent;
39 unsigned delay;
Jeff Hostetler9d81ecb2019-03-21 19:36:11[diff] [blame]40 unsigned sparse;
Nicolas Pitrecf84d512007-10-30 18:57:34[diff] [blame]41 struct throughput *throughput;
René Scharfe0fae1e02017-07-08 16:43:42[diff] [blame]42 uint64_t start_ns;
SZEDER Gábord53ba842019-04-05 00:45:37[diff] [blame]43 struct strbuf counters_sb;
SZEDER Gábor545dc342019-04-12 19:45:15[diff] [blame]44 int title_len;
45 int split;
Nicolas Pitredc6a0752007-10-30 18:57:32[diff] [blame]46};
47
Nicolas Pitre96a02f82007-04-18 18:27:45[diff] [blame]48static volatile sig_atomic_t progress_update;
49
SZEDER Gábor2bb74b52019-09-16 20:54:12[diff] [blame]50/*
51 * These are only intended for testing the progress output, i.e. exclusively
52 * for 'test-tool progress'.
53 */
54int progress_testing;
55uint64_t progress_test_ns = 0;
SZEDER Gábor2bb74b52019-09-16 20:54:12[diff] [blame]56void progress_test_force_update(void)
57{
58 progress_update = 1;
59}
60
61
Nicolas Pitre96a02f82007-04-18 18:27:45[diff] [blame]62static void progress_interval(int signum)
63{
64 progress_update = 1;
65}
66
67static void set_progress_signal(void)
68{
69 struct sigaction sa;
70 struct itimerval v;
71
SZEDER Gábor2bb74b52019-09-16 20:54:12[diff] [blame]72 if (progress_testing)
73 return;
74
Nicolas Pitre180a9f22007-04-20 19:05:27[diff] [blame]75 progress_update = 0;
76
Nicolas Pitre96a02f82007-04-18 18:27:45[diff] [blame]77 memset(&sa, 0, sizeof(sa));
78 sa.sa_handler = progress_interval;
79 sigemptyset(&sa.sa_mask);
80 sa.sa_flags = SA_RESTART;
81 sigaction(SIGALRM, &sa, NULL);
82
83 v.it_interval.tv_sec = 1;
84 v.it_interval.tv_usec = 0;
85 v.it_value = v.it_interval;
86 setitimer(ITIMER_REAL, &v, NULL);
87}
88
89static void clear_progress_signal(void)
90{
91 struct itimerval v = {{0,},};
SZEDER Gábor2bb74b52019-09-16 20:54:12[diff] [blame]92
93 if (progress_testing)
94 return;
95
Nicolas Pitre96a02f82007-04-18 18:27:45[diff] [blame]96 setitimer(ITIMER_REAL, &v, NULL);
97 signal(SIGALRM, SIG_IGN);
98 progress_update = 0;
99}
100
Luke Mewburn85cb8902015-04-13 13:30:51[diff] [blame]101static int is_foreground_fd(int fd)
102{
Jeff Kinga4fb76c2015-05-19 05:24:57[diff] [blame]103 int tpgrp = tcgetpgrp(fd);
104 return tpgrp < 0 || tpgrp == getpgid(0);
Luke Mewburn85cb8902015-04-13 13:30:51[diff] [blame]105}
106
SZEDER Gábor9219d122019-04-05 00:45:36[diff] [blame]107static void display(struct progress *progress, uint64_t n, const char *done)
Nicolas Pitre96a02f82007-04-18 18:27:45[diff] [blame]108{
SZEDER Gábord53ba842019-04-05 00:45:37[diff] [blame]109 const char *tp;
110 struct strbuf *counters_sb = &progress->counters_sb;
111 int show_update = 0;
SZEDER Gáborbbf47562019-09-16 20:54:11[diff] [blame]112 int last_count_len = counters_sb->len;
Nicolas Pitre42e18fb2007-10-17 01:55:45[diff] [blame]113
Lars Schneider9c5951c2017-12-04 22:07:00[diff] [blame]114 if (progress->delay && (!progress_update || --progress->delay))
SZEDER Gábor9219d122019-04-05 00:45:36[diff] [blame]115 return;
Nicolas Pitre42e18fb2007-10-17 01:55:45[diff] [blame]116
117 progress->last_value = n;
Jeff King31319772015-09-24 21:05:57[diff] [blame]118 tp = (progress->throughput) ? progress->throughput->display.buf : "";
Nicolas Pitre96a02f82007-04-18 18:27:45[diff] [blame]119 if (progress->total) {
120 unsigned percent = n * 100 / progress->total;
121 if (percent != progress->last_percent || progress_update) {
122 progress->last_percent = percent;
SZEDER Gábord53ba842019-04-05 00:45:37[diff] [blame]123
124 strbuf_reset(counters_sb);
125 strbuf_addf(counters_sb,
126 "%3u%% (%"PRIuMAX"/%"PRIuMAX")%s", percent,
127 (uintmax_t)n, (uintmax_t)progress->total,
128 tp);
129 show_update = 1;
Nicolas Pitre96a02f82007-04-18 18:27:45[diff] [blame]130 }
131 } else if (progress_update) {
SZEDER Gábord53ba842019-04-05 00:45:37[diff] [blame]132 strbuf_reset(counters_sb);
133 strbuf_addf(counters_sb, "%"PRIuMAX"%s", (uintmax_t)n, tp);
134 show_update = 1;
135 }
136
137 if (show_update) {
Luke Mewburn85cb8902015-04-13 13:30:51[diff] [blame]138 if (is_foreground_fd(fileno(stderr)) || done) {
SZEDER Gábor9f1fd842019-04-12 19:45:14[diff] [blame]139 const char *eol = done ? done : "\r";
SZEDER Gáborbbf47562019-09-16 20:54:11[diff] [blame]140 size_t clear_len = counters_sb->len < last_count_len ?
141 last_count_len - counters_sb->len + 1 :
142 0;
143 /* The "+ 2" accounts for the ": ". */
144 size_t progress_line_len = progress->title_len +
145 counters_sb->len + 2;
146 int cols = term_columns();
SZEDER Gábor545dc342019-04-12 19:45:15[diff] [blame]147
148 if (progress->split) {
SZEDER Gáborbbf47562019-09-16 20:54:11[diff] [blame]149 fprintf(stderr, " %s%*s", counters_sb->buf,
150 (int) clear_len, eol);
151 } else if (!done && cols < progress_line_len) {
152 clear_len = progress->title_len + 1 < cols ?
153 cols - progress->title_len - 1 : 0;
154 fprintf(stderr, "%s:%*s\n %s%s",
155 progress->title, (int) clear_len, "",
156 counters_sb->buf, eol);
SZEDER Gábor545dc342019-04-12 19:45:15[diff] [blame]157 progress->split = 1;
158 } else {
SZEDER Gáborbbf47562019-09-16 20:54:11[diff] [blame]159 fprintf(stderr, "%s: %s%*s", progress->title,
160 counters_sb->buf, (int) clear_len, eol);
SZEDER Gábor545dc342019-04-12 19:45:15[diff] [blame]161 }
Luke Mewburn85cb8902015-04-13 13:30:51[diff] [blame]162 fflush(stderr);
163 }
Nicolas Pitre96a02f82007-04-18 18:27:45[diff] [blame]164 progress_update = 0;
Nicolas Pitre96a02f82007-04-18 18:27:45[diff] [blame]165 }
Nicolas Pitre96a02f82007-04-18 18:27:45[diff] [blame]166}
167
Elijah Newrend6861d02017-11-13 20:15:58[diff] [blame]168static void throughput_string(struct strbuf *buf, uint64_t total,
Nicolas Pitre53ed7b52007-11-06 21:30:28[diff] [blame]169 unsigned int rate)
170{
Jeff King31319772015-09-24 21:05:57[diff] [blame]171 strbuf_reset(buf);
Antoine Pelisse079b5462013-04-10 19:03:23[diff] [blame]172 strbuf_addstr(buf, ", ");
173 strbuf_humanise_bytes(buf, total);
174 strbuf_addstr(buf, " | ");
Dimitriy Ryazantcev8f354a12019-07-02 18:22:48[diff] [blame]175 strbuf_humanise_rate(buf, rate * 1024);
Nicolas Pitre53ed7b52007-11-06 21:30:28[diff] [blame]176}
177
SZEDER Gábor2bb74b52019-09-16 20:54:12[diff] [blame]178static uint64_t progress_getnanotime(struct progress *progress)
179{
180 if (progress_testing)
181 return progress->start_ns + progress_test_ns;
182 else
183 return getnanotime();
184}
185
Elijah Newrend6861d02017-11-13 20:15:58[diff] [blame]186void display_throughput(struct progress *progress, uint64_t total)
Nicolas Pitrecf84d512007-10-30 18:57:34[diff] [blame]187{
188 struct throughput *tp;
Karsten Blees83d26fa2014-07-12 00:08:11[diff] [blame]189 uint64_t now_ns;
190 unsigned int misecs, count, rate;
Nicolas Pitrecf84d512007-10-30 18:57:34[diff] [blame]191
192 if (!progress)
193 return;
194 tp = progress->throughput;
195
SZEDER Gábor2bb74b52019-09-16 20:54:12[diff] [blame]196 now_ns = progress_getnanotime(progress);
Nicolas Pitrecf84d512007-10-30 18:57:34[diff] [blame]197
198 if (!tp) {
René Scharfeca56dad2021-03-13 16:17:22[diff] [blame]199 progress->throughput = CALLOC_ARRAY(tp, 1);
Jeff King999b9512019-04-11 13:49:57[diff] [blame]200 tp->prev_total = tp->curr_total = total;
201 tp->prev_ns = now_ns;
202 strbuf_init(&tp->display, 0);
Nicolas Pitrecf84d512007-10-30 18:57:34[diff] [blame]203 return;
204 }
Nicolas Pitre53ed7b52007-11-06 21:30:28[diff] [blame]205 tp->curr_total = total;
Nicolas Pitrecf84d512007-10-30 18:57:34[diff] [blame]206
Karsten Blees83d26fa2014-07-12 00:08:11[diff] [blame]207 /* only update throughput every 0.5 s */
208 if (now_ns - tp->prev_ns <= 500000000)
209 return;
210
Nicolas Pitrecf84d512007-10-30 18:57:34[diff] [blame]211 /*
Karsten Blees83d26fa2014-07-12 00:08:11[diff] [blame]212 * We have x = bytes and y = nanosecs. We want z = KiB/s:
Nicolas Pitrecf84d512007-10-30 18:57:34[diff] [blame]213 *
Karsten Blees83d26fa2014-07-12 00:08:11[diff] [blame]214 * z = (x / 1024) / (y / 1000000000)
215 * z = x / y * 1000000000 / 1024
216 * z = x / (y * 1024 / 1000000000)
Nicolas Pitrecf84d512007-10-30 18:57:34[diff] [blame]217 * z = x / y'
218 *
219 * To simplify things we'll keep track of misecs, or 1024th of a sec
220 * obtained with:
221 *
Karsten Blees83d26fa2014-07-12 00:08:11[diff] [blame]222 * y' = y * 1024 / 1000000000
223 * y' = y * (2^10 / 2^42) * (2^42 / 1000000000)
224 * y' = y / 2^32 * 4398
225 * y' = (y * 4398) >> 32
Nicolas Pitrecf84d512007-10-30 18:57:34[diff] [blame]226 */
Karsten Blees83d26fa2014-07-12 00:08:11[diff] [blame]227 misecs = ((now_ns - tp->prev_ns) * 4398) >> 32;
Nicolas Pitrecf84d512007-10-30 18:57:34[diff] [blame]228
Karsten Blees83d26fa2014-07-12 00:08:11[diff] [blame]229 count = total - tp->prev_total;
230 tp->prev_total = total;
231 tp->prev_ns = now_ns;
232 tp->avg_bytes += count;
233 tp->avg_misecs += misecs;
234 rate = tp->avg_bytes / tp->avg_misecs;
235 tp->avg_bytes -= tp->last_bytes[tp->idx];
236 tp->avg_misecs -= tp->last_misecs[tp->idx];
237 tp->last_bytes[tp->idx] = count;
238 tp->last_misecs[tp->idx] = misecs;
239 tp->idx = (tp->idx + 1) % TP_IDX_MAX;
Nicolas Pitre53ed7b52007-11-06 21:30:28[diff] [blame]240
Jeff King31319772015-09-24 21:05:57[diff] [blame]241 throughput_string(&tp->display, total, rate);
Karsten Blees83d26fa2014-07-12 00:08:11[diff] [blame]242 if (progress->last_value != -1 && progress_update)
243 display(progress, progress->last_value, NULL);
Nicolas Pitrecf84d512007-10-30 18:57:34[diff] [blame]244}
245
SZEDER Gábor9219d122019-04-05 00:45:36[diff] [blame]246void display_progress(struct progress *progress, uint64_t n)
Nicolas Pitre96a02f82007-04-18 18:27:45[diff] [blame]247{
SZEDER Gábor9219d122019-04-05 00:45:36[diff] [blame]248 if (progress)
249 display(progress, n, NULL);
Nicolas Pitre96a02f82007-04-18 18:27:45[diff] [blame]250}
251
Elijah Newrend6861d02017-11-13 20:15:58[diff] [blame]252static struct progress *start_progress_delay(const char *title, uint64_t total,
Jeff Hostetler9d81ecb2019-03-21 19:36:11[diff] [blame]253 unsigned delay, unsigned sparse)
Nicolas Pitre180a9f22007-04-20 19:05:27[diff] [blame]254{
Jeff King999b9512019-04-11 13:49:57[diff] [blame]255 struct progress *progress = xmalloc(sizeof(*progress));
Nicolas Pitre42e18fb2007-10-17 01:55:45[diff] [blame]256 progress->title = title;
Nicolas Pitre180a9f22007-04-20 19:05:27[diff] [blame]257 progress->total = total;
Nicolas Pitre42e18fb2007-10-17 01:55:45[diff] [blame]258 progress->last_value = -1;
Nicolas Pitre180a9f22007-04-20 19:05:27[diff] [blame]259 progress->last_percent = -1;
Nicolas Pitre180a9f22007-04-20 19:05:27[diff] [blame]260 progress->delay = delay;
Jeff Hostetler9d81ecb2019-03-21 19:36:11[diff] [blame]261 progress->sparse = sparse;
Nicolas Pitrecf84d512007-10-30 18:57:34[diff] [blame]262 progress->throughput = NULL;
René Scharfe0fae1e02017-07-08 16:43:42[diff] [blame]263 progress->start_ns = getnanotime();
SZEDER Gábord53ba842019-04-05 00:45:37[diff] [blame]264 strbuf_init(&progress->counters_sb, 0);
SZEDER Gábor545dc342019-04-12 19:45:15[diff] [blame]265 progress->title_len = utf8_strwidth(title);
266 progress->split = 0;
Nicolas Pitre180a9f22007-04-20 19:05:27[diff] [blame]267 set_progress_signal();
Emily Shaffer98a13642020-05-12 21:44:20[diff] [blame]268 trace2_region_enter("progress", title, the_repository);
Nicolas Pitredc6a0752007-10-30 18:57:32[diff] [blame]269 return progress;
Nicolas Pitre180a9f22007-04-20 19:05:27[diff] [blame]270}
271
Derrick Stolee44a46932019-11-25 21:28:22[diff] [blame]272static int get_default_delay(void)
273{
274 static int delay_in_secs = -1;
275
276 if (delay_in_secs < 0)
277 delay_in_secs = git_env_ulong("GIT_PROGRESS_DELAY", 2);
278
279 return delay_in_secs;
280}
281
Elijah Newrend6861d02017-11-13 20:15:58[diff] [blame]282struct progress *start_delayed_progress(const char *title, uint64_t total)
Junio C Hamano8aade102017-08-19 17:39:41[diff] [blame]283{
Derrick Stolee44a46932019-11-25 21:28:22[diff] [blame]284 return start_progress_delay(title, total, get_default_delay(), 0);
Junio C Hamano8aade102017-08-19 17:39:41[diff] [blame]285}
286
Elijah Newrend6861d02017-11-13 20:15:58[diff] [blame]287struct progress *start_progress(const char *title, uint64_t total)
Nicolas Pitre42e18fb2007-10-17 01:55:45[diff] [blame]288{
Jeff Hostetler9d81ecb2019-03-21 19:36:11[diff] [blame]289 return start_progress_delay(title, total, 0, 0);
290}
291
292/*
293 * Here "sparse" means that the caller might use some sampling criteria to
294 * decide when to call display_progress() rather than calling it for every
295 * integer value in[0 .. total). In particular, the caller might not call
296 * display_progress() for the last value in the range.
297 *
298 * When "sparse" is set, stop_progress() will automatically force the done
299 * message to show 100%.
300 */
301struct progress *start_sparse_progress(const char *title, uint64_t total)
302{
303 return start_progress_delay(title, total, 0, 1);
304}
305
306struct progress *start_delayed_sparse_progress(const char *title,
307 uint64_t total)
308{
Derrick Stolee44a46932019-11-25 21:28:22[diff] [blame]309 return start_progress_delay(title, total, get_default_delay(), 1);
Jeff Hostetler9d81ecb2019-03-21 19:36:11[diff] [blame]310}
311
312static void finish_if_sparse(struct progress *progress)
313{
314 if (progress &&
315 progress->sparse &&
316 progress->last_value != progress->total)
317 display_progress(progress, progress->total);
Nicolas Pitre42e18fb2007-10-17 01:55:45[diff] [blame]318}
319
Nicolas Pitredc6a0752007-10-30 18:57:32[diff] [blame]320void stop_progress(struct progress **p_progress)
Nicolas Pitre96a02f82007-04-18 18:27:45[diff] [blame]321{
Martin Ågrenac900fd2020-08-10 19:47:48[diff] [blame]322 if (!p_progress)
323 BUG("don't provide NULL to stop_progress");
324
Jeff Hostetler9d81ecb2019-03-21 19:36:11[diff] [blame]325 finish_if_sparse(*p_progress);
326
Martin Ågrenac900fd2020-08-10 19:47:48[diff] [blame]327 if (*p_progress) {
Emily Shaffer98a13642020-05-12 21:44:20[diff] [blame]328 trace2_data_intmax("progress", the_repository, "total_objects",
329 (*p_progress)->total);
330
331 if ((*p_progress)->throughput)
332 trace2_data_intmax("progress", the_repository,
333 "total_bytes",
334 (*p_progress)->throughput->curr_total);
Emily Shaffer98a13642020-05-12 21:44:20[diff] [blame]335
Derrick Stolee3af029c2020-05-15 16:09:28[diff] [blame]336 trace2_region_leave("progress", (*p_progress)->title, the_repository);
337 }
Emily Shaffer98a13642020-05-12 21:44:20[diff] [blame]338
Nguyễn Thái Ngọc Duy754dbc42014-02-21 12:50:18[diff] [blame]339 stop_progress_msg(p_progress, _("done"));
Nicolas Pitrea984a062007-11-08 20:45:41[diff] [blame]340}
341
342void stop_progress_msg(struct progress **p_progress, const char *msg)
343{
Martin Ågrenac900fd2020-08-10 19:47:48[diff] [blame]344 struct progress *progress;
345
346 if (!p_progress)
347 BUG("don't provide NULL to stop_progress_msg");
348
349 progress = *p_progress;
Nicolas Pitredc6a0752007-10-30 18:57:32[diff] [blame]350 if (!progress)
351 return;
352 *p_progress = NULL;
Nicolas Pitre42e18fb2007-10-17 01:55:45[diff] [blame]353 if (progress->last_value != -1) {
354 /* Force the last update */
Maxim Moseychukfbd09432017-02-16 17:07:13[diff] [blame]355 char *buf;
Nicolas Pitre53ed7b52007-11-06 21:30:28[diff] [blame]356 struct throughput *tp = progress->throughput;
Boyd Lynn Gerberd4c44442008-06-08 15:26:15[diff] [blame]357
Nicolas Pitre53ed7b52007-11-06 21:30:28[diff] [blame]358 if (tp) {
SZEDER Gábor2bb74b52019-09-16 20:54:12[diff] [blame]359 uint64_t now_ns = progress_getnanotime(progress);
René Scharfe0fae1e02017-07-08 16:43:42[diff] [blame]360 unsigned int misecs, rate;
361 misecs = ((now_ns - progress->start_ns) * 4398) >> 32;
362 rate = tp->curr_total / (misecs ? misecs : 1);
Jeff King31319772015-09-24 21:05:57[diff] [blame]363 throughput_string(&tp->display, tp->curr_total, rate);
Nicolas Pitre53ed7b52007-11-06 21:30:28[diff] [blame]364 }
Nicolas Pitre42e18fb2007-10-17 01:55:45[diff] [blame]365 progress_update = 1;
Maxim Moseychukfbd09432017-02-16 17:07:13[diff] [blame]366 buf = xstrfmt(", %s.\n", msg);
367 display(progress, progress->last_value, buf);
368 free(buf);
Nicolas Pitre42e18fb2007-10-17 01:55:45[diff] [blame]369 }
Nicolas Pitre96a02f82007-04-18 18:27:45[diff] [blame]370 clear_progress_signal();
SZEDER Gábord53ba842019-04-05 00:45:37[diff] [blame]371 strbuf_release(&progress->counters_sb);
Jeff King31319772015-09-24 21:05:57[diff] [blame]372 if (progress->throughput)
373 strbuf_release(&progress->throughput->display);
Nicolas Pitrecf84d512007-10-30 18:57:34[diff] [blame]374 free(progress->throughput);
Nicolas Pitredc6a0752007-10-30 18:57:32[diff] [blame]375 free(progress);
Nicolas Pitre96a02f82007-04-18 18:27:45[diff] [blame]376}