date_type
parse_date(const string_type& value,
const string_type& format) const
{
stringstream_type ss;
ss << value;
stream_itr_type sitr(ss);
stream_itr_type stream_end;
return parse_date(sitr, stream_end, format);
}
int64_t parse_time_or_die(const char *context, const char *timestr, int is_duration)
{
int64_t us = parse_date(timestr, is_duration);
if (us == INT64_MIN) {
fprintf(stderr, "Invalid %s specification for %s: %s\n",
is_duration ? "duration" : "date", context, timestr);
exit(1);
}
return us;
}
/* returns 1 if the given date is Saturday or Sunday.
* Zero is otherwise returned. */
int vi_is_weekend(char *s, int time_delta)
{
struct tm tm;
if (parse_date(s, &tm, time_delta) != (time_t)-1) {
if (tm.tm_wday == 0 || tm.tm_wday == 6)
return 1;
}
return 0;
}
void rss_parser::fill_feed_items(std::tr1::shared_ptr<rss_feed> feed) {
/*
* we iterate over all items of a feed, create an rss_item object for
* each item, and fill it with the appropriate values from the data structure.
*/
for (std::vector<rsspp::item>::iterator item=f.items.begin();item!=f.items.end();item++) {
std::tr1::shared_ptr<rss_item> x(new rss_item(ch));
set_item_title(feed, x, *item);
if (item->link != "") {
x->set_link(utils::absolute_url(feed->link(), item->link));
}
set_item_author(x, *item);
x->set_feedurl(feed->rssurl());
if (f.rss_version == rsspp::ATOM_1_0 && item->labels.size() > 0) {
std::vector<std::string>::const_iterator start, finish;
start = item->labels.begin();
finish = item->labels.end();
if (std::find(start, finish, "fresh") != finish) {
x->set_unread_nowrite(true);
x->set_override_unread(true);
}
if (std::find(start, finish, "kept-unread") != finish) {
x->set_unread_nowrite(true);
x->set_override_unread(true);
}
if (std::find(start, finish, "read") != finish) {
x->set_unread_nowrite(false);
x->set_override_unread(true);
}
}
set_item_content(x, *item);
if (item->pubDate != "")
x->set_pubDate(parse_date(item->pubDate));
else
x->set_pubDate(::time(NULL));
x->set_guid(get_guid(*item));
x->set_base(item->base);
set_item_enclosure(x, *item);
LOG(LOG_DEBUG, "rss_parser::parse: item title = `%s' link = `%s' pubDate = `%s' (%d) description = `%s'", x->title().c_str(),
x->link().c_str(), x->pubDate().c_str(), x->pubDate_timestamp(), x->description().c_str());
add_item_to_feed(feed, x);
}
}
int8_t command_insert( uint8_t *pszCommandString, tUserState *pState )
{
int32_t iRetVal;
tDateTime tempDate;
char szFirstName[MAX_STRING_LENGTH+1];
char szLastName[MAX_STRING_LENGTH+1];
char szUserName[MAX_STRING_LENGTH+1];
char szTemp[MAX_STRING_LENGTH+1];
uint32_t creationDate;
uint32_t newRecordNumber;
printf( "First name: " );
iRetVal = readLine( STDIN, szFirstName, MAX_STRING_LENGTH );
sanitize_string( szFirstName );
printf( "Last name: " );
iRetVal = readLine( STDIN, szLastName, MAX_STRING_LENGTH );
sanitize_string( szLastName );
printf( "User name: " );
iRetVal = readLine( STDIN, szUserName, MAX_STRING_LENGTH );
sanitize_string( szUserName );
printf( "Birthdate (mm/dd/yy hh:mm:ss): " );
iRetVal = readLine( STDIN, szTemp, MAX_STRING_LENGTH );
creationDate = parse_date( szTemp, &tempDate );
if ( creationDate == 0 )
{
printf( "Date parsing error.\n" );
return 0;
}
printf( "Date is: $d/$d/$d $d:$d:$d\n", tempDate.month, tempDate.day, GET_DB_YEAR(tempDate.year), tempDate.hour, tempDate.minute, tempDate.second );
// Insert into database
newRecordNumber = db_add_record( szUserName, szFirstName, szLastName, tempDate );
if ( newRecordNumber == BAD_RECORD_ERROR )
{
printf( "Database full.\n" );
return 0;
}
printf( "Data added, record $d\n", newRecordNumber );
return 0;
}
static VALUE typecast(VALUE r_value, const VALUE type) {
VALUE r_data;
if (type == rb_cInteger) {
return TYPE(r_value) == T_FIXNUM || TYPE(r_value) == T_BIGNUM ? r_value : rb_funcall(r_value, DO_ID_TO_I, 0);
} else if (type == rb_cString) {
if (TYPE(r_value) == T_STRING)
return r_value;
else if (rb_obj_class(r_value) == cOCI8_CLOB)
return rb_funcall(r_value, DO_ID_READ, 0);
else
return rb_funcall(r_value, DO_ID_TO_S, 0);
} else if (type == rb_cFloat) {
return TYPE(r_value) == T_FLOAT ? r_value : rb_funcall(r_value, DO_ID_TO_F, 0);
} else if (type == rb_cBigDecimal) {
VALUE r_string = TYPE(r_value) == T_STRING ? r_value : rb_funcall(r_value, DO_ID_TO_S, 0);
return rb_funcall(rb_cBigDecimal, DO_ID_NEW, 1, r_string);
} else if (type == rb_cDate) {
return parse_date(r_value);
} else if (type == rb_cDateTime) {
return parse_date_time(r_value);
} else if (type == rb_cTime) {
return parse_time(r_value);
} else if (type == rb_cTrueClass) {
return parse_boolean(r_value);
} else if (type == rb_cByteArray) {
if (rb_obj_class(r_value) == cOCI8_BLOB)
r_data = rb_funcall(r_value, DO_ID_READ, 0);
else
r_data = r_value;
return rb_funcall(rb_cByteArray, DO_ID_NEW, 1, r_data);
} else if (type == rb_cClass) {
return rb_funcall(mDO, DO_ID_FULL_CONST_GET, 1, r_value);
} else if (type == rb_cNilClass) {
return Qnil;
} else {
if (rb_obj_class(r_value) == cOCI8_CLOB)
return rb_funcall(r_value, DO_ID_READ, 0);
else
return r_value;
}
}
static VALUE typecast(sqlite3_stmt *stmt, int i, VALUE ruby_class) {
const char *ruby_type;
VALUE ruby_value = Qnil;
int original_type = sqlite3_column_type(stmt, i);
int length = sqlite3_column_bytes(stmt, i);
if ( original_type == SQLITE_NULL ) {
return ruby_value;
}
if ( original_type == SQLITE_BLOB ) {
return TAINTED_STRING((char*)sqlite3_column_blob(stmt, i), length);
}
if(ruby_class == Qnil) {
switch(original_type) {
case SQLITE_INTEGER: {
ruby_type = "Integer";
break;
}
case SQLITE_FLOAT: {
ruby_type = "Float";
break;
}
default: {
ruby_type = "String";
break;
}
}
} else {
ruby_type = rb_class2name(ruby_class);
}
if ( strcmp(ruby_type, "Class") == 0) {
return rb_funcall(rb_cObject, rb_intern("full_const_get"), 1, TAINTED_STRING((char*)sqlite3_column_text(stmt, i), length));
} else if ( strcmp(ruby_type, "Object") == 0 ) {
return rb_marshal_load(rb_str_new2((char*)sqlite3_column_text(stmt, i)));
} else if ( strcmp(ruby_type, "TrueClass") == 0 ) {
return strcmp((char*)sqlite3_column_text(stmt, i), "t") == 0 ? Qtrue : Qfalse;
} else if ( strcmp(ruby_type, "Integer") == 0 || strcmp(ruby_type, "Fixnum") == 0 || strcmp(ruby_type, "Bignum") == 0 ) {
return LL2NUM(sqlite3_column_int64(stmt, i));
} else if ( strcmp(ruby_type, "BigDecimal") == 0 ) {
return rb_funcall(rb_cBigDecimal, ID_NEW, 1, TAINTED_STRING((char*)sqlite3_column_text(stmt, i), length));
} else if ( strcmp(ruby_type, "Float") == 0 ) {
return rb_float_new(sqlite3_column_double(stmt, i));
} else if ( strcmp(ruby_type, "Date") == 0 ) {
return parse_date((char*)sqlite3_column_text(stmt, i));
} else if ( strcmp(ruby_type, "DateTime") == 0 ) {
return parse_date_time((char*)sqlite3_column_text(stmt, i));
} else if ( strcmp(ruby_type, "Time") == 0 ) {
return parse_time((char*)sqlite3_column_text(stmt, i));
} else {
return TAINTED_STRING((char*)sqlite3_column_text(stmt, i), length);
}
}
const char *fmt_ident(const char *name, const char *email,
const char *date_str, int flag)
{
static char buffer[1000];
char date[50];
int i;
int error_on_no_name = (flag & IDENT_ERROR_ON_NO_NAME);
int warn_on_no_name = (flag & IDENT_WARN_ON_NO_NAME);
int name_addr_only = (flag & IDENT_NO_DATE);
setup_ident();
if (!name)
name = git_default_name;
if (!email)
email = git_default_email;
if (!*name) {
struct passwd *pw;
if ((warn_on_no_name || error_on_no_name) &&
name == git_default_name && env_hint) {
fputs(env_hint, stderr);
env_hint = NULL; /* warn only once */
}
if (error_on_no_name)
die("empty ident %s <%s> not allowed", name, email);
pw = getpwuid(getuid());
if (!pw)
die("You don't exist. Go away!");
strlcpy(git_default_name, pw->pw_name,
sizeof(git_default_name));
name = git_default_name;
}
strcpy(date, git_default_date);
if (!name_addr_only && date_str && date_str[0]) {
if (parse_date(date_str, date, sizeof(date)) < 0)
die("invalid date format: %s", date_str);
}
i = copy(buffer, sizeof(buffer), 0, name);
i = add_raw(buffer, sizeof(buffer), i, " <");
i = copy(buffer, sizeof(buffer), i, email);
if (!name_addr_only) {
i = add_raw(buffer, sizeof(buffer), i, "> ");
i = copy(buffer, sizeof(buffer), i, date);
} else {
i = add_raw(buffer, sizeof(buffer), i, ">");
}
if (i >= sizeof(buffer))
die("Impossibly long personal identifier");
buffer[i] = 0;
return buffer;
}
// input is string in the format "DD-MMM-YYYY, hh:mm:ss" (as in parse_date())
// output is seconds since midnight, Jan 1, 1900 (as from date2sec())
double seconds_from_str(const char *date_str)
{
ymd_date d;
hms_time t;
parse_date(date_str, &d, &t);
t.sec = 0;
julian_date jd;
date_ymd2jd(&d, &jd);
return date2sec(&jd, &t);
}
/** Parse a string \p in the form of Range:npt=xx-xx, and determine the start
* and end time.
* Used for seeking in the rtp stream.
*/
static void rtsp_parse_range_npt(const char *p, int64_t *start, int64_t *end)
{
char buf[256];
skip_spaces(&p);
if (!av_stristart(p, "npt=", &p))
return;
*start = AV_NOPTS_VALUE;
*end = AV_NOPTS_VALUE;
get_word_sep(buf, sizeof(buf), "-", &p);
*start = parse_date(buf, 1);
if (*p == '-') {
p++;
get_word_sep(buf, sizeof(buf), "-", &p);
*end = parse_date(buf, 1);
}
// av_log(NULL, AV_LOG_DEBUG, "Range Start: %lld\n", *start);
// av_log(NULL, AV_LOG_DEBUG, "Range End: %lld\n", *end);
}
int try_to_open_csv(struct memblock *mem, enum csv_format type)
{
char *p = mem->buffer;
char *header[8];
int i, time;
timestamp_t date;
struct dive *dive;
struct divecomputer *dc;
for (i = 0; i < 8; i++) {
header[i] = p;
p = strchr(p, ',');
if (!p)
return 0;
p++;
}
date = parse_date(header[2]);
if (!date)
return 0;
dive = alloc_dive();
dive->when = date;
dive->number = atoi(header[1]);
dc = &dive->dc;
time = 0;
for (;;) {
char *end;
double val;
struct sample *sample;
errno = 0;
val = strtod(p, &end); // FIXME == localization issue
if (end == p)
break;
if (errno)
break;
sample = prepare_sample(dc);
sample->time.seconds = time;
add_sample_data(sample, type, val);
finish_sample(dc);
time++;
dc->duration.seconds = time;
if (*end != ',')
break;
p = end + 1;
}
record_dive(dive);
return 1;
}
static void parse_rmc(struct gps_tpv *tpv, const char **token)
{
if (is_status_valid(token[1][0]))
{
parse_time(tpv->time, token[0]);
tpv->latitude = parse_angular_distance(token[2], token[3][0]);
tpv->longitude = parse_angular_distance(token[4], token[5][0]);
tpv->track = parse_track(token[7], 'T');
tpv->speed = parse_speed(token[6], 'N');
parse_date(tpv->time, token[8]);
}
}
/* Main parser function
*/
int parse() {
token = yylex();
do {
switch (token) {
case TITLE:
if (!parse_title()) return 0;
break;
case AUTHOR:
if (!parse_author()) return 0;
break;
case DATE:
if (!parse_date()) return 0;
break;
case SECTION:
if (!parse_section()) return 0;
break;
case FRAME:
if (!parse_frame()) return 0;
break;
case PART:
if (!parse_part()) return 0;
break;
case EOF:
case ZERO:
return 1;
case NEWLINE:
token = yylex();
break;
case IMAGE:
fprintf(stderr, "[%d] Top mode: figure not allowed in top mode.\n",yylineno);
return 0;
case ANIMATION:
fprintf(stderr, "[%d] Top mode: figure not allowed in top mode.\n",yylineno);
return 0;
case LISTING:
fprintf(stderr, "[%d] Top mode: listing not allowed in top mode.\n", yylineno);
return 0;
case STRUCT:
fprintf(stderr, "[%d] Top mode: structure not allowed in top mode.\n", yylineno);
return 0;
case ITEM:
fprintf(stderr, "[%d] Top mode: item not allowed in top mode.\n", yylineno);
return 0;
default:
fprintf(stderr, "[%d] Top mode: %s \"%s\" not allowed in top mode.\n", yylineno,
get_token_name(token), yytext);
return 0;
}
} while (token != EOF);
return 1;
}
void header_retry_after(const char *s)
{
struct tm tm;
if (s[0] != 0 && strspn(s, NUMBER) == strlen(s)) {
lookup("ok");
return;
}
if (!parse_date(s, &tm))
return;
lookup("ok");
}
int parse_date_or_number(const char* s, int absolute, double *value)
{
Dates_format dummy;
const char *sdummy;
if (parse_date(s, get_date_hint(), absolute, value, &dummy)
== RETURN_SUCCESS) {
return RETURN_SUCCESS;
} else if (parse_float(s, value, &sdummy) == RETURN_SUCCESS) {
return RETURN_SUCCESS;
} else {
return RETURN_FAILURE;
}
}
/*}}}*/
int process_done(char **x)/*{{{*/
{
time_t done_time = time(NULL);
if (*x && (x[0][0] == '@')) {
int error;
done_time = parse_date(x[0]+1, done_time, 0, &error);
if (error < 0) return error;
x++;
}
internal_done(done_time, x);
return 0;
}
static time_t
pw_exppolicy(struct userconf * cnf, struct cargs * args)
{
time_t result = 0;
time_t now = time(NULL);
struct carg *arg = getarg(args, 'e');
if (arg != NULL) {
if ((result = parse_date(now, arg->val)) == now)
errx(EX_DATAERR, "invalid date/time `%s'", arg->val);
} else if (cnf->expire_days > 0)
result = now + ((long) cnf->expire_days * 86400L);
return result;
}
void HTTPAndroidRequest::onResponse(int code, std::string message, std::string etag, std::string modified, std::string cacheControl, std::string expires, std::string body) {
response = std::make_unique<Response>();
using Error = Response::Error;
response->modified = parse_date(modified.c_str());
response->etag = etag;
response->expires = parseCacheControl(cacheControl.c_str());
if (!expires.empty()) {
response->expires = parse_date(expires.c_str());
}
response->data = std::make_shared<std::string>(body);
if (code == 200) {
// Nothing to do; this is what we want
} else if (code == 304) {
if (existingResponse) {
if (existingResponse->error) {
response->error = std::make_unique<Error>(*existingResponse->error);
}
response->data = existingResponse->data;
response->modified = existingResponse->modified;
// We're not updating `expired`, it was probably set during the request.
response->etag = existingResponse->etag;
} else {
// This is an unsolicited 304 response and should only happen on malfunctioning
// HTTP servers. It likely doesn't include any data, but we don't have much options.
}
} else if (code == 404) {
response->error = std::make_unique<Error>(Error::Reason::NotFound, "HTTP status code 404");
} else if (code >= 500 && code < 600) {
response->error = std::make_unique<Error>(Error::Reason::Server, std::string{ "HTTP status code " } + std::to_string(code));
} else {
response->error = std::make_unique<Error>(Error::Reason::Other, std::string{ "HTTP status code " } + std::to_string(code));
}
async.send();
}
time_t read_agefile(char *path)
{
FILE *f;
static char buf[64], buf2[64];
if (!(f = fopen(path, "r")))
return -1;
if (fgets(buf, sizeof(buf), f) == NULL)
return -1;
fclose(f);
if (parse_date(buf, buf2, sizeof(buf2)))
return strtoul(buf2, NULL, 10);
else
return 0;
}
time_t
parse_rfc1123(const char *str, int len)
{
struct tm *tm;
time_t t;
if (NULL == str)
return -1;
tm = parse_date(str, len);
if (!tm)
return -1;
tm->tm_isdst = -1;
#ifdef HAVE_TIMEGM
t = timegm(tm);
#elif HAVE_TM_GMTOFF
t = mktime(tm);
if (t != -1) {
struct tm *local = localtime(&t);
t += local->tm_gmtoff;
}
#else
/* some systems do not have tm_gmtoff so we fake it */
t = mktime(tm);
if (t != -1) {
time_t dst = 0;
#if defined (_TIMEZONE)
#elif defined (_timezone)
#elif defined(_SQUID_AIX_)
#elif defined(_SQUID_CYGWIN_)
#elif defined(_SQUID_MSWIN_)
#elif defined(_SQUID_SGI_)
#else
extern long timezone;
#endif
/*
* The following assumes a fixed DST offset of 1 hour,
* which is probably wrong.
*/
if (tm->tm_isdst > 0)
dst = -3600;
#if defined ( _timezone) || defined(_SQUID_WIN32_)
t -= (_timezone + dst);
#else
t -= (timezone + dst);
#endif
}
#endif
return t;
}
static void parse_dates(char **argv, struct timeval *now)
{
for (; *argv; argv++) {
char result[100];
unsigned long t;
int tz;
result[0] = 0;
parse_date(*argv, result, sizeof(result));
if (sscanf(result, "%lu %d", &t, &tz) == 2)
printf("%s -> %s\n",
*argv, show_date(t, tz, DATE_ISO8601));
else
printf("%s -> bad\n", *argv);
}
}
crm_time_t *
crm_time_new(const char *date_time)
{
time_t tm_now;
crm_time_t *dt = NULL;
tzset();
if (date_time == NULL) {
tm_now = time(NULL);
dt = calloc(1, sizeof(crm_time_t));
crm_time_set_timet(dt, &tm_now);
} else {
dt = parse_date(date_time);
}
return dt;
}
progress progress_load(levelset *set, char *user) {
FILE *fp;
char buf[FILENAME_MAX+10];
char fname[FILENAME_MAX];
progress p;
p.levnum = 0;
p.date = -1;
fname[sizeof(fname)-1] = '\0';
strncpy(fname, SAVEDIR, sizeof(fname));
strncpy(fname + strlen(fname), set->name, sizeof(fname)-strlen(fname));
strncpy(fname + strlen(fname), ".", sizeof(fname)-strlen(fname));
strncpy(fname + strlen(fname), user, sizeof(fname)-strlen(fname));
strncpy(fname + strlen(fname), ".progress", sizeof(fname)-strlen(fname));
if (fname[sizeof(fname)-1] != '\0') {
/* file name length overflow */
return p;
}
fp = fopen(fname, "r");
if (!fp) {
/* unable to read progress file */
return p;
}
while (fgets(buf, sizeof(buf), fp)) {
if (buf[strlen(buf)-1] != '\n') {
/* line length overflow in save file */
return p;
}
buf[strcspn(buf, "\r\n")] = '\0';
if (ishdr(buf, "Level: ")) {
p.levnum = atoi(buf+7);
} else if (ishdr(buf, "Date: ")) {
p.date = parse_date(buf+6);
} else {
/* unrecognised keyword in progress file */
return p;
}
}
fclose(fp);
return p;
}
time_t read_agefile(char *path)
{
time_t result;
size_t size;
char *buf;
static char buf2[64];
if (readfile(path, &buf, &size))
return -1;
if (parse_date(buf, buf2, sizeof(buf2)) > 0)
result = strtoul(buf2, NULL, 10);
else
result = 0;
free(buf);
return result;
}
void header_last_modified(const char *s)
{
double diff;
time_t time0, time1;
struct tm tm;
time0 = time(0);
if (!parse_date(s, &tm))
return;
time1 = mktime_from_utc(&tm);
diff = difftime(time1, time0);
if (10 < diff)
lookup("futurelastmod");
else
lookup("ok");
}
void header_date(const char *s)
{
double diff;
time_t time0, time1;
struct tm tm;
time0 = time(0);
if (!parse_date(s, &tm))
return;
time1 = mktime_from_utc(&tm);
diff = difftime(time0, time1);
if (10 < fabs(diff))
lookup("wrongdate");
else
lookup("ok");
}
static time_t read_agefile(char *path)
{
time_t result;
size_t size;
char *buf;
struct strbuf date_buf = STRBUF_INIT;
if (readfile(path, &buf, &size))
return -1;
if (parse_date(buf, &date_buf) == 0)
result = strtoul(date_buf.buf, NULL, 10);
else
result = 0;
free(buf);
strbuf_release(&date_buf);
return result;
}
static void parse_dates(const char **argv, struct timeval *now)
{
struct strbuf result = STRBUF_INIT;
for (; *argv; argv++) {
unsigned long t;
int tz;
strbuf_reset(&result);
parse_date(*argv, &result);
if (sscanf(result.buf, "%lu %d", &t, &tz) == 2)
printf("%s -> %s\n",
*argv, show_date(t, tz, DATE_MODE(ISO8601)));
else
printf("%s -> bad\n", *argv);
}
strbuf_release(&result);
}
/*------------------------------------------------------------------------
* parse a datetime string
*/
bool ogc_datetime :: parse(
const char * str)
{
OGC_TIME timebuf;
const char * s;
char * t;
clear();
if ( str == OGC_NULL )
return false;
/* copy string, remove WS, uppercase all chars */
t = timebuf;
for (s = str; *s; s++)
{
if ( !isspace(*s) )
*t++ = (char)toupper(*s);
}
*t = 0;
s = timebuf;
if ( *s == 0 )
return false;
if ( !parse_date(&s) )
return false;
if ( *s == 0 )
return true;
if ( *s++ != 'T' )
return false;
if ( !parse_time(&s) )
return false;
if ( *s == 0 )
return true;
if ( !parse_tz(&s) )
return false;
return true;
}
void set_date(char** args, int argc) {
date_t time_struct;
int days, months, years;
get_time(&time_struct);
if (argc <1){
fprintf(STDERR, INVALID_DATE);
return;
}
if (!parse_date(args[0], &days, &months, &years)){
fprintf(STDERR, INVALID_DATE);
return;
}
time_struct.year = years;
time_struct.mon = months;
time_struct.day = days;
set_time(&time_struct);
}
