]> git.cworth.org Git - notmuch/blob - test/parse-time.c
fix misspelling
[notmuch] / test / parse-time.c
1 /*
2  * parse time string - user friendly date and time parser
3  * Copyright © 2012 Jani Nikula
4  *
5  * This program is free software: you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation, either version 2 of the License, or
8  * (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
17  *
18  * Author: Jani Nikula <jani@nikula.org>
19  */
20
21 #include <assert.h>
22 #include <ctype.h>
23 #include <getopt.h>
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <string.h>
27
28 #include "parse-time-string.h"
29
30 #define ARRAY_SIZE(a) (sizeof (a) / sizeof (a[0]))
31
32 static const char *parse_time_error_strings[] = {
33     [PARSE_TIME_OK]                     = "OK",
34     [PARSE_TIME_ERR]                    = "ERR",
35     [PARSE_TIME_ERR_LIB]                = "LIB",
36     [PARSE_TIME_ERR_ALREADYSET]         = "ALREADYSET",
37     [PARSE_TIME_ERR_FORMAT]             = "FORMAT",
38     [PARSE_TIME_ERR_DATEFORMAT]         = "DATEFORMAT",
39     [PARSE_TIME_ERR_TIMEFORMAT]         = "TIMEFORMAT",
40     [PARSE_TIME_ERR_INVALIDDATE]        = "INVALIDDATE",
41     [PARSE_TIME_ERR_INVALIDTIME]        = "INVALIDTIME",
42     [PARSE_TIME_ERR_KEYWORD]            = "KEYWORD",
43 };
44
45 static const char *
46 parse_time_strerror (unsigned int errnum)
47 {
48     if (errnum < ARRAY_SIZE (parse_time_error_strings))
49         return parse_time_error_strings[errnum];
50     else
51         return NULL;
52 }
53
54 /*
55  * concat argv[start]...argv[end - 1], separating them by a single
56  * space, to a malloced string
57  */
58 static char *
59 concat_args (int start, int end, char *argv[])
60 {
61     int i;
62     size_t len = 1;
63     char *p;
64
65     for (i = start; i < end; i++)
66         len += strlen (argv[i]) + 1;
67
68     p = malloc (len);
69     if (!p)
70         return NULL;
71
72     *p = 0;
73
74     for (i = start; i < end; i++) {
75         if (i != start)
76             strcat (p, " ");
77         strcat (p, argv[i]);
78     }
79
80     return p;
81 }
82
83 #define DEFAULT_FORMAT "%a %b %d %T %z %Y"
84
85 static void
86 usage (const char *name)
87 {
88     printf ("Usage: %s [options ...] [<date/time>]\n\n", name);
89     printf (
90         "Parse <date/time> and display it in given format. If <date/time> is\n"
91         "not given, parse each line in stdin according to:\n\n"
92         "  <date/time> [(==>|==_>|==^>|==^^>)<ignored>] [#<comment>]\n\n"
93         "and produce output:\n\n"
94         "  <date/time> (==>|==_>|==^>|==^^>) <time in --format=FMT> [#<comment>]\n\n"
95         "preserving whitespace and comment in input. The operators ==>, ==_>,\n"
96         "==^>, and ==^^> define rounding as no rounding, round down, round up\n"
97         "inclusive, and round up, respectively.\n\n"
98
99         "  -f, --format=FMT output format, FMT according to strftime(3)\n"
100         "                   (default: \"%s\")\n"
101         "  -r, --ref=N      use N seconds since epoch as reference time\n"
102         "                   (default: now)\n"
103         "  -u, --^          round result up inclusive (default: no rounding)\n"
104         "  -U, --^^         round result up (default: no rounding)\n"
105         "  -d, --_          round result down (default: no rounding)\n"
106         "  -h, --help       print this help\n",
107         DEFAULT_FORMAT);
108 }
109
110 struct {
111     const char *operator;
112     int round;
113 } operators[] = {
114     { "==>",    PARSE_TIME_NO_ROUND },
115     { "==_>",   PARSE_TIME_ROUND_DOWN },
116     { "==^>",   PARSE_TIME_ROUND_UP_INCLUSIVE },
117     { "==^^>",  PARSE_TIME_ROUND_UP },
118 };
119
120 static const char *
121 find_operator_in_string (char *str, char **ptr, int *round)
122 {
123     const char *oper = NULL;
124     unsigned int i;
125
126     for (i = 0; i < ARRAY_SIZE (operators); i++) {
127         char *p = strstr (str, operators[i].operator);
128         if (p) {
129             if (round)
130                 *round = operators[i].round;
131             if (ptr)
132                 *ptr = p;
133
134             oper = operators[i].operator;
135             break;
136         }
137     }
138
139     return oper;
140 }
141
142 static const char *
143 get_operator (int round)
144 {
145     const char *oper = NULL;
146     unsigned int i;
147
148     for (i = 0; i < ARRAY_SIZE(operators); i++) {
149         if (round == operators[i].round) {
150             oper = operators[i].operator;
151             break;
152         }
153     }
154
155     return oper;
156 }
157
158 static int
159 parse_stdin (FILE *infile, time_t *ref, int round, const char *format)
160 {
161     char *input = NULL;
162     char result[1024];
163     size_t inputsize;
164     ssize_t len;
165     struct tm tm;
166     time_t t;
167     int r;
168
169     while ((len = getline (&input, &inputsize, infile)) != -1) {
170         const char *oper;
171         char *trail, *tmp;
172
173         /* trail is trailing whitespace and (optional) comment */
174         trail = strchr (input, '#');
175         if (!trail)
176             trail = input + len;
177
178         while (trail > input && isspace ((unsigned char) *(trail-1)))
179             trail--;
180
181         if (trail == input) {
182             printf ("%s", input);
183             continue;
184         }
185
186         tmp = strdup (trail);
187         if (!tmp) {
188             fprintf (stderr, "strdup() failed\n");
189             continue;
190         }
191         *trail = '\0';
192         trail = tmp;
193
194         /* operator */
195         oper = find_operator_in_string (input, &tmp, &round);
196         if (oper) {
197             *tmp = '\0';
198         } else {
199             oper = get_operator (round);
200             assert (oper);
201         }
202
203         r = parse_time_string (input, &t, ref, round);
204         if (!r) {
205             if (!localtime_r (&t, &tm)) {
206                 fprintf (stderr, "localtime_r() failed\n");
207                 free (trail);
208                 continue;
209             }
210
211             strftime (result, sizeof (result), format, &tm);
212         } else {
213             const char *errstr = parse_time_strerror (r);
214             if (errstr)
215                 snprintf (result, sizeof (result), "ERROR: %s", errstr);
216             else
217                 snprintf (result, sizeof (result), "ERROR: %d", r);
218         }
219
220         printf ("%s%s %s%s", input, oper, result, trail);
221         free (trail);
222     }
223
224     free (input);
225
226     return 0;
227 }
228
229 int
230 main (int argc, char *argv[])
231 {
232     int r;
233     struct tm tm;
234     time_t result;
235     time_t now;
236     time_t *nowp = NULL;
237     char *argstr;
238     int round = PARSE_TIME_NO_ROUND;
239     char buf[1024];
240     const char *format = DEFAULT_FORMAT;
241     struct option options[] = {
242         { "help",       no_argument,            NULL,   'h' },
243         { "^",          no_argument,            NULL,   'u' },
244         { "^^",         no_argument,            NULL,   'U' },
245         { "_",          no_argument,            NULL,   'd' },
246         { "format",     required_argument,      NULL,   'f' },
247         { "ref",        required_argument,      NULL,   'r' },
248         { NULL, 0, NULL, 0 },
249     };
250
251     for (;;) {
252         int c;
253
254         c = getopt_long (argc, argv, "huUdf:r:", options, NULL);
255         if (c == -1)
256             break;
257
258         switch (c) {
259         case 'f':
260             /* output format */
261             format = optarg;
262             break;
263         case 'u':
264             round = PARSE_TIME_ROUND_UP_INCLUSIVE;
265             break;
266         case 'U':
267             round = PARSE_TIME_ROUND_UP;
268             break;
269         case 'd':
270             round = PARSE_TIME_ROUND_DOWN;
271             break;
272         case 'r':
273             /* specify now in seconds since epoch */
274             now = (time_t) strtol (optarg, NULL, 10);
275             if (now >= (time_t) 0)
276                 nowp = &now;
277             break;
278         case 'h':
279         case '?':
280         default:
281             usage (argv[0]);
282             return 1;
283         }
284     }
285
286     if (optind == argc)
287         return parse_stdin (stdin, nowp, round, format);
288
289     argstr = concat_args (optind, argc, argv);
290     if (!argstr)
291         return 1;
292
293     r = parse_time_string (argstr, &result, nowp, round);
294
295     free (argstr);
296
297     if (r) {
298         const char *errstr = parse_time_strerror (r);
299         if (errstr)
300             fprintf (stderr, "ERROR: %s\n", errstr);
301         else
302             fprintf (stderr, "ERROR: %d\n", r);
303
304         return r;
305     }
306
307     if (!localtime_r (&result, &tm))
308         return 1;
309
310     strftime (buf, sizeof (buf), format, &tm);
311     printf ("%s\n", buf);
312
313     return 0;
314 }