Added an initial implementation of parsedate(), parsedate_etc(), get_dateformats(),
and set_dateformats(). It's not complete yet, but already quite useful. Added a "d.m.y" to the R5 set of formats. git-svn-id: file:///srv/svn/repos/haiku/trunk/current@4367 a95241bf-73f2-0310-859d-f6bbb57e9c96
This commit is contained in:
Axel Dörfler
@@ -0,0 +1,733 @@
|
|||||||
|
/*
|
||||||
|
** Copyright 2003, Axel Dörfler, [email protected]. All rights reserved.
|
||||||
|
** Distributed under the terms of the OpenBeOS License.
|
||||||
|
*/
|
||||||
|
|
||||||
|
|
||||||
|
#include <OS.h>
|
||||||
|
#include <parsedate.h>
|
||||||
|
|
||||||
|
#include <stdlib.h>
|
||||||
|
#include <stdio.h>
|
||||||
|
#include <string.h>
|
||||||
|
#include <ctype.h>
|
||||||
|
|
||||||
|
|
||||||
|
/* The date format is as follows:
|
||||||
|
*
|
||||||
|
* a/A weekday
|
||||||
|
* d day of month
|
||||||
|
* b/B month name
|
||||||
|
* m month
|
||||||
|
* y/Y year
|
||||||
|
* H/I hours
|
||||||
|
* M minute
|
||||||
|
* S seconds
|
||||||
|
* p meridian (i.e. am/pm)
|
||||||
|
* T time unit: last hour, next tuesday, today, ...
|
||||||
|
* z/Z time zone
|
||||||
|
* - dash or slash
|
||||||
|
*
|
||||||
|
* Any of ",.:" is allowed and will be expected in the input string as is.
|
||||||
|
* You can enclose a single field with "[]" to mark it as being optional.
|
||||||
|
* A space stands for white space.
|
||||||
|
* No other character is allowed.
|
||||||
|
*/
|
||||||
|
|
||||||
|
static const char * const kFormatsTable[] = {
|
||||||
|
"[A][,] B d[,] H:M:S [p] Y[,] [Z]",
|
||||||
|
"[A][,] B d[,] [Y][,] H:M:S [p] [Z]",
|
||||||
|
"[A][,] B d[,] [Y][,] H:M [p][,] [Z]",
|
||||||
|
"[A][,] B d[,] [Y][,] H [p][,] [Z]",
|
||||||
|
"[A][,] B d[,] H:M [p][,] [Y] [Z]",
|
||||||
|
"[A][,] d B[,] [Y][,] H:M [p][,] [Z]",
|
||||||
|
"[A][,] d B[,] [Y][,] H:M:S [p][,] [Z]",
|
||||||
|
"[A][,] d B[,] H:M:S [Y][,] [p][,] [Z]",
|
||||||
|
"[A][,] d B[,] H:M [Y][,] [p][,] [Z]",
|
||||||
|
"d.m.y H:M:S [p] [Z]",
|
||||||
|
"d.m.y H:M [p] [Z]",
|
||||||
|
"d.m.y",
|
||||||
|
"[A][,] m-d-y[,] [H][:][M] [p]",
|
||||||
|
"[A][,] m-d[,] H:M [p]",
|
||||||
|
"[A][,] m-d[,] H[p]",
|
||||||
|
"[A][,] m-d",
|
||||||
|
"[A][,] B d[,] Y",
|
||||||
|
"[A][,] H:M [p]",
|
||||||
|
"[A][,] H [p]",
|
||||||
|
"H:M [p][,] [A]",
|
||||||
|
"H [p][,] [A]",
|
||||||
|
"[A][,] B d[,] H:M:S [p] [Z] [Y]",
|
||||||
|
"[A][,] B d[,] H:M [p] [Z] [Y]",
|
||||||
|
"[A][,] d B [,] H:M:S [p] [Z] [Y]",
|
||||||
|
"[A][,] d B [,] H:M [p] [Z] [Y]",
|
||||||
|
"[A][,] d-B-Y H:M:S [p] [Z]",
|
||||||
|
"[A][,] d-B-Y H:M [p] [Z]",
|
||||||
|
"d B Y H:M:S [Z]",
|
||||||
|
"d B Y H:M [Z]",
|
||||||
|
"y-m-d",
|
||||||
|
"y-m-d H:M:S [p] [Z]",
|
||||||
|
"m-d-y H[p]",
|
||||||
|
"m-d-y H:M[p]",
|
||||||
|
"m-d-y H:M:S[p]",
|
||||||
|
"H[p] m-d-y",
|
||||||
|
"H:M[p] m-d-y",
|
||||||
|
"H:M:S[p] m-d-y",
|
||||||
|
"A[,] H:M:S [p] [Z]",
|
||||||
|
"A[,] H:M [p] [Z]",
|
||||||
|
"H:M:S [p] [Z]",
|
||||||
|
"H:M [p] [Z]",
|
||||||
|
"A[,] [B] [d] [Y]",
|
||||||
|
"A[,] [d] [B] [Y]",
|
||||||
|
"B d[,][Y] H[p][,] [Z]",
|
||||||
|
"B d[,] H[p]",
|
||||||
|
"B d [,] H:M [p]",
|
||||||
|
"d B [,][Y] H [p] [Z]",
|
||||||
|
"d B [,] H:M [p]",
|
||||||
|
"B d [,][Y]",
|
||||||
|
"B d [,] H:M [p][,] [Y]",
|
||||||
|
"B d [,] H [p][,] [Y]",
|
||||||
|
"d B [,][Y]",
|
||||||
|
"H[p] [,] B d",
|
||||||
|
"H:M[p] [,] B d",
|
||||||
|
"T [T][T][T][T][T]",
|
||||||
|
"T H:M:S [p]",
|
||||||
|
"T H:M [p]",
|
||||||
|
"T H [p]",
|
||||||
|
"H:M [p] T",
|
||||||
|
"H [p] T",
|
||||||
|
"H [p]",
|
||||||
|
NULL
|
||||||
|
};
|
||||||
|
static const char * const *sFormatsTable = kFormatsTable;
|
||||||
|
|
||||||
|
|
||||||
|
enum field_type {
|
||||||
|
TYPE_DAY_UNIT = 0x0100,
|
||||||
|
TYPE_SECOND_UNIT = 0x0200,
|
||||||
|
TYPE_MONTH_UNIT = 0x0400,
|
||||||
|
TYPE_YEAR_UNIT = 0x0800,
|
||||||
|
|
||||||
|
TYPE_RELATIVE = 0x1000,
|
||||||
|
TYPE_NOT_MODIFIABLE = 0x2000,
|
||||||
|
TYPE_MODIFIER = 0x4000,
|
||||||
|
TYPE_UNIT = 0x8000,
|
||||||
|
|
||||||
|
TYPE_UNIT_MASK = 0x0f00,
|
||||||
|
TYPE_MASK = 0x00ff,
|
||||||
|
|
||||||
|
TYPE_UNKNOWN = 0,
|
||||||
|
|
||||||
|
TYPE_DAY = 1 | TYPE_DAY_UNIT,
|
||||||
|
TYPE_MONTH = 2 | TYPE_MONTH_UNIT,
|
||||||
|
TYPE_YEAR = 3 | TYPE_MONTH_UNIT,
|
||||||
|
TYPE_WEEKDAY = 4 | TYPE_DAY_UNIT,
|
||||||
|
TYPE_NOW = 5,
|
||||||
|
TYPE_HOUR = 6 | TYPE_SECOND_UNIT,
|
||||||
|
TYPE_MINUTE = 7 | TYPE_SECOND_UNIT,
|
||||||
|
TYPE_SECOND = 8 | TYPE_SECOND_UNIT,
|
||||||
|
TYPE_TIME_ZONE = 9 | TYPE_SECOND_UNIT,
|
||||||
|
TYPE_MERIDIAN = 10 | TYPE_SECOND_UNIT,
|
||||||
|
|
||||||
|
TYPE_DASH = 12,
|
||||||
|
TYPE_DOT = 13,
|
||||||
|
TYPE_COLON = 14,
|
||||||
|
TYPE_SEMICOLON = 15,
|
||||||
|
|
||||||
|
TYPE_PLUS_MINUS = 16 | TYPE_MODIFIER | TYPE_RELATIVE,
|
||||||
|
TYPE_NEXT_LAST_THIS = 17 | TYPE_MODIFIER | TYPE_RELATIVE,
|
||||||
|
|
||||||
|
TYPE_END,
|
||||||
|
};
|
||||||
|
|
||||||
|
enum value_type {
|
||||||
|
VALUE_NUMERICAL,
|
||||||
|
VALUE_STRING,
|
||||||
|
VALUE_CHAR,
|
||||||
|
};
|
||||||
|
|
||||||
|
enum value_modifier {
|
||||||
|
MODIFY_PLUS,
|
||||||
|
MODIFY_MINUS,
|
||||||
|
MODIFY_NEXT,
|
||||||
|
MODIFY_THIS,
|
||||||
|
MODIFY_LAST,
|
||||||
|
};
|
||||||
|
|
||||||
|
struct known_identifier {
|
||||||
|
const char *string;
|
||||||
|
int32 type;
|
||||||
|
int32 value;
|
||||||
|
};
|
||||||
|
|
||||||
|
static const known_identifier kIdentifiers[] = {
|
||||||
|
{"today", TYPE_RELATIVE | TYPE_NOT_MODIFIABLE | TYPE_DAY_UNIT, 0},
|
||||||
|
{"tomorrow", TYPE_RELATIVE | TYPE_NOT_MODIFIABLE | TYPE_DAY_UNIT, 1},
|
||||||
|
{"yesterday", TYPE_RELATIVE | TYPE_NOT_MODIFIABLE | TYPE_DAY_UNIT, -1},
|
||||||
|
{"now", TYPE_RELATIVE | TYPE_NOT_MODIFIABLE | TYPE_NOW, 0},
|
||||||
|
|
||||||
|
{"this", TYPE_NEXT_LAST_THIS, 0},
|
||||||
|
{"next", TYPE_NEXT_LAST_THIS, 1},
|
||||||
|
{"last", TYPE_NEXT_LAST_THIS, -1},
|
||||||
|
|
||||||
|
{"year", TYPE_UNIT | TYPE_RELATIVE | TYPE_YEAR_UNIT, 1},
|
||||||
|
{"month", TYPE_UNIT | TYPE_RELATIVE | TYPE_MONTH_UNIT, 1},
|
||||||
|
{"day", TYPE_UNIT | TYPE_RELATIVE | TYPE_DAY_UNIT, 1},
|
||||||
|
{"days", TYPE_UNIT | TYPE_RELATIVE | TYPE_DAY_UNIT, 1},
|
||||||
|
{"hour", TYPE_UNIT | TYPE_RELATIVE | TYPE_SECOND_UNIT, 1 * 60 * 60},
|
||||||
|
{"hrs", TYPE_UNIT | TYPE_RELATIVE | TYPE_SECOND_UNIT, 1 * 60 * 60},
|
||||||
|
{"hours", TYPE_UNIT | TYPE_RELATIVE | TYPE_SECOND_UNIT, 1 * 60 * 60},
|
||||||
|
{"sec", TYPE_UNIT | TYPE_RELATIVE | TYPE_SECOND_UNIT, 1},
|
||||||
|
{"second", TYPE_UNIT | TYPE_RELATIVE | TYPE_SECOND_UNIT, 1},
|
||||||
|
{"seconds", TYPE_UNIT | TYPE_RELATIVE | TYPE_SECOND_UNIT, 1},
|
||||||
|
{"min", TYPE_UNIT | TYPE_RELATIVE | TYPE_SECOND_UNIT, 60},
|
||||||
|
{"minute", TYPE_UNIT | TYPE_RELATIVE | TYPE_SECOND_UNIT, 60},
|
||||||
|
{"minutes", TYPE_UNIT | TYPE_RELATIVE | TYPE_SECOND_UNIT, 60},
|
||||||
|
|
||||||
|
{"am", TYPE_MERIDIAN | TYPE_NOT_MODIFIABLE, 0},
|
||||||
|
{"pm", TYPE_MERIDIAN | TYPE_NOT_MODIFIABLE, 12 * 60 * 60}, // 12 hours
|
||||||
|
|
||||||
|
{"sunday", TYPE_WEEKDAY, 0},
|
||||||
|
{"monday", TYPE_WEEKDAY, 1},
|
||||||
|
{"tuesday", TYPE_WEEKDAY, 2},
|
||||||
|
{"wednesday", TYPE_WEEKDAY, 3},
|
||||||
|
{"thursday", TYPE_WEEKDAY, 4},
|
||||||
|
{"friday", TYPE_WEEKDAY, 5},
|
||||||
|
{"saturday", TYPE_WEEKDAY, 6},
|
||||||
|
|
||||||
|
{"january", TYPE_MONTH, 1},
|
||||||
|
{"february", TYPE_MONTH, 2},
|
||||||
|
{"march", TYPE_MONTH, 3},
|
||||||
|
{"april", TYPE_MONTH, 4},
|
||||||
|
{"may", TYPE_MONTH, 5},
|
||||||
|
{"june", TYPE_MONTH, 6},
|
||||||
|
{"july", TYPE_MONTH, 7},
|
||||||
|
{"august", TYPE_MONTH, 8},
|
||||||
|
{"september", TYPE_MONTH, 9},
|
||||||
|
{"october", TYPE_MONTH, 10},
|
||||||
|
{"november", TYPE_MONTH, 11},
|
||||||
|
{"december", TYPE_MONTH, 12},
|
||||||
|
|
||||||
|
{"GMT", TYPE_TIME_ZONE, 0},
|
||||||
|
// ToDo: add more time zones
|
||||||
|
|
||||||
|
{NULL, TYPE_UNKNOWN, 0},
|
||||||
|
};
|
||||||
|
|
||||||
|
#define MAX_ELEMENTS 32
|
||||||
|
|
||||||
|
struct parsed_element {
|
||||||
|
int32 type;
|
||||||
|
int32 value_type;
|
||||||
|
int32 modifier;
|
||||||
|
bigtime_t value;
|
||||||
|
};
|
||||||
|
|
||||||
|
|
||||||
|
bool
|
||||||
|
isType(int32 typeA, int32 typeB)
|
||||||
|
{
|
||||||
|
return (typeA & TYPE_MASK) == (typeB & TYPE_MASK);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
status_t
|
||||||
|
preparseDate(const char *dateString, parsed_element *elements)
|
||||||
|
{
|
||||||
|
int32 index = 0;
|
||||||
|
char c;
|
||||||
|
|
||||||
|
if (dateString == NULL)
|
||||||
|
return B_ERROR;
|
||||||
|
|
||||||
|
for (; (c = dateString[0]) != '\0'; dateString++) {
|
||||||
|
// we don't care about spaces
|
||||||
|
if (isspace(c))
|
||||||
|
continue;
|
||||||
|
|
||||||
|
// if we're reached our maximum number of elements, bail out
|
||||||
|
if (index >= MAX_ELEMENTS)
|
||||||
|
return B_ERROR;
|
||||||
|
|
||||||
|
memset(&elements[index], 0, sizeof(parsed_element));
|
||||||
|
|
||||||
|
if (c == ',') {
|
||||||
|
elements[index].type = TYPE_COLON;
|
||||||
|
elements[index].value_type = VALUE_CHAR;
|
||||||
|
} else if (c == '.') {
|
||||||
|
elements[index].type = TYPE_DOT;
|
||||||
|
elements[index].value_type = VALUE_CHAR;
|
||||||
|
} else if (c == '/' || c == '-') {
|
||||||
|
// ToDo: "-" can also be the minus modifier... - how to distinguish?
|
||||||
|
elements[index].type = TYPE_DASH;
|
||||||
|
elements[index].value_type = VALUE_CHAR;
|
||||||
|
} else if (c == ':') {
|
||||||
|
elements[index].type = TYPE_SEMICOLON;
|
||||||
|
elements[index].value_type = VALUE_CHAR;
|
||||||
|
} else if (c == '+') {
|
||||||
|
elements[index].type = TYPE_RELATIVE;
|
||||||
|
elements[index].value_type = VALUE_CHAR;
|
||||||
|
elements[index].modifier = MODIFY_PLUS;
|
||||||
|
|
||||||
|
// this counts for the next element
|
||||||
|
continue;
|
||||||
|
} else if (c == '-') {
|
||||||
|
// ToDo: this never happens, due to TYPE_DASH
|
||||||
|
elements[index].type = TYPE_MODIFIER;
|
||||||
|
elements[index].value_type = VALUE_CHAR;
|
||||||
|
elements[index].modifier = MODIFY_MINUS;
|
||||||
|
|
||||||
|
// this counts for the next element
|
||||||
|
continue;
|
||||||
|
} else if (isdigit(c)) {
|
||||||
|
// fetch whole number
|
||||||
|
|
||||||
|
elements[index].type = TYPE_UNKNOWN;
|
||||||
|
elements[index].value_type = VALUE_NUMERICAL;
|
||||||
|
elements[index].value = atoll(dateString);
|
||||||
|
|
||||||
|
// skip number
|
||||||
|
while (isdigit(dateString[1]))
|
||||||
|
dateString++;
|
||||||
|
} else if (isalpha(c)) {
|
||||||
|
// fetch whole string
|
||||||
|
|
||||||
|
const char *string = dateString;
|
||||||
|
while (isalpha(dateString[1]))
|
||||||
|
dateString++;
|
||||||
|
int32 length = dateString + 1 - string;
|
||||||
|
|
||||||
|
// compare with known strings
|
||||||
|
// ToDo: should understand other languages as well...
|
||||||
|
|
||||||
|
const known_identifier *identifier = kIdentifiers;
|
||||||
|
for (; identifier->string; identifier++) {
|
||||||
|
if (!strncasecmp(identifier->string, string, length)
|
||||||
|
&& !identifier->string[length])
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
if (identifier->string == NULL) {
|
||||||
|
// unknown string, we don't have to parse any further
|
||||||
|
return B_ERROR;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (index > 0 && (identifier->type & TYPE_UNIT) != 0) {
|
||||||
|
// this is just a unit, so it will give the last value a meaning
|
||||||
|
|
||||||
|
if (elements[--index].value_type != VALUE_NUMERICAL
|
||||||
|
&& elements[index].type != TYPE_NEXT_LAST_THIS)
|
||||||
|
return B_ERROR;
|
||||||
|
|
||||||
|
elements[index].value *= identifier->value;
|
||||||
|
} else if (index > 0 && elements[index - 1].type == TYPE_NEXT_LAST_THIS) {
|
||||||
|
if (isType(identifier->type, TYPE_MONTH)
|
||||||
|
|| isType(identifier->type, TYPE_WEEKDAY)) {
|
||||||
|
index--;
|
||||||
|
|
||||||
|
switch (elements[index].value) {
|
||||||
|
case -1:
|
||||||
|
elements[index].modifier = MODIFY_LAST;
|
||||||
|
break;
|
||||||
|
case 0:
|
||||||
|
elements[index].modifier = MODIFY_THIS;
|
||||||
|
break;
|
||||||
|
case 1:
|
||||||
|
elements[index].modifier = MODIFY_NEXT;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
elements[index].value = identifier->value;
|
||||||
|
} else
|
||||||
|
return B_ERROR;
|
||||||
|
} else {
|
||||||
|
elements[index].value_type = VALUE_STRING;
|
||||||
|
elements[index].value = identifier->value;
|
||||||
|
}
|
||||||
|
|
||||||
|
elements[index].type = identifier->type;
|
||||||
|
}
|
||||||
|
|
||||||
|
// see if we can join any preceding modifiers
|
||||||
|
|
||||||
|
if (index > 0
|
||||||
|
&& (elements[index - 1].type & TYPE_MODIFIER) != 0
|
||||||
|
&& (elements[index].type & TYPE_NOT_MODIFIABLE) == 0) {
|
||||||
|
// copy the current one to the last and go on
|
||||||
|
elements[index].modifier = elements[index - 1].modifier;
|
||||||
|
elements[index].value *= elements[index - 1].value;
|
||||||
|
elements[index - 1] = elements[index];
|
||||||
|
} else {
|
||||||
|
// we filled out one parsed_element
|
||||||
|
index++;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// were there any elements?
|
||||||
|
if (index == 0)
|
||||||
|
return B_ERROR;
|
||||||
|
|
||||||
|
elements[index].type = TYPE_END;
|
||||||
|
|
||||||
|
return B_OK;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
static void
|
||||||
|
computeRelativeUnit(parsed_element &element, struct tm &tm, time_t &now, bool &makeTime, bool isString)
|
||||||
|
{
|
||||||
|
uint32 type = element.type;
|
||||||
|
|
||||||
|
// ToDo: should change flags as well!
|
||||||
|
|
||||||
|
makeTime = true;
|
||||||
|
localtime_r(&now, &tm);
|
||||||
|
|
||||||
|
// set the relative start depending on unit
|
||||||
|
|
||||||
|
if (type & (TYPE_DAY_UNIT | TYPE_MONTH_UNIT | TYPE_YEAR_UNIT)) {
|
||||||
|
tm.tm_hour = 0;
|
||||||
|
tm.tm_min = 0;
|
||||||
|
tm.tm_sec = 0;
|
||||||
|
}
|
||||||
|
if (type & (TYPE_MONTH_UNIT | TYPE_YEAR_UNIT))
|
||||||
|
tm.tm_mday = 1;
|
||||||
|
if (type & TYPE_YEAR_UNIT)
|
||||||
|
tm.tm_mon = 0;
|
||||||
|
|
||||||
|
// adjust value
|
||||||
|
|
||||||
|
if (type & TYPE_RELATIVE) {
|
||||||
|
if (type & TYPE_MONTH_UNIT)
|
||||||
|
tm.tm_mon += element.value;
|
||||||
|
else if (type & TYPE_DAY_UNIT)
|
||||||
|
tm.tm_mday += element.value;
|
||||||
|
else if (type & TYPE_SECOND_UNIT)
|
||||||
|
tm.tm_sec += element.value;
|
||||||
|
else if (!isType(type, TYPE_NOW))
|
||||||
|
;
|
||||||
|
//puts("what's going on here?");
|
||||||
|
} else if (isType(type, TYPE_WEEKDAY)) {
|
||||||
|
tm.tm_mday += abs(element.value) - tm.tm_wday;
|
||||||
|
|
||||||
|
if (element.modifier == MODIFY_NEXT)
|
||||||
|
tm.tm_mday += 7;
|
||||||
|
else if (element.modifier == MODIFY_LAST)
|
||||||
|
tm.tm_mday -= 7;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
static time_t
|
||||||
|
computeDate(const char *format, bool *optional, parsed_element *elements, time_t now, int *_flags)
|
||||||
|
{
|
||||||
|
//printf("matches: %s\n", format);
|
||||||
|
|
||||||
|
parsed_element *element = elements;
|
||||||
|
uint32 position = 0;
|
||||||
|
struct tm tm;
|
||||||
|
time_t date;
|
||||||
|
bool relative = false, makeTime = false;
|
||||||
|
|
||||||
|
// ToDo: only call time() if necessary
|
||||||
|
if (now == -1)
|
||||||
|
now = time(NULL);
|
||||||
|
|
||||||
|
memset(&tm, 0, sizeof(tm));
|
||||||
|
// localtime_r(&now, &tm);
|
||||||
|
// printf("now = %ld, -> %ld\n", now, mktime(&tm));
|
||||||
|
|
||||||
|
while (element->type != TYPE_END) {
|
||||||
|
// skip whitespace
|
||||||
|
while (isspace(format[0]))
|
||||||
|
format++;
|
||||||
|
|
||||||
|
if (format[0] == '[' && format[2] == ']') {
|
||||||
|
// does this optional parameter not match our date string?
|
||||||
|
if (!optional[position]) {
|
||||||
|
format += 3;
|
||||||
|
position++;
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
|
||||||
|
format++;
|
||||||
|
}
|
||||||
|
|
||||||
|
switch (element->value_type) {
|
||||||
|
case VALUE_CHAR:
|
||||||
|
// skip the single character
|
||||||
|
break;
|
||||||
|
|
||||||
|
case VALUE_NUMERICAL:
|
||||||
|
switch (format[0]) {
|
||||||
|
case 'd':
|
||||||
|
tm.tm_mday = element->value;
|
||||||
|
makeTime = true;
|
||||||
|
break;
|
||||||
|
case 'm':
|
||||||
|
tm.tm_mon = element->value - 1;
|
||||||
|
makeTime = true;
|
||||||
|
break;
|
||||||
|
case 'H':
|
||||||
|
case 'I':
|
||||||
|
tm.tm_hour = element->value;
|
||||||
|
makeTime = true;
|
||||||
|
break;
|
||||||
|
case 'M':
|
||||||
|
tm.tm_min = element->value;
|
||||||
|
makeTime = true;
|
||||||
|
break;
|
||||||
|
case 'S':
|
||||||
|
tm.tm_sec = element->value;
|
||||||
|
makeTime = true;
|
||||||
|
break;
|
||||||
|
case 'y':
|
||||||
|
case 'Y':
|
||||||
|
tm.tm_year = element->value;
|
||||||
|
if (tm.tm_year > 1900)
|
||||||
|
tm.tm_year -= 1900;
|
||||||
|
makeTime = true;
|
||||||
|
break;
|
||||||
|
case 'T':
|
||||||
|
// ToDo:!
|
||||||
|
computeRelativeUnit(*element, tm, now, makeTime, false);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
|
||||||
|
case VALUE_STRING:
|
||||||
|
switch (format[0]) {
|
||||||
|
case 'a': // weekday
|
||||||
|
case 'A':
|
||||||
|
break;
|
||||||
|
case 'b':
|
||||||
|
case 'B':
|
||||||
|
break;
|
||||||
|
case 'p':
|
||||||
|
break;
|
||||||
|
case 'z': // time zone
|
||||||
|
case 'Z':
|
||||||
|
break;
|
||||||
|
case 'T':
|
||||||
|
computeRelativeUnit(*element, tm, now, makeTime, true);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
// format matched at this point, check next element
|
||||||
|
format++;
|
||||||
|
position++;
|
||||||
|
element++;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (makeTime)
|
||||||
|
return mktime(&tm);
|
||||||
|
|
||||||
|
return now;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
time_t
|
||||||
|
parsedate_etc(const char *dateString, time_t now, int *_flags)
|
||||||
|
{
|
||||||
|
// preparse date string so that it can be easily compared to our formats
|
||||||
|
|
||||||
|
parsed_element elements[MAX_ELEMENTS];
|
||||||
|
|
||||||
|
if (preparseDate(dateString, elements) < B_OK) {
|
||||||
|
*_flags = PARSEDATE_INVALID_DATE;
|
||||||
|
return B_ERROR;
|
||||||
|
}
|
||||||
|
|
||||||
|
/*for (int32 index = 0; elements[index].type != TYPE_END; index++) {
|
||||||
|
parsed_element e = elements[index];
|
||||||
|
char type[32];
|
||||||
|
sprintf(type, "0x%lx", e.type);
|
||||||
|
if (e.type & TYPE_UNIT)
|
||||||
|
strcat(type, " unit");
|
||||||
|
if (e.type & TYPE_RELATIVE)
|
||||||
|
strcat(type, " relative");
|
||||||
|
|
||||||
|
printf(" %ld: type = %ld (%s), value = %Ld (%s)\n",
|
||||||
|
index, e.type & TYPE_MASK, type, e.value,
|
||||||
|
e.value_type == VALUE_NUMERICAL ? "numerical" :
|
||||||
|
(e.value_type == VALUE_STRING ? "string" : "char"));
|
||||||
|
}*/
|
||||||
|
|
||||||
|
bool optional[MAX_ELEMENTS];
|
||||||
|
|
||||||
|
for (int32 index = 0; sFormatsTable[index]; index++) {
|
||||||
|
// test if this format matches our date string
|
||||||
|
|
||||||
|
const char *format = sFormatsTable[index];
|
||||||
|
uint32 position = 0;
|
||||||
|
|
||||||
|
parsed_element *element = elements;
|
||||||
|
while (element->type != TYPE_END) {
|
||||||
|
// skip whitespace
|
||||||
|
while (isspace(format[0]))
|
||||||
|
format++;
|
||||||
|
|
||||||
|
if (format[0] == '[' && format[2] == ']') {
|
||||||
|
optional[position] = true;
|
||||||
|
format++;
|
||||||
|
} else
|
||||||
|
optional[position] = false;
|
||||||
|
|
||||||
|
switch (element->value_type) {
|
||||||
|
case VALUE_CHAR:
|
||||||
|
// check the allowed single characters
|
||||||
|
|
||||||
|
switch (element->type & TYPE_MASK) {
|
||||||
|
case TYPE_DOT:
|
||||||
|
if (format[0] != '.')
|
||||||
|
goto next_format;
|
||||||
|
break;
|
||||||
|
case TYPE_DASH:
|
||||||
|
if (format[0] != '/' && format[0] != '-')
|
||||||
|
goto next_format;
|
||||||
|
break;
|
||||||
|
case TYPE_COLON:
|
||||||
|
if (format[0] != ',')
|
||||||
|
goto next_format;
|
||||||
|
break;
|
||||||
|
case TYPE_SEMICOLON:
|
||||||
|
if (format[0] != ';')
|
||||||
|
goto next_format;
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
goto next_format;
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
|
||||||
|
case VALUE_NUMERICAL:
|
||||||
|
switch (format[0]) {
|
||||||
|
case 'd':
|
||||||
|
if (element->value > 31)
|
||||||
|
goto next_format;
|
||||||
|
break;
|
||||||
|
case 'm':
|
||||||
|
if (element->value > 12)
|
||||||
|
goto next_format;
|
||||||
|
break;
|
||||||
|
case 'H':
|
||||||
|
case 'I':
|
||||||
|
if (element->value > 24)
|
||||||
|
goto next_format;
|
||||||
|
break;
|
||||||
|
case 'M':
|
||||||
|
case 'S':
|
||||||
|
if (element->value > 59)
|
||||||
|
goto next_format;
|
||||||
|
break;
|
||||||
|
case 'y':
|
||||||
|
case 'Y':
|
||||||
|
case 'T':
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
goto next_format;
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
|
||||||
|
case VALUE_STRING:
|
||||||
|
switch (format[0]) {
|
||||||
|
case 'a': // weekday
|
||||||
|
case 'A':
|
||||||
|
if ((element->type & TYPE_MASK) != TYPE_WEEKDAY)
|
||||||
|
goto next_format;
|
||||||
|
break;
|
||||||
|
case 'b': // month
|
||||||
|
case 'B':
|
||||||
|
if ((element->type & TYPE_MASK) != TYPE_MONTH)
|
||||||
|
goto next_format;
|
||||||
|
break;
|
||||||
|
case 'p': // meridian
|
||||||
|
if ((element->type & TYPE_MASK) != TYPE_MERIDIAN)
|
||||||
|
goto next_format;
|
||||||
|
break;
|
||||||
|
case 'z': // time zone
|
||||||
|
case 'Z':
|
||||||
|
if ((element->type & TYPE_MASK) != TYPE_TIME_ZONE)
|
||||||
|
goto next_format;
|
||||||
|
break;
|
||||||
|
case 'T':
|
||||||
|
// last/next/this
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
goto next_format;
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
// format matched at this point, check next element
|
||||||
|
if (optional[position])
|
||||||
|
format++;
|
||||||
|
format++;
|
||||||
|
position++;
|
||||||
|
element++;
|
||||||
|
continue;
|
||||||
|
|
||||||
|
next_format:
|
||||||
|
// format didn't match element - let's see if the current
|
||||||
|
// one is only optional (in which case we can continue)
|
||||||
|
if (!optional[position])
|
||||||
|
goto skip_format;
|
||||||
|
|
||||||
|
optional[position] = false;
|
||||||
|
format += 2;
|
||||||
|
position++;
|
||||||
|
// skip the closing ']'
|
||||||
|
}
|
||||||
|
|
||||||
|
// check if the format is already empty (since we reached our last element)
|
||||||
|
while (format[0]) {
|
||||||
|
if (format[0] == '[')
|
||||||
|
format += 3;
|
||||||
|
else if (isspace(format[0]))
|
||||||
|
format++;
|
||||||
|
else
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
if (format[0])
|
||||||
|
goto skip_format;
|
||||||
|
|
||||||
|
// made it here? then we seem to have found our guy
|
||||||
|
|
||||||
|
return computeDate(sFormatsTable[index], optional, elements, now, _flags);
|
||||||
|
|
||||||
|
skip_format:
|
||||||
|
// check if the next format has the same beginning as the skipped one,
|
||||||
|
// and if so, skip that one, too.
|
||||||
|
|
||||||
|
int32 length = format + 1 - sFormatsTable[index];
|
||||||
|
|
||||||
|
while (sFormatsTable[index + 1]
|
||||||
|
&& !strncmp(sFormatsTable[index], sFormatsTable[index + 1], length))
|
||||||
|
index++;
|
||||||
|
}
|
||||||
|
|
||||||
|
// didn't find any matching formats
|
||||||
|
return B_ERROR;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
time_t
|
||||||
|
parsedate(const char *dateString, time_t now)
|
||||||
|
{
|
||||||
|
int flags = 0;
|
||||||
|
|
||||||
|
return parsedate_etc(dateString, now, &flags);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
void
|
||||||
|
set_dateformats(const char **table)
|
||||||
|
{
|
||||||
|
sFormatsTable = table ? table : kFormatsTable;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
const char **
|
||||||
|
get_dateformats(void)
|
||||||
|
{
|
||||||
|
return const_cast<const char **>(sFormatsTable);
|
||||||
|
}
|
||||||
|
|
||||||
Reference in New Issue
Block a user