2005-04-30 16:46:49 +00:00
|
|
|
/*
|
|
|
|
* GIT - The information manager from hell
|
|
|
|
*
|
|
|
|
* Copyright (C) Linus Torvalds, 2005
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <time.h>
|
git's rev-parse.c function show_datestring presumes gnu date
Ok. This is the insane patch to do this.
It really isn't very careful, and the reason I call it "approxidate()"
will become obvious when you look at the code. It is very liberal in what
it accepts, to the point where sometimes the results may not make a whole
lot of sense.
It accepts "last week" as a date string, by virtue of "last" parsing as
the number 1, and it totally ignoring superfluous fluff like "ago", so
"last week" ends up being exactly the same thing as "1 week ago". Fine so
far.
It has strange side effects: "last december" will actually parse as "Dec
1", which actually _does_ turn out right, because it will then notice that
it's not December yet, so it will decide that you must be talking about a
date last year. So it actually gets it right, but it's kind of for the
"wrong" reasons.
It also accepts the numbers 1..10 in string format ("one" .. "ten"), so
you can do "ten weeks ago" or "ten hours ago" and it will do the right
thing.
But it will do some really strange thigns too: the string "this will last
forever", will not recognize anyting but "last", which is recognized as
"1", which since it doesn't understand anything else it will think is the
day of the month. So if you do
gitk --since="this will last forever"
the date will actually parse as the first day of the current month.
And it will parse the string "now" as "now", but only because it doesn't
understand it at all, and it makes everything relative to "now".
Similarly, it doesn't actually parse the "ago" or "from now", so "2 weeks
ago" is exactly the same as "2 weeks from now". It's the current date
minus 14 days.
But hey, it's probably better (and certainly faster) than depending on GNU
date. So now you can portably do things like
gitk --since="two weeks and three days ago"
git log --since="July 5"
git-whatchanged --since="10 hours ago"
git log --since="last october"
and it will actually do exactly what you thought it would do (I think). It
will count 17 days backwards, and it will do so even if you don't have GNU
date installed.
(I don't do "last monday" or similar yet, but I can extend it to that too
if people want).
It was kind of fun trying to write code that uses such totally relaxed
"understanding" of dates yet tries to get it right for the trivial cases.
The result should be mixed with a few strange preprocessor tricks, and be
submitted for the IOCCC ;)
Feel free to try it out, and see how many strange dates it gets right. Or
wrong.
And if you find some interesting (and valid - not "interesting" as in
"strange", but "interesting" as in "I'd be interested in actually doing
this) thing it gets wrong - usually by not understanding it and silently
just doing some strange things - please holler.
Now, as usual this certainly hasn't been getting a lot of testing. But my
code always works, no?
Linus
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-11-15 03:29:06 +00:00
|
|
|
#include <sys/time.h>
|
2005-04-30 16:46:49 +00:00
|
|
|
|
2005-05-20 18:46:10 +00:00
|
|
|
#include "cache.h"
|
|
|
|
|
2005-04-30 16:46:49 +00:00
|
|
|
static time_t my_mktime(struct tm *tm)
|
|
|
|
{
|
|
|
|
static const int mdays[] = {
|
|
|
|
0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334
|
|
|
|
};
|
|
|
|
int year = tm->tm_year - 70;
|
|
|
|
int month = tm->tm_mon;
|
|
|
|
int day = tm->tm_mday;
|
|
|
|
|
|
|
|
if (year < 0 || year > 129) /* algo only works for 1970-2099 */
|
|
|
|
return -1;
|
|
|
|
if (month < 0 || month > 11) /* array bounds */
|
|
|
|
return -1;
|
|
|
|
if (month < 2 || (year + 2) % 4)
|
|
|
|
day--;
|
|
|
|
return (year * 365 + (year + 1) / 4 + mdays[month] + day) * 24*60*60UL +
|
|
|
|
tm->tm_hour * 60*60 + tm->tm_min * 60 + tm->tm_sec;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const char *month_names[] = {
|
2005-04-30 20:19:56 +00:00
|
|
|
"January", "February", "March", "April", "May", "June",
|
|
|
|
"July", "August", "September", "October", "November", "December"
|
2005-04-30 16:46:49 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static const char *weekday_names[] = {
|
Teach "approxidate" about weekday syntax
This allows people to use syntax like "last thursday" for the approxidate.
(Or, indeed, more complex "three thursdays ago", but I suspect that would
be pretty unusual).
NOTE! The parsing is strictly sequential, so if you do
"one day before last thursday"
it will _not_ do what you think it does. It will take the current time,
subtract one day, and then go back to the thursday before that. So to get
what you want, you'd have to write it the other way around:
"last thursday and one day before"
which is insane (it's usually the same as "last wednesday" _except_ if
today is Thursday, in which case "last wednesday" is yesterday, and "last
thursday and one day before" is eight days ago).
Similarly,
"last thursday one month ago"
will first go back to last thursday, and then go back one month from
there, not the other way around.
I doubt anybody would ever use insane dates like that, but I thought I'd
point out that the approxidate parsing is not exactly "standard English".
Side note 2: if you want to avoid spaces (because of quoting issues), you
can use any non-alphanumberic character instead. So
git log --since=2.days.ago
works without any quotes.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-11-17 20:36:30 +00:00
|
|
|
"Sundays", "Mondays", "Tuesdays", "Wednesdays", "Thursdays", "Fridays", "Saturdays"
|
2005-04-30 16:46:49 +00:00
|
|
|
};
|
|
|
|
|
2005-05-06 22:28:59 +00:00
|
|
|
/*
|
|
|
|
* The "tz" thing is passed in as this strange "decimal parse of tz"
|
|
|
|
* thing, which means that tz -0100 is passed in as the integer -100,
|
|
|
|
* even though it means "sixty minutes off"
|
|
|
|
*/
|
|
|
|
const char *show_date(unsigned long time, int tz)
|
|
|
|
{
|
|
|
|
struct tm *tm;
|
|
|
|
time_t t;
|
|
|
|
static char timebuf[200];
|
|
|
|
int minutes;
|
|
|
|
|
|
|
|
minutes = tz < 0 ? -tz : tz;
|
2005-05-18 21:11:07 +00:00
|
|
|
minutes = (minutes / 100)*60 + (minutes % 100);
|
2005-05-06 22:28:59 +00:00
|
|
|
minutes = tz < 0 ? -minutes : minutes;
|
2005-05-18 21:11:07 +00:00
|
|
|
t = time + minutes * 60;
|
2005-05-06 22:28:59 +00:00
|
|
|
tm = gmtime(&t);
|
|
|
|
if (!tm)
|
|
|
|
return NULL;
|
|
|
|
sprintf(timebuf, "%.3s %.3s %d %02d:%02d:%02d %d %+05d",
|
|
|
|
weekday_names[tm->tm_wday],
|
|
|
|
month_names[tm->tm_mon],
|
|
|
|
tm->tm_mday,
|
|
|
|
tm->tm_hour, tm->tm_min, tm->tm_sec,
|
|
|
|
tm->tm_year + 1900, tz);
|
|
|
|
return timebuf;
|
|
|
|
}
|
|
|
|
|
2005-04-30 20:19:56 +00:00
|
|
|
/*
|
|
|
|
* Check these. And note how it doesn't do the summer-time conversion.
|
|
|
|
*
|
|
|
|
* In my world, it's always summer, and things are probably a bit off
|
|
|
|
* in other ways too.
|
|
|
|
*/
|
|
|
|
static const struct {
|
|
|
|
const char *name;
|
|
|
|
int offset;
|
2005-04-30 21:53:12 +00:00
|
|
|
int dst;
|
2005-04-30 20:19:56 +00:00
|
|
|
} timezone_names[] = {
|
2005-04-30 21:53:12 +00:00
|
|
|
{ "IDLW", -12, 0, }, /* International Date Line West */
|
|
|
|
{ "NT", -11, 0, }, /* Nome */
|
|
|
|
{ "CAT", -10, 0, }, /* Central Alaska */
|
|
|
|
{ "HST", -10, 0, }, /* Hawaii Standard */
|
|
|
|
{ "HDT", -10, 1, }, /* Hawaii Daylight */
|
|
|
|
{ "YST", -9, 0, }, /* Yukon Standard */
|
|
|
|
{ "YDT", -9, 1, }, /* Yukon Daylight */
|
|
|
|
{ "PST", -8, 0, }, /* Pacific Standard */
|
|
|
|
{ "PDT", -8, 1, }, /* Pacific Daylight */
|
|
|
|
{ "MST", -7, 0, }, /* Mountain Standard */
|
|
|
|
{ "MDT", -7, 1, }, /* Mountain Daylight */
|
|
|
|
{ "CST", -6, 0, }, /* Central Standard */
|
|
|
|
{ "CDT", -6, 1, }, /* Central Daylight */
|
|
|
|
{ "EST", -5, 0, }, /* Eastern Standard */
|
|
|
|
{ "EDT", -5, 1, }, /* Eastern Daylight */
|
|
|
|
{ "AST", -3, 0, }, /* Atlantic Standard */
|
|
|
|
{ "ADT", -3, 1, }, /* Atlantic Daylight */
|
|
|
|
{ "WAT", -1, 0, }, /* West Africa */
|
|
|
|
|
|
|
|
{ "GMT", 0, 0, }, /* Greenwich Mean */
|
|
|
|
{ "UTC", 0, 0, }, /* Universal (Coordinated) */
|
|
|
|
|
|
|
|
{ "WET", 0, 0, }, /* Western European */
|
|
|
|
{ "BST", 0, 1, }, /* British Summer */
|
|
|
|
{ "CET", +1, 0, }, /* Central European */
|
|
|
|
{ "MET", +1, 0, }, /* Middle European */
|
|
|
|
{ "MEWT", +1, 0, }, /* Middle European Winter */
|
|
|
|
{ "MEST", +1, 1, }, /* Middle European Summer */
|
|
|
|
{ "CEST", +1, 1, }, /* Central European Summer */
|
|
|
|
{ "MESZ", +1, 1, }, /* Middle European Summer */
|
|
|
|
{ "FWT", +1, 0, }, /* French Winter */
|
|
|
|
{ "FST", +1, 1, }, /* French Summer */
|
|
|
|
{ "EET", +2, 0, }, /* Eastern Europe, USSR Zone 1 */
|
2005-04-30 22:21:57 +00:00
|
|
|
{ "EEST", +2, 1, }, /* Eastern European Daylight */
|
2005-04-30 21:53:12 +00:00
|
|
|
{ "WAST", +7, 0, }, /* West Australian Standard */
|
|
|
|
{ "WADT", +7, 1, }, /* West Australian Daylight */
|
|
|
|
{ "CCT", +8, 0, }, /* China Coast, USSR Zone 7 */
|
|
|
|
{ "JST", +9, 0, }, /* Japan Standard, USSR Zone 8 */
|
|
|
|
{ "EAST", +10, 0, }, /* Eastern Australian Standard */
|
|
|
|
{ "EADT", +10, 1, }, /* Eastern Australian Daylight */
|
|
|
|
{ "GST", +10, 0, }, /* Guam Standard, USSR Zone 9 */
|
|
|
|
{ "NZT", +11, 0, }, /* New Zealand */
|
|
|
|
{ "NZST", +11, 0, }, /* New Zealand Standard */
|
|
|
|
{ "NZDT", +11, 1, }, /* New Zealand Daylight */
|
|
|
|
{ "IDLE", +12, 0, }, /* International Date Line East */
|
2005-04-30 20:19:56 +00:00
|
|
|
};
|
2005-04-30 16:46:49 +00:00
|
|
|
|
2005-04-30 20:19:56 +00:00
|
|
|
#define NR_TZ (sizeof(timezone_names) / sizeof(timezone_names[0]))
|
|
|
|
|
|
|
|
static int match_string(const char *date, const char *str)
|
2005-04-30 16:46:49 +00:00
|
|
|
{
|
2005-04-30 20:19:56 +00:00
|
|
|
int i = 0;
|
|
|
|
|
|
|
|
for (i = 0; *date; date++, str++, i++) {
|
|
|
|
if (*date == *str)
|
|
|
|
continue;
|
|
|
|
if (toupper(*date) == toupper(*str))
|
|
|
|
continue;
|
|
|
|
if (!isalnum(*date))
|
|
|
|
break;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return i;
|
2005-04-30 16:46:49 +00:00
|
|
|
}
|
|
|
|
|
2005-05-01 19:34:56 +00:00
|
|
|
static int skip_alpha(const char *date)
|
|
|
|
{
|
|
|
|
int i = 0;
|
|
|
|
do {
|
|
|
|
i++;
|
|
|
|
} while (isalpha(date[i]));
|
|
|
|
return i;
|
|
|
|
}
|
|
|
|
|
2005-04-30 20:19:56 +00:00
|
|
|
/*
|
|
|
|
* Parse month, weekday, or timezone name
|
|
|
|
*/
|
|
|
|
static int match_alpha(const char *date, struct tm *tm, int *offset)
|
2005-04-30 16:46:49 +00:00
|
|
|
{
|
2005-04-30 20:19:56 +00:00
|
|
|
int i;
|
2005-04-30 16:46:49 +00:00
|
|
|
|
2005-04-30 20:19:56 +00:00
|
|
|
for (i = 0; i < 12; i++) {
|
|
|
|
int match = match_string(date, month_names[i]);
|
|
|
|
if (match >= 3) {
|
|
|
|
tm->tm_mon = i;
|
|
|
|
return match;
|
2005-04-30 16:46:49 +00:00
|
|
|
}
|
2005-04-30 20:19:56 +00:00
|
|
|
}
|
2005-04-30 16:46:49 +00:00
|
|
|
|
2005-04-30 20:19:56 +00:00
|
|
|
for (i = 0; i < 7; i++) {
|
|
|
|
int match = match_string(date, weekday_names[i]);
|
|
|
|
if (match >= 3) {
|
|
|
|
tm->tm_wday = i;
|
|
|
|
return match;
|
|
|
|
}
|
|
|
|
}
|
2005-04-30 16:46:49 +00:00
|
|
|
|
2005-04-30 20:19:56 +00:00
|
|
|
for (i = 0; i < NR_TZ; i++) {
|
|
|
|
int match = match_string(date, timezone_names[i].name);
|
|
|
|
if (match >= 3) {
|
2005-04-30 21:53:12 +00:00
|
|
|
int off = timezone_names[i].offset;
|
|
|
|
|
|
|
|
/* This is bogus, but we like summer */
|
|
|
|
off += timezone_names[i].dst;
|
|
|
|
|
2005-04-30 22:21:57 +00:00
|
|
|
/* Only use the tz name offset if we don't have anything better */
|
|
|
|
if (*offset == -1)
|
|
|
|
*offset = 60*off;
|
|
|
|
|
2005-04-30 20:19:56 +00:00
|
|
|
return match;
|
2005-04-30 16:46:49 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-05-01 19:34:56 +00:00
|
|
|
if (match_string(date, "PM") == 2) {
|
|
|
|
if (tm->tm_hour > 0 && tm->tm_hour < 12)
|
|
|
|
tm->tm_hour += 12;
|
|
|
|
return 2;
|
|
|
|
}
|
|
|
|
|
2005-04-30 20:19:56 +00:00
|
|
|
/* BAD CRAP */
|
2005-05-01 19:34:56 +00:00
|
|
|
return skip_alpha(date);
|
2005-04-30 20:19:56 +00:00
|
|
|
}
|
2005-04-30 16:46:49 +00:00
|
|
|
|
2005-05-01 18:48:34 +00:00
|
|
|
static int is_date(int year, int month, int day, struct tm *tm)
|
2005-04-30 20:19:56 +00:00
|
|
|
{
|
2005-05-01 18:48:34 +00:00
|
|
|
if (month > 0 && month < 13 && day > 0 && day < 32) {
|
|
|
|
if (year == -1) {
|
|
|
|
tm->tm_mon = month-1;
|
|
|
|
tm->tm_mday = day;
|
|
|
|
return 1;
|
2005-04-30 20:19:56 +00:00
|
|
|
}
|
2005-05-01 18:48:34 +00:00
|
|
|
if (year >= 1970 && year < 2100) {
|
|
|
|
year -= 1900;
|
|
|
|
} else if (year > 70 && year < 100) {
|
|
|
|
/* ok */
|
|
|
|
} else if (year < 38) {
|
|
|
|
year += 100;
|
|
|
|
} else
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
tm->tm_mon = month-1;
|
|
|
|
tm->tm_mday = day;
|
|
|
|
tm->tm_year = year;
|
|
|
|
return 1;
|
2005-04-30 20:19:56 +00:00
|
|
|
}
|
2005-05-01 18:48:34 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2005-04-30 16:46:49 +00:00
|
|
|
|
2005-07-12 17:33:06 +00:00
|
|
|
static int match_multi_number(unsigned long num, char c, const char *date, char *end, struct tm *tm)
|
2005-05-01 18:48:34 +00:00
|
|
|
{
|
|
|
|
long num2, num3;
|
|
|
|
|
|
|
|
num2 = strtol(end+1, &end, 10);
|
|
|
|
num3 = -1;
|
|
|
|
if (*end == c && isdigit(end[1]))
|
|
|
|
num3 = strtol(end+1, &end, 10);
|
|
|
|
|
|
|
|
/* Time? Date? */
|
2005-04-30 20:19:56 +00:00
|
|
|
switch (c) {
|
2005-05-01 18:48:34 +00:00
|
|
|
case ':':
|
|
|
|
if (num3 < 0)
|
|
|
|
num3 = 0;
|
|
|
|
if (num < 25 && num2 >= 0 && num2 < 60 && num3 >= 0 && num3 <= 60) {
|
|
|
|
tm->tm_hour = num;
|
|
|
|
tm->tm_min = num2;
|
|
|
|
tm->tm_sec = num3;
|
2005-04-30 20:19:56 +00:00
|
|
|
break;
|
|
|
|
}
|
2005-05-01 18:48:34 +00:00
|
|
|
return 0;
|
2005-04-30 20:19:56 +00:00
|
|
|
|
|
|
|
case '-':
|
|
|
|
case '/':
|
2005-05-01 18:48:34 +00:00
|
|
|
if (num > 70) {
|
|
|
|
/* yyyy-mm-dd? */
|
|
|
|
if (is_date(num, num2, num3, tm))
|
|
|
|
break;
|
|
|
|
/* yyyy-dd-mm? */
|
|
|
|
if (is_date(num, num3, num2, tm))
|
2005-04-30 20:19:56 +00:00
|
|
|
break;
|
2005-05-01 18:48:34 +00:00
|
|
|
}
|
|
|
|
/* mm/dd/yy ? */
|
|
|
|
if (is_date(num3, num2, num, tm))
|
2005-04-30 20:19:56 +00:00
|
|
|
break;
|
2005-05-01 18:48:34 +00:00
|
|
|
/* dd/mm/yy ? */
|
|
|
|
if (is_date(num3, num, num2, tm))
|
|
|
|
break;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return end - date;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We've seen a digit. Time? Year? Date?
|
|
|
|
*/
|
2005-07-12 17:33:06 +00:00
|
|
|
static int match_digit(const char *date, struct tm *tm, int *offset, int *tm_gmt)
|
2005-05-01 18:48:34 +00:00
|
|
|
{
|
|
|
|
int n;
|
|
|
|
char *end;
|
|
|
|
unsigned long num;
|
|
|
|
|
|
|
|
num = strtoul(date, &end, 10);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Seconds since 1970? We trigger on that for anything after Jan 1, 2000
|
|
|
|
*/
|
|
|
|
if (num > 946684800) {
|
|
|
|
time_t time = num;
|
2005-06-25 09:21:16 +00:00
|
|
|
if (gmtime_r(&time, tm)) {
|
|
|
|
*tm_gmt = 1;
|
2005-05-01 18:48:34 +00:00
|
|
|
return end - date;
|
2005-06-25 09:21:16 +00:00
|
|
|
}
|
2005-05-01 18:48:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check for special formats: num[:-/]num[same]num
|
|
|
|
*/
|
|
|
|
switch (*end) {
|
|
|
|
case ':':
|
|
|
|
case '/':
|
|
|
|
case '-':
|
|
|
|
if (isdigit(end[1])) {
|
|
|
|
int match = match_multi_number(num, *end, date, end, tm);
|
|
|
|
if (match)
|
|
|
|
return match;
|
2005-04-30 20:19:56 +00:00
|
|
|
}
|
|
|
|
}
|
2005-05-01 18:48:34 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* None of the special formats? Try to guess what
|
|
|
|
* the number meant. We use the number of digits
|
|
|
|
* to make a more educated guess..
|
|
|
|
*/
|
|
|
|
n = 0;
|
|
|
|
do {
|
|
|
|
n++;
|
|
|
|
} while (isdigit(date[n]));
|
|
|
|
|
|
|
|
/* Four-digit year or a timezone? */
|
|
|
|
if (n == 4) {
|
|
|
|
if (num <= 1200 && *offset == -1) {
|
|
|
|
unsigned int minutes = num % 100;
|
|
|
|
unsigned int hours = num / 100;
|
|
|
|
*offset = hours*60 + minutes;
|
|
|
|
} else if (num > 1900 && num < 2100)
|
|
|
|
tm->tm_year = num - 1900;
|
|
|
|
return n;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* NOTE! We will give precedence to day-of-month over month or
|
2005-12-29 09:30:08 +00:00
|
|
|
* year numbers in the 1-12 range. So 05 is always "mday 5",
|
2005-05-01 18:48:34 +00:00
|
|
|
* unless we already have a mday..
|
|
|
|
*
|
|
|
|
* IOW, 01 Apr 05 parses as "April 1st, 2005".
|
|
|
|
*/
|
|
|
|
if (num > 0 && num < 32 && tm->tm_mday < 0) {
|
|
|
|
tm->tm_mday = num;
|
|
|
|
return n;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Two-digit year? */
|
|
|
|
if (n == 2 && tm->tm_year < 0) {
|
|
|
|
if (num < 10 && tm->tm_mday >= 0) {
|
|
|
|
tm->tm_year = num + 100;
|
|
|
|
return n;
|
|
|
|
}
|
|
|
|
if (num >= 70) {
|
|
|
|
tm->tm_year = num;
|
|
|
|
return n;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (num > 0 && num < 32) {
|
|
|
|
tm->tm_mday = num;
|
|
|
|
} else if (num > 1900) {
|
|
|
|
tm->tm_year = num - 1900;
|
|
|
|
} else if (num > 70) {
|
|
|
|
tm->tm_year = num;
|
|
|
|
} else if (num > 0 && num < 13) {
|
|
|
|
tm->tm_mon = num-1;
|
|
|
|
}
|
2005-04-30 16:46:49 +00:00
|
|
|
|
2005-05-01 18:48:34 +00:00
|
|
|
return n;
|
2005-04-30 20:19:56 +00:00
|
|
|
}
|
2005-04-30 16:46:49 +00:00
|
|
|
|
2005-07-12 17:33:06 +00:00
|
|
|
static int match_tz(const char *date, int *offp)
|
2005-04-30 20:19:56 +00:00
|
|
|
{
|
|
|
|
char *end;
|
|
|
|
int offset = strtoul(date+1, &end, 10);
|
|
|
|
int min, hour;
|
2005-05-01 18:48:34 +00:00
|
|
|
int n = end - date - 1;
|
2005-04-30 16:46:49 +00:00
|
|
|
|
2005-04-30 20:19:56 +00:00
|
|
|
min = offset % 100;
|
|
|
|
hour = offset / 100;
|
2005-04-30 16:46:49 +00:00
|
|
|
|
2005-05-01 18:48:34 +00:00
|
|
|
/*
|
|
|
|
* Don't accept any random crap.. At least 3 digits, and
|
|
|
|
* a valid minute. We might want to check that the minutes
|
|
|
|
* are divisible by 30 or something too.
|
|
|
|
*/
|
2005-05-01 19:34:56 +00:00
|
|
|
if (min < 60 && n > 2) {
|
|
|
|
offset = hour*60+min;
|
|
|
|
if (*date == '-')
|
|
|
|
offset = -offset;
|
2005-04-30 16:46:49 +00:00
|
|
|
|
2005-05-01 19:34:56 +00:00
|
|
|
*offp = offset;
|
|
|
|
}
|
2005-04-30 20:19:56 +00:00
|
|
|
return end - date;
|
|
|
|
}
|
2005-04-30 16:46:49 +00:00
|
|
|
|
2005-09-21 22:50:28 +00:00
|
|
|
static int date_string(unsigned long date, int offset, char *buf, int len)
|
|
|
|
{
|
|
|
|
int sign = '+';
|
|
|
|
|
|
|
|
if (offset < 0) {
|
|
|
|
offset = -offset;
|
|
|
|
sign = '-';
|
|
|
|
}
|
|
|
|
return snprintf(buf, len, "%lu %c%02d%02d", date, sign, offset / 60, offset % 60);
|
|
|
|
}
|
|
|
|
|
2005-04-30 20:19:56 +00:00
|
|
|
/* Gr. strptime is crap for this; it doesn't have a way to require RFC2822
|
|
|
|
(i.e. English) day/month names, and it doesn't work correctly with %z. */
|
2005-09-19 22:53:50 +00:00
|
|
|
int parse_date(const char *date, char *result, int maxlen)
|
2005-04-30 20:19:56 +00:00
|
|
|
{
|
|
|
|
struct tm tm;
|
2005-09-21 22:50:28 +00:00
|
|
|
int offset, tm_gmt;
|
2005-04-30 20:19:56 +00:00
|
|
|
time_t then;
|
2005-04-30 16:46:49 +00:00
|
|
|
|
2005-04-30 20:19:56 +00:00
|
|
|
memset(&tm, 0, sizeof(tm));
|
|
|
|
tm.tm_year = -1;
|
|
|
|
tm.tm_mon = -1;
|
|
|
|
tm.tm_mday = -1;
|
2005-04-30 21:25:02 +00:00
|
|
|
tm.tm_isdst = -1;
|
|
|
|
offset = -1;
|
2005-06-25 09:21:16 +00:00
|
|
|
tm_gmt = 0;
|
2005-04-30 20:19:56 +00:00
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
int match = 0;
|
|
|
|
unsigned char c = *date;
|
|
|
|
|
|
|
|
/* Stop at end of string or newline */
|
|
|
|
if (!c || c == '\n')
|
|
|
|
break;
|
|
|
|
|
|
|
|
if (isalpha(c))
|
|
|
|
match = match_alpha(date, &tm, &offset);
|
|
|
|
else if (isdigit(c))
|
2005-06-25 09:21:16 +00:00
|
|
|
match = match_digit(date, &tm, &offset, &tm_gmt);
|
2005-04-30 20:19:56 +00:00
|
|
|
else if ((c == '-' || c == '+') && isdigit(date[1]))
|
|
|
|
match = match_tz(date, &offset);
|
|
|
|
|
|
|
|
if (!match) {
|
|
|
|
/* BAD CRAP */
|
|
|
|
match = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
date += match;
|
|
|
|
}
|
2005-04-30 16:46:49 +00:00
|
|
|
|
2005-04-30 21:25:02 +00:00
|
|
|
/* mktime uses local timezone */
|
|
|
|
then = my_mktime(&tm);
|
|
|
|
if (offset == -1)
|
|
|
|
offset = (then - mktime(&tm)) / 60;
|
|
|
|
|
2005-04-30 16:46:49 +00:00
|
|
|
if (then == -1)
|
2005-09-19 22:53:50 +00:00
|
|
|
return -1;
|
2005-04-30 16:46:49 +00:00
|
|
|
|
2005-06-25 09:21:16 +00:00
|
|
|
if (!tm_gmt)
|
|
|
|
then -= offset * 60;
|
2005-09-21 22:50:28 +00:00
|
|
|
return date_string(then, offset, result, maxlen);
|
2005-04-30 16:46:49 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void datestamp(char *buf, int bufsize)
|
|
|
|
{
|
|
|
|
time_t now;
|
|
|
|
int offset;
|
|
|
|
|
|
|
|
time(&now);
|
|
|
|
|
|
|
|
offset = my_mktime(localtime(&now)) - now;
|
|
|
|
offset /= 60;
|
|
|
|
|
2005-09-21 22:50:28 +00:00
|
|
|
date_string(now, offset, buf, bufsize);
|
2005-04-30 16:46:49 +00:00
|
|
|
}
|
git's rev-parse.c function show_datestring presumes gnu date
Ok. This is the insane patch to do this.
It really isn't very careful, and the reason I call it "approxidate()"
will become obvious when you look at the code. It is very liberal in what
it accepts, to the point where sometimes the results may not make a whole
lot of sense.
It accepts "last week" as a date string, by virtue of "last" parsing as
the number 1, and it totally ignoring superfluous fluff like "ago", so
"last week" ends up being exactly the same thing as "1 week ago". Fine so
far.
It has strange side effects: "last december" will actually parse as "Dec
1", which actually _does_ turn out right, because it will then notice that
it's not December yet, so it will decide that you must be talking about a
date last year. So it actually gets it right, but it's kind of for the
"wrong" reasons.
It also accepts the numbers 1..10 in string format ("one" .. "ten"), so
you can do "ten weeks ago" or "ten hours ago" and it will do the right
thing.
But it will do some really strange thigns too: the string "this will last
forever", will not recognize anyting but "last", which is recognized as
"1", which since it doesn't understand anything else it will think is the
day of the month. So if you do
gitk --since="this will last forever"
the date will actually parse as the first day of the current month.
And it will parse the string "now" as "now", but only because it doesn't
understand it at all, and it makes everything relative to "now".
Similarly, it doesn't actually parse the "ago" or "from now", so "2 weeks
ago" is exactly the same as "2 weeks from now". It's the current date
minus 14 days.
But hey, it's probably better (and certainly faster) than depending on GNU
date. So now you can portably do things like
gitk --since="two weeks and three days ago"
git log --since="July 5"
git-whatchanged --since="10 hours ago"
git log --since="last october"
and it will actually do exactly what you thought it would do (I think). It
will count 17 days backwards, and it will do so even if you don't have GNU
date installed.
(I don't do "last monday" or similar yet, but I can extend it to that too
if people want).
It was kind of fun trying to write code that uses such totally relaxed
"understanding" of dates yet tries to get it right for the trivial cases.
The result should be mixed with a few strange preprocessor tricks, and be
submitted for the IOCCC ;)
Feel free to try it out, and see how many strange dates it gets right. Or
wrong.
And if you find some interesting (and valid - not "interesting" as in
"strange", but "interesting" as in "I'd be interested in actually doing
this) thing it gets wrong - usually by not understanding it and silently
just doing some strange things - please holler.
Now, as usual this certainly hasn't been getting a lot of testing. But my
code always works, no?
Linus
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-11-15 03:29:06 +00:00
|
|
|
|
|
|
|
static void update_tm(struct tm *tm, unsigned long sec)
|
|
|
|
{
|
|
|
|
time_t n = mktime(tm) - sec;
|
|
|
|
localtime_r(&n, tm);
|
|
|
|
}
|
|
|
|
|
2005-11-18 16:56:40 +00:00
|
|
|
static void date_yesterday(struct tm *tm, int *num)
|
|
|
|
{
|
|
|
|
update_tm(tm, 24*60*60);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void date_time(struct tm *tm, int hour)
|
|
|
|
{
|
|
|
|
if (tm->tm_hour < hour)
|
|
|
|
date_yesterday(tm, NULL);
|
|
|
|
tm->tm_hour = hour;
|
|
|
|
tm->tm_min = 0;
|
|
|
|
tm->tm_sec = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void date_midnight(struct tm *tm, int *num)
|
|
|
|
{
|
|
|
|
date_time(tm, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void date_noon(struct tm *tm, int *num)
|
|
|
|
{
|
|
|
|
date_time(tm, 12);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void date_tea(struct tm *tm, int *num)
|
|
|
|
{
|
|
|
|
date_time(tm, 17);
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct special {
|
|
|
|
const char *name;
|
|
|
|
void (*fn)(struct tm *, int *);
|
|
|
|
} special[] = {
|
|
|
|
{ "yesterday", date_yesterday },
|
|
|
|
{ "noon", date_noon },
|
|
|
|
{ "midnight", date_midnight },
|
|
|
|
{ "tea", date_tea },
|
|
|
|
{ NULL }
|
|
|
|
};
|
|
|
|
|
git's rev-parse.c function show_datestring presumes gnu date
Ok. This is the insane patch to do this.
It really isn't very careful, and the reason I call it "approxidate()"
will become obvious when you look at the code. It is very liberal in what
it accepts, to the point where sometimes the results may not make a whole
lot of sense.
It accepts "last week" as a date string, by virtue of "last" parsing as
the number 1, and it totally ignoring superfluous fluff like "ago", so
"last week" ends up being exactly the same thing as "1 week ago". Fine so
far.
It has strange side effects: "last december" will actually parse as "Dec
1", which actually _does_ turn out right, because it will then notice that
it's not December yet, so it will decide that you must be talking about a
date last year. So it actually gets it right, but it's kind of for the
"wrong" reasons.
It also accepts the numbers 1..10 in string format ("one" .. "ten"), so
you can do "ten weeks ago" or "ten hours ago" and it will do the right
thing.
But it will do some really strange thigns too: the string "this will last
forever", will not recognize anyting but "last", which is recognized as
"1", which since it doesn't understand anything else it will think is the
day of the month. So if you do
gitk --since="this will last forever"
the date will actually parse as the first day of the current month.
And it will parse the string "now" as "now", but only because it doesn't
understand it at all, and it makes everything relative to "now".
Similarly, it doesn't actually parse the "ago" or "from now", so "2 weeks
ago" is exactly the same as "2 weeks from now". It's the current date
minus 14 days.
But hey, it's probably better (and certainly faster) than depending on GNU
date. So now you can portably do things like
gitk --since="two weeks and three days ago"
git log --since="July 5"
git-whatchanged --since="10 hours ago"
git log --since="last october"
and it will actually do exactly what you thought it would do (I think). It
will count 17 days backwards, and it will do so even if you don't have GNU
date installed.
(I don't do "last monday" or similar yet, but I can extend it to that too
if people want).
It was kind of fun trying to write code that uses such totally relaxed
"understanding" of dates yet tries to get it right for the trivial cases.
The result should be mixed with a few strange preprocessor tricks, and be
submitted for the IOCCC ;)
Feel free to try it out, and see how many strange dates it gets right. Or
wrong.
And if you find some interesting (and valid - not "interesting" as in
"strange", but "interesting" as in "I'd be interested in actually doing
this) thing it gets wrong - usually by not understanding it and silently
just doing some strange things - please holler.
Now, as usual this certainly hasn't been getting a lot of testing. But my
code always works, no?
Linus
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-11-15 03:29:06 +00:00
|
|
|
static const char *number_name[] = {
|
|
|
|
"zero", "one", "two", "three", "four",
|
|
|
|
"five", "six", "seven", "eight", "nine", "ten",
|
|
|
|
};
|
|
|
|
|
2005-11-18 16:56:40 +00:00
|
|
|
static const struct typelen {
|
git's rev-parse.c function show_datestring presumes gnu date
Ok. This is the insane patch to do this.
It really isn't very careful, and the reason I call it "approxidate()"
will become obvious when you look at the code. It is very liberal in what
it accepts, to the point where sometimes the results may not make a whole
lot of sense.
It accepts "last week" as a date string, by virtue of "last" parsing as
the number 1, and it totally ignoring superfluous fluff like "ago", so
"last week" ends up being exactly the same thing as "1 week ago". Fine so
far.
It has strange side effects: "last december" will actually parse as "Dec
1", which actually _does_ turn out right, because it will then notice that
it's not December yet, so it will decide that you must be talking about a
date last year. So it actually gets it right, but it's kind of for the
"wrong" reasons.
It also accepts the numbers 1..10 in string format ("one" .. "ten"), so
you can do "ten weeks ago" or "ten hours ago" and it will do the right
thing.
But it will do some really strange thigns too: the string "this will last
forever", will not recognize anyting but "last", which is recognized as
"1", which since it doesn't understand anything else it will think is the
day of the month. So if you do
gitk --since="this will last forever"
the date will actually parse as the first day of the current month.
And it will parse the string "now" as "now", but only because it doesn't
understand it at all, and it makes everything relative to "now".
Similarly, it doesn't actually parse the "ago" or "from now", so "2 weeks
ago" is exactly the same as "2 weeks from now". It's the current date
minus 14 days.
But hey, it's probably better (and certainly faster) than depending on GNU
date. So now you can portably do things like
gitk --since="two weeks and three days ago"
git log --since="July 5"
git-whatchanged --since="10 hours ago"
git log --since="last october"
and it will actually do exactly what you thought it would do (I think). It
will count 17 days backwards, and it will do so even if you don't have GNU
date installed.
(I don't do "last monday" or similar yet, but I can extend it to that too
if people want).
It was kind of fun trying to write code that uses such totally relaxed
"understanding" of dates yet tries to get it right for the trivial cases.
The result should be mixed with a few strange preprocessor tricks, and be
submitted for the IOCCC ;)
Feel free to try it out, and see how many strange dates it gets right. Or
wrong.
And if you find some interesting (and valid - not "interesting" as in
"strange", but "interesting" as in "I'd be interested in actually doing
this) thing it gets wrong - usually by not understanding it and silently
just doing some strange things - please holler.
Now, as usual this certainly hasn't been getting a lot of testing. But my
code always works, no?
Linus
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-11-15 03:29:06 +00:00
|
|
|
const char *type;
|
|
|
|
int length;
|
|
|
|
} typelen[] = {
|
|
|
|
{ "seconds", 1 },
|
|
|
|
{ "minutes", 60 },
|
|
|
|
{ "hours", 60*60 },
|
|
|
|
{ "days", 24*60*60 },
|
|
|
|
{ "weeks", 7*24*60*60 },
|
|
|
|
{ NULL }
|
|
|
|
};
|
|
|
|
|
|
|
|
static const char *approxidate_alpha(const char *date, struct tm *tm, int *num)
|
|
|
|
{
|
2005-11-18 16:56:40 +00:00
|
|
|
const struct typelen *tl;
|
|
|
|
const struct special *s;
|
git's rev-parse.c function show_datestring presumes gnu date
Ok. This is the insane patch to do this.
It really isn't very careful, and the reason I call it "approxidate()"
will become obvious when you look at the code. It is very liberal in what
it accepts, to the point where sometimes the results may not make a whole
lot of sense.
It accepts "last week" as a date string, by virtue of "last" parsing as
the number 1, and it totally ignoring superfluous fluff like "ago", so
"last week" ends up being exactly the same thing as "1 week ago". Fine so
far.
It has strange side effects: "last december" will actually parse as "Dec
1", which actually _does_ turn out right, because it will then notice that
it's not December yet, so it will decide that you must be talking about a
date last year. So it actually gets it right, but it's kind of for the
"wrong" reasons.
It also accepts the numbers 1..10 in string format ("one" .. "ten"), so
you can do "ten weeks ago" or "ten hours ago" and it will do the right
thing.
But it will do some really strange thigns too: the string "this will last
forever", will not recognize anyting but "last", which is recognized as
"1", which since it doesn't understand anything else it will think is the
day of the month. So if you do
gitk --since="this will last forever"
the date will actually parse as the first day of the current month.
And it will parse the string "now" as "now", but only because it doesn't
understand it at all, and it makes everything relative to "now".
Similarly, it doesn't actually parse the "ago" or "from now", so "2 weeks
ago" is exactly the same as "2 weeks from now". It's the current date
minus 14 days.
But hey, it's probably better (and certainly faster) than depending on GNU
date. So now you can portably do things like
gitk --since="two weeks and three days ago"
git log --since="July 5"
git-whatchanged --since="10 hours ago"
git log --since="last october"
and it will actually do exactly what you thought it would do (I think). It
will count 17 days backwards, and it will do so even if you don't have GNU
date installed.
(I don't do "last monday" or similar yet, but I can extend it to that too
if people want).
It was kind of fun trying to write code that uses such totally relaxed
"understanding" of dates yet tries to get it right for the trivial cases.
The result should be mixed with a few strange preprocessor tricks, and be
submitted for the IOCCC ;)
Feel free to try it out, and see how many strange dates it gets right. Or
wrong.
And if you find some interesting (and valid - not "interesting" as in
"strange", but "interesting" as in "I'd be interested in actually doing
this) thing it gets wrong - usually by not understanding it and silently
just doing some strange things - please holler.
Now, as usual this certainly hasn't been getting a lot of testing. But my
code always works, no?
Linus
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-11-15 03:29:06 +00:00
|
|
|
const char *end = date;
|
|
|
|
int n = 1, i;
|
|
|
|
|
|
|
|
while (isalpha(*++end))
|
|
|
|
n++;
|
|
|
|
|
|
|
|
for (i = 0; i < 12; i++) {
|
|
|
|
int match = match_string(date, month_names[i]);
|
|
|
|
if (match >= 3) {
|
|
|
|
tm->tm_mon = i;
|
|
|
|
return end;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-11-18 16:56:40 +00:00
|
|
|
for (s = special; s->name; s++) {
|
|
|
|
int len = strlen(s->name);
|
|
|
|
if (match_string(date, s->name) == len) {
|
|
|
|
s->fn(tm, num);
|
|
|
|
return end;
|
|
|
|
}
|
git's rev-parse.c function show_datestring presumes gnu date
Ok. This is the insane patch to do this.
It really isn't very careful, and the reason I call it "approxidate()"
will become obvious when you look at the code. It is very liberal in what
it accepts, to the point where sometimes the results may not make a whole
lot of sense.
It accepts "last week" as a date string, by virtue of "last" parsing as
the number 1, and it totally ignoring superfluous fluff like "ago", so
"last week" ends up being exactly the same thing as "1 week ago". Fine so
far.
It has strange side effects: "last december" will actually parse as "Dec
1", which actually _does_ turn out right, because it will then notice that
it's not December yet, so it will decide that you must be talking about a
date last year. So it actually gets it right, but it's kind of for the
"wrong" reasons.
It also accepts the numbers 1..10 in string format ("one" .. "ten"), so
you can do "ten weeks ago" or "ten hours ago" and it will do the right
thing.
But it will do some really strange thigns too: the string "this will last
forever", will not recognize anyting but "last", which is recognized as
"1", which since it doesn't understand anything else it will think is the
day of the month. So if you do
gitk --since="this will last forever"
the date will actually parse as the first day of the current month.
And it will parse the string "now" as "now", but only because it doesn't
understand it at all, and it makes everything relative to "now".
Similarly, it doesn't actually parse the "ago" or "from now", so "2 weeks
ago" is exactly the same as "2 weeks from now". It's the current date
minus 14 days.
But hey, it's probably better (and certainly faster) than depending on GNU
date. So now you can portably do things like
gitk --since="two weeks and three days ago"
git log --since="July 5"
git-whatchanged --since="10 hours ago"
git log --since="last october"
and it will actually do exactly what you thought it would do (I think). It
will count 17 days backwards, and it will do so even if you don't have GNU
date installed.
(I don't do "last monday" or similar yet, but I can extend it to that too
if people want).
It was kind of fun trying to write code that uses such totally relaxed
"understanding" of dates yet tries to get it right for the trivial cases.
The result should be mixed with a few strange preprocessor tricks, and be
submitted for the IOCCC ;)
Feel free to try it out, and see how many strange dates it gets right. Or
wrong.
And if you find some interesting (and valid - not "interesting" as in
"strange", but "interesting" as in "I'd be interested in actually doing
this) thing it gets wrong - usually by not understanding it and silently
just doing some strange things - please holler.
Now, as usual this certainly hasn't been getting a lot of testing. But my
code always works, no?
Linus
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-11-15 03:29:06 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!*num) {
|
|
|
|
for (i = 1; i < 11; i++) {
|
|
|
|
int len = strlen(number_name[i]);
|
|
|
|
if (match_string(date, number_name[i]) == len) {
|
|
|
|
*num = i;
|
|
|
|
return end;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (match_string(date, "last") == 4)
|
|
|
|
*num = 1;
|
|
|
|
return end;
|
|
|
|
}
|
|
|
|
|
|
|
|
tl = typelen;
|
|
|
|
while (tl->type) {
|
|
|
|
int len = strlen(tl->type);
|
|
|
|
if (match_string(date, tl->type) >= len-1) {
|
|
|
|
update_tm(tm, tl->length * *num);
|
|
|
|
*num = 0;
|
|
|
|
return end;
|
|
|
|
}
|
|
|
|
tl++;
|
|
|
|
}
|
|
|
|
|
Teach "approxidate" about weekday syntax
This allows people to use syntax like "last thursday" for the approxidate.
(Or, indeed, more complex "three thursdays ago", but I suspect that would
be pretty unusual).
NOTE! The parsing is strictly sequential, so if you do
"one day before last thursday"
it will _not_ do what you think it does. It will take the current time,
subtract one day, and then go back to the thursday before that. So to get
what you want, you'd have to write it the other way around:
"last thursday and one day before"
which is insane (it's usually the same as "last wednesday" _except_ if
today is Thursday, in which case "last wednesday" is yesterday, and "last
thursday and one day before" is eight days ago).
Similarly,
"last thursday one month ago"
will first go back to last thursday, and then go back one month from
there, not the other way around.
I doubt anybody would ever use insane dates like that, but I thought I'd
point out that the approxidate parsing is not exactly "standard English".
Side note 2: if you want to avoid spaces (because of quoting issues), you
can use any non-alphanumberic character instead. So
git log --since=2.days.ago
works without any quotes.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-11-17 20:36:30 +00:00
|
|
|
for (i = 0; i < 7; i++) {
|
|
|
|
int match = match_string(date, weekday_names[i]);
|
|
|
|
if (match >= 3) {
|
|
|
|
int diff, n = *num -1;
|
|
|
|
*num = 0;
|
|
|
|
|
|
|
|
diff = tm->tm_wday - i;
|
|
|
|
if (diff <= 0)
|
|
|
|
n++;
|
|
|
|
diff += 7*n;
|
|
|
|
|
|
|
|
update_tm(tm, diff * 24 * 60 * 60);
|
|
|
|
return end;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
git's rev-parse.c function show_datestring presumes gnu date
Ok. This is the insane patch to do this.
It really isn't very careful, and the reason I call it "approxidate()"
will become obvious when you look at the code. It is very liberal in what
it accepts, to the point where sometimes the results may not make a whole
lot of sense.
It accepts "last week" as a date string, by virtue of "last" parsing as
the number 1, and it totally ignoring superfluous fluff like "ago", so
"last week" ends up being exactly the same thing as "1 week ago". Fine so
far.
It has strange side effects: "last december" will actually parse as "Dec
1", which actually _does_ turn out right, because it will then notice that
it's not December yet, so it will decide that you must be talking about a
date last year. So it actually gets it right, but it's kind of for the
"wrong" reasons.
It also accepts the numbers 1..10 in string format ("one" .. "ten"), so
you can do "ten weeks ago" or "ten hours ago" and it will do the right
thing.
But it will do some really strange thigns too: the string "this will last
forever", will not recognize anyting but "last", which is recognized as
"1", which since it doesn't understand anything else it will think is the
day of the month. So if you do
gitk --since="this will last forever"
the date will actually parse as the first day of the current month.
And it will parse the string "now" as "now", but only because it doesn't
understand it at all, and it makes everything relative to "now".
Similarly, it doesn't actually parse the "ago" or "from now", so "2 weeks
ago" is exactly the same as "2 weeks from now". It's the current date
minus 14 days.
But hey, it's probably better (and certainly faster) than depending on GNU
date. So now you can portably do things like
gitk --since="two weeks and three days ago"
git log --since="July 5"
git-whatchanged --since="10 hours ago"
git log --since="last october"
and it will actually do exactly what you thought it would do (I think). It
will count 17 days backwards, and it will do so even if you don't have GNU
date installed.
(I don't do "last monday" or similar yet, but I can extend it to that too
if people want).
It was kind of fun trying to write code that uses such totally relaxed
"understanding" of dates yet tries to get it right for the trivial cases.
The result should be mixed with a few strange preprocessor tricks, and be
submitted for the IOCCC ;)
Feel free to try it out, and see how many strange dates it gets right. Or
wrong.
And if you find some interesting (and valid - not "interesting" as in
"strange", but "interesting" as in "I'd be interested in actually doing
this) thing it gets wrong - usually by not understanding it and silently
just doing some strange things - please holler.
Now, as usual this certainly hasn't been getting a lot of testing. But my
code always works, no?
Linus
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-11-15 03:29:06 +00:00
|
|
|
if (match_string(date, "months") >= 5) {
|
|
|
|
int n = tm->tm_mon - *num;
|
|
|
|
*num = 0;
|
|
|
|
while (n < 0) {
|
|
|
|
n += 12;
|
|
|
|
tm->tm_year--;
|
|
|
|
}
|
|
|
|
tm->tm_mon = n;
|
|
|
|
return end;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (match_string(date, "years") >= 4) {
|
|
|
|
tm->tm_year -= *num;
|
|
|
|
*num = 0;
|
|
|
|
return end;
|
|
|
|
}
|
|
|
|
|
|
|
|
return end;
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned long approxidate(const char *date)
|
|
|
|
{
|
|
|
|
int number = 0;
|
|
|
|
struct tm tm, now;
|
|
|
|
struct timeval tv;
|
|
|
|
char buffer[50];
|
|
|
|
|
|
|
|
if (parse_date(date, buffer, sizeof(buffer)) > 0)
|
|
|
|
return strtoul(buffer, NULL, 10);
|
|
|
|
|
|
|
|
gettimeofday(&tv, NULL);
|
|
|
|
localtime_r(&tv.tv_sec, &tm);
|
|
|
|
now = tm;
|
|
|
|
for (;;) {
|
|
|
|
unsigned char c = *date;
|
|
|
|
if (!c)
|
|
|
|
break;
|
|
|
|
date++;
|
|
|
|
if (isdigit(c)) {
|
|
|
|
char *end;
|
|
|
|
number = strtoul(date-1, &end, 10);
|
|
|
|
date = end;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (isalpha(c))
|
|
|
|
date = approxidate_alpha(date-1, &tm, &number);
|
|
|
|
}
|
|
|
|
if (number > 0 && number < 32)
|
|
|
|
tm.tm_mday = number;
|
2006-01-05 03:33:55 +00:00
|
|
|
if (tm.tm_mon > now.tm_mon && tm.tm_year == now.tm_year)
|
git's rev-parse.c function show_datestring presumes gnu date
Ok. This is the insane patch to do this.
It really isn't very careful, and the reason I call it "approxidate()"
will become obvious when you look at the code. It is very liberal in what
it accepts, to the point where sometimes the results may not make a whole
lot of sense.
It accepts "last week" as a date string, by virtue of "last" parsing as
the number 1, and it totally ignoring superfluous fluff like "ago", so
"last week" ends up being exactly the same thing as "1 week ago". Fine so
far.
It has strange side effects: "last december" will actually parse as "Dec
1", which actually _does_ turn out right, because it will then notice that
it's not December yet, so it will decide that you must be talking about a
date last year. So it actually gets it right, but it's kind of for the
"wrong" reasons.
It also accepts the numbers 1..10 in string format ("one" .. "ten"), so
you can do "ten weeks ago" or "ten hours ago" and it will do the right
thing.
But it will do some really strange thigns too: the string "this will last
forever", will not recognize anyting but "last", which is recognized as
"1", which since it doesn't understand anything else it will think is the
day of the month. So if you do
gitk --since="this will last forever"
the date will actually parse as the first day of the current month.
And it will parse the string "now" as "now", but only because it doesn't
understand it at all, and it makes everything relative to "now".
Similarly, it doesn't actually parse the "ago" or "from now", so "2 weeks
ago" is exactly the same as "2 weeks from now". It's the current date
minus 14 days.
But hey, it's probably better (and certainly faster) than depending on GNU
date. So now you can portably do things like
gitk --since="two weeks and three days ago"
git log --since="July 5"
git-whatchanged --since="10 hours ago"
git log --since="last october"
and it will actually do exactly what you thought it would do (I think). It
will count 17 days backwards, and it will do so even if you don't have GNU
date installed.
(I don't do "last monday" or similar yet, but I can extend it to that too
if people want).
It was kind of fun trying to write code that uses such totally relaxed
"understanding" of dates yet tries to get it right for the trivial cases.
The result should be mixed with a few strange preprocessor tricks, and be
submitted for the IOCCC ;)
Feel free to try it out, and see how many strange dates it gets right. Or
wrong.
And if you find some interesting (and valid - not "interesting" as in
"strange", but "interesting" as in "I'd be interested in actually doing
this) thing it gets wrong - usually by not understanding it and silently
just doing some strange things - please holler.
Now, as usual this certainly hasn't been getting a lot of testing. But my
code always works, no?
Linus
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-11-15 03:29:06 +00:00
|
|
|
tm.tm_year--;
|
|
|
|
return mktime(&tm);
|
|
|
|
}
|