path: root/util/datetime/parser.rl6

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cctype>
#include <ctime>
#include <numeric>

#include <util/datetime/parser.h>
#include <util/generic/ymath.h>


%%{

machine DateTimeParserCommon; 

sp  = ' '; 
 
action clear_int {
    I = 0; 
    Dc = 0; 
}

action update_int {
    I = I * 10 + (fc - '0'); 
    ++Dc; 
}

int = (digit+) 
    >clear_int 
    $update_int; 

int1 = digit
    >clear_int
    $update_int;

int2 = (digit digit)
    >clear_int
    $update_int;

int3 = (digit digit digit) 
    >clear_int 
    $update_int; 
 
int4 = (digit digit digit digit)
    >clear_int
    $update_int;

int12 = (digit digit?)
    >clear_int
    $update_int;

int24 = ( digit digit ( digit digit )? )
    >clear_int
    $update_int;

# According to both RFC2822 and RFC2616 dates MUST be case-sensitive, 
# but Andrey fomichev@ wants relaxed parser 
 
month3 = 
      'Jan'i %{ DateTimeFields.Month =  1; } 
    | 'Feb'i %{ DateTimeFields.Month =  2; } 
    | 'Mar'i %{ DateTimeFields.Month =  3; } 
    | 'Apr'i %{ DateTimeFields.Month =  4; } 
    | 'May'i %{ DateTimeFields.Month =  5; } 
    | 'Jun'i %{ DateTimeFields.Month =  6; } 
    | 'Jul'i %{ DateTimeFields.Month =  7; } 
    | 'Aug'i %{ DateTimeFields.Month =  8; } 
    | 'Sep'i %{ DateTimeFields.Month =  9; } 
    | 'Oct'i %{ DateTimeFields.Month = 10; } 
    | 'Nov'i %{ DateTimeFields.Month = 11; } 
    | 'Dec'i %{ DateTimeFields.Month = 12; }; 
 
wkday   = 'Mon'i | 'Tue'i | 'Wed'i | 'Thu'i | 'Fri'i | 'Sat'i | 'Sun'i; 
weekday = 'Monday'i | 'Tuesday'i | 'Wednesday'i | 'Thursday'i 
        | 'Friday'i | 'Saturday'i | 'Sunday'i; 
 
action set_second   { DateTimeFields.Second = I; } 
action set_minute   { DateTimeFields.Minute = I; } 
action set_hour     { DateTimeFields.Hour = I; } 
action set_day      { DateTimeFields.Day = I; } 
action set_month    { DateTimeFields.Month = I; } 
action set_year     { DateTimeFields.SetLooseYear(I); } 
action set_zone_utc { DateTimeFields.ZoneOffsetMinutes = 0; } 
 
}%% 
 
%%{ 
 
machine RFC822DateParser; 
 
################# RFC 2822 3.3 Full Date ################### 
 
include DateTimeParserCommon; 
 
ws1 = (space+); 
ws0 = (space*); 
dow_spec = ( wkday ',' )?; 
 
day  = int12 %set_day; 
year = int24 %set_year;

# actually it must be from 0 to 23
hour = int2 %set_hour; 

# actually it must be from 0 to 59
min  = int2 %set_minute; 

# actually it must be from 0 to 59
sec  = int2 %set_second; 

sec_spec  = ( ':' . sec )?;

# so called "military zone offset". I hardly believe someone uses it now, but we MUST respect RFc822
action set_mil_offset {
    char c = (char)toupper(fc);
    if (c == 'Z')
        DateTimeFields.ZoneOffsetMinutes = 0; 
    else {
        if (c <= 'M') {
            // ['A'..'M'] \ 'J'
            if (c < 'J')
                DateTimeFields.ZoneOffsetMinutes = (i32)TDuration::Hours(c - 'A' + 1).Minutes();
            else
                DateTimeFields.ZoneOffsetMinutes = (i32)TDuration::Hours(c - 'A').Minutes();
        } else {
            // ['N'..'Y']
            DateTimeFields.ZoneOffsetMinutes = -(i32)TDuration::Hours(c - 'N' + 1).Minutes();
        }
    }
}

action set_digit_offset {
    DateTimeFields.ZoneOffsetMinutes = Sign * (i32)(TDuration::Hours(I / 100) + TDuration::Minutes(I % 100)).Minutes();
}

mil_zone = /[A-IK-Za-ik-z]/ $set_mil_offset;

# actions % were replaced with @ (when the script was migrated to ragel 5.24)
# because ragel 5.24 does not call to the % action if it  be called at the very end of string.
# it is a bug in ragel 5 because ragel 6.2 works correctly with % at the end of string.
# see http://www.complang.org/ragel/ChangeLog.

zone = 'UT' @{ DateTimeFields.ZoneOffsetMinutes = 0; } 
    | 'GMT' @{ DateTimeFields.ZoneOffsetMinutes = 0; } 
    | 'EST' @{ DateTimeFields.ZoneOffsetMinutes = -(i32)TDuration::Hours(5).Minutes();}
    | 'EDT' @{ DateTimeFields.ZoneOffsetMinutes = -(i32)TDuration::Hours(4).Minutes(); }
    | 'CST' @{ DateTimeFields.ZoneOffsetMinutes = -(i32)TDuration::Hours(6).Minutes();}
    | 'CDT' @{ DateTimeFields.ZoneOffsetMinutes = -(i32)TDuration::Hours(5).Minutes(); }
    | 'MST' @{ DateTimeFields.ZoneOffsetMinutes = -(i32)TDuration::Hours(7).Minutes();}
    | 'MDT' @{ DateTimeFields.ZoneOffsetMinutes = -(i32)TDuration::Hours(6).Minutes(); }
    | 'PST' @{ DateTimeFields.ZoneOffsetMinutes = -(i32)TDuration::Hours(8).Minutes();}
    | 'PDT' @{ DateTimeFields.ZoneOffsetMinutes = -(i32)TDuration::Hours(7).Minutes(); };

digit_offset = ('+' | '-') > { Sign = fc == '+' ? 1 : -1; } . int4 @set_digit_offset; 

offset = ( zone | mil_zone | digit_offset );

rfc822datetime = ws0 . dow_spec . ws0 . day . ws1 . month3 . ws1 . year . ws1 . hour . ':' . min . sec_spec . ws1 . offset . ws0; 

main := rfc822datetime; 

write data noerror;

}%%

TRfc822DateTimeParserDeprecated::TRfc822DateTimeParserDeprecated() {
    %% write init; 
} 

bool TRfc822DateTimeParserDeprecated::ParsePart(const char* input, size_t len) {
    const char* p = input; 
    const char* pe = input + len; 

    %% write exec; 
    return cs != %%{ write error; }%%; 
} 

TRfc822DateTimeParser::TRfc822DateTimeParser() {
    %% write init;
}

bool TRfc822DateTimeParser::ParsePart(const char* input, size_t len) {
    const char* p = input;
    const char* pe = input + len;

    %% write exec;
    return cs != %%{ write error; }%%;
}

%%{ 
 
machine ISO8601DateTimeParser; 
 
include DateTimeParserCommon; 
 
year = int4 @set_year; 
month = int2 @set_month; 
day = int2 @set_day; 
hour = int2 @set_hour; 
minute = int2 @set_minute; 
second = int2 @set_second; 
secondFrac = digit {1,6} >clear_int $update_int @{
    ui32 us = I; 
    for (int k = Dc; k < 6; ++k) { 
        us *= 10; 
    } 
    DateTimeFields.MicroSecond = us; 
}; 
secondFracTail = (digit*);
 
zoneZ = [Zz] @set_zone_utc; 
zoneOffset = space? . ('+' | '-') >{ Sign = fc == '+' ? 1 : -1; } . int2 @{ DateTimeFields.ZoneOffsetMinutes = Sign * (i32)TDuration::Hours(I).Minutes(); } . (':')? . (int2 @{ DateTimeFields.ZoneOffsetMinutes += I * Sign; })?;
zone = zoneZ | zoneOffset; 
 
iso8601date = (year . '-' . month . '-' . day) | (year . month . day); 
iso8601time = (hour . ':' . minute . (':' . second ('.' secondFrac secondFracTail)?)?) | (hour . minute . second?);
 
iso8601datetime = iso8601date . ([Tt ] . iso8601time . zone?)?; 
 
main := iso8601datetime; 
 
write data noerror; 
 
}%% 
 
TIso8601DateTimeParserDeprecated::TIso8601DateTimeParserDeprecated() {
    %% write init;
} 
 
bool TIso8601DateTimeParserDeprecated::ParsePart(const char* input, size_t len) {
    const char* p = input; 
    const char* pe = input + len; 
 
    %% write exec;
    return cs != %%{ write error; }%%; 
} 

TIso8601DateTimeParser::TIso8601DateTimeParser() {
    %% write init;
}

bool TIso8601DateTimeParser::ParsePart(const char* input, size_t len) {
    const char* p = input;
    const char* pe = input + len;

    %% write exec;
    return cs != %%{ write error; }%%;
}

%%{ 
 
machine HttpDateTimeParser; 
 
include DateTimeParserCommon; 
 
################# RFC 2616 3.3.1 Full Date ################# 
 
time            = int2 %set_hour ':' int2 %set_minute ':' int2 %set_second; 
date1           = int2 %set_day ' ' month3 ' ' int4 %set_year; 
date2           = int2 %set_day '-' month3 '-' int2 %set_year; 
date3           = month3 sp (int2 | sp int1) %set_day; 
 
rfc1123_date    = wkday ',' sp date1 sp time sp 'GMT'i; 
rfc850_date     = weekday ',' sp date2 sp time sp 'GMT'i; 
asctime_date    = wkday sp date3 sp time sp int4 @set_year; 
http_date       = (rfc1123_date | rfc850_date | asctime_date) @set_zone_utc; 
 
}%% 
 
%%{ 
 
machine HttpDateTimeParserStandalone; 
 
include HttpDateTimeParser; 
 
main := http_date; 
 
write data noerror; 
 
}%% 
 
THttpDateTimeParserDeprecated::THttpDateTimeParserDeprecated() {
    %% write init; 
} 
 
bool THttpDateTimeParserDeprecated::ParsePart(const char* input, size_t len) {
    const char* p = input; 
    const char* pe = input + len; 
 
    %% write exec; 
    return cs != %%{ write error; }%%; 
} 
 
THttpDateTimeParser::THttpDateTimeParser() {
    %% write init;
}

bool THttpDateTimeParser::ParsePart(const char* input, size_t len) {
    const char* p = input;
    const char* pe = input + len;

    %% write exec;
    return cs != %%{ write error; }%%;
}

%%{

machine X509ValidityDateTimeParser;

include DateTimeParserCommon;

################# X.509 certificate validity time (see rfc5280 4.1.2.5.*) #################

year = int2 @{ DateTimeFields.Year = (I < 50 ? I + 2000 : I + 1900); };
month = int2 @set_month;
day = int2 @set_day;
hour = int2 @set_hour;
minute = int2 @set_minute;
second = int2 @set_second;
zone = 'Z' @set_zone_utc;

main := year . month . day . hour . minute . second . zone;

write data noerror;

}%%

TX509ValidityDateTimeParserDeprecated::TX509ValidityDateTimeParserDeprecated() {
    %% write init;
}

bool TX509ValidityDateTimeParserDeprecated::ParsePart(const char *input, size_t len) {
    const char *p = input;
    const char *pe = input + len;

    %% write exec;
    return cs != %%{ write error; }%%; 
}

TX509ValidityDateTimeParser::TX509ValidityDateTimeParser() {
    %% write init;
}

bool TX509ValidityDateTimeParser::ParsePart(const char *input, size_t len) {
    const char *p = input;
    const char *pe = input + len;

    %% write exec;
    return cs != %%{ write error; }%%;
}

%%{

machine X509Validity4yDateTimeParser;

include DateTimeParserCommon;

year = int4 @{ DateTimeFields.Year = I; };
month = int2 @set_month;
day = int2 @set_day;
hour = int2 @set_hour;
minute = int2 @set_minute;
second = int2 @set_second;
zone = 'Z' @set_zone_utc;


main := year . month . day . hour . minute . second . zone;

write data noerror;

}%%

TX509Validity4yDateTimeParserDeprecated::TX509Validity4yDateTimeParserDeprecated() {
    %% write init;
}

bool TX509Validity4yDateTimeParserDeprecated::ParsePart(const char *input, size_t len) {
    const char *p = input;
    const char *pe = input + len;

    %% write exec;
    return cs != %%{ write error; }%%; 
}

TX509Validity4yDateTimeParser::TX509Validity4yDateTimeParser() {
    %% write init;
}

bool TX509Validity4yDateTimeParser::ParsePart(const char *input, size_t len) {
    const char *p = input;
    const char *pe = input + len;

    %% write exec;
    return cs != %%{ write error; }%%;
}

TInstant TIso8601DateTimeParserDeprecated::GetResult(TInstant defaultValue) const {
    Y_UNUSED(ISO8601DateTimeParser_en_main);
    return TDateTimeParserBaseDeprecated::GetResult(ISO8601DateTimeParser_first_final, defaultValue);
} 
 
TInstant TRfc822DateTimeParserDeprecated::GetResult(TInstant defaultValue) const {
    Y_UNUSED(RFC822DateParser_en_main);
    return TDateTimeParserBaseDeprecated::GetResult(RFC822DateParser_first_final, defaultValue);
} 
 
TInstant THttpDateTimeParserDeprecated::GetResult(TInstant defaultValue) const {
    Y_UNUSED(HttpDateTimeParserStandalone_en_main);
    return TDateTimeParserBaseDeprecated::GetResult(HttpDateTimeParserStandalone_first_final, defaultValue);
} 
 
TInstant TX509ValidityDateTimeParserDeprecated::GetResult(TInstant defaultValue) const {
    Y_UNUSED(X509ValidityDateTimeParser_en_main);
    return TDateTimeParserBaseDeprecated::GetResult(X509ValidityDateTimeParser_first_final, defaultValue);
}
 
TInstant TX509Validity4yDateTimeParserDeprecated::GetResult(TInstant defaultValue) const {
    Y_UNUSED(X509Validity4yDateTimeParser_en_main);
    return TDateTimeParserBaseDeprecated::GetResult(X509Validity4yDateTimeParser_first_final, defaultValue);
}

TInstant TIso8601DateTimeParser::GetResult(TInstant defaultValue) const {
    Y_UNUSED(ISO8601DateTimeParser_en_main);
    return TDateTimeParserBase::GetResult(ISO8601DateTimeParser_first_final, defaultValue);
}

TInstant TRfc822DateTimeParser::GetResult(TInstant defaultValue) const {
    Y_UNUSED(RFC822DateParser_en_main);
    return TDateTimeParserBase::GetResult(RFC822DateParser_first_final, defaultValue);
}

TInstant THttpDateTimeParser::GetResult(TInstant defaultValue) const {
    Y_UNUSED(HttpDateTimeParserStandalone_en_main);
    return TDateTimeParserBase::GetResult(HttpDateTimeParserStandalone_first_final, defaultValue);
}

TInstant TX509ValidityDateTimeParser::GetResult(TInstant defaultValue) const {
    Y_UNUSED(X509ValidityDateTimeParser_en_main);
    return TDateTimeParserBase::GetResult(X509ValidityDateTimeParser_first_final, defaultValue);
}

TInstant TX509Validity4yDateTimeParser::GetResult(TInstant defaultValue) const {
    Y_UNUSED(X509Validity4yDateTimeParser_en_main);
    return TDateTimeParserBase::GetResult(X509Validity4yDateTimeParser_first_final, defaultValue);
}

template<class TParser, class TResult> 
static inline TResult Parse(const char* input, size_t len, TResult defaultValue) { 
    TParser parser; 
    if (!parser.ParsePart(input, len)) 
        return defaultValue; 
    return parser.GetResult(defaultValue); 
} 
 
template<class TParser, class TResult, bool ThrowExceptionOnFailure = true>
static inline TResult ParseUnsafe(const char* input, size_t len) { 
    TResult r = Parse<TParser, TResult>(input, len, TResult::Max()); 
    if (ThrowExceptionOnFailure && r == TResult::Max())
        ythrow TDateTimeParseException() << "error in datetime parsing. Input data: " << TStringBuf(input, len);
    return r; 
} 
 
TInstant TInstant::ParseIso8601Deprecated(const TStringBuf input) {
    return ParseUnsafe<TIso8601DateTimeParserDeprecated, TInstant>(input.data(), input.size());
} 
 
TInstant TInstant::ParseRfc822Deprecated(const TStringBuf input) {
    return ParseUnsafe<TRfc822DateTimeParserDeprecated, TInstant>(input.data(), input.size());
} 
 
TInstant TInstant::ParseHttpDeprecated(const TStringBuf input) {
    return ParseUnsafe<THttpDateTimeParserDeprecated, TInstant>(input.data(), input.size());
} 
 
TInstant TInstant::ParseX509ValidityDeprecated(const TStringBuf input) {
    switch (input.size()) {
    case 13:
        return ParseUnsafe<TX509ValidityDateTimeParserDeprecated, TInstant>(input.data(), 13);
    case 15:
        return ParseUnsafe<TX509Validity4yDateTimeParserDeprecated, TInstant>(input.data(), 15);
    default:
        ythrow TDateTimeParseException();
    }
}
 
bool TInstant::TryParseIso8601Deprecated(const TStringBuf input, TInstant& instant) {
    const auto parsed = ParseUnsafe<TIso8601DateTimeParserDeprecated, TInstant, false>(input.data(), input.size());
    if (TInstant::Max() == parsed) {
        return false;
    }
    instant = parsed;
    return true;
}

bool TInstant::TryParseRfc822Deprecated(const TStringBuf input, TInstant& instant) {
    const auto parsed = ParseUnsafe<TRfc822DateTimeParserDeprecated, TInstant, false>(input.data(), input.size());
    if (TInstant::Max() == parsed) {
        return false;
    }
    instant = parsed;
    return true;
}

bool TInstant::TryParseHttpDeprecated(const TStringBuf input, TInstant& instant) {
    const auto parsed = ParseUnsafe<THttpDateTimeParserDeprecated, TInstant, false>(input.data(), input.size());
    if (TInstant::Max() == parsed) {
        return false;
    }
    instant = parsed;
    return true;
}

bool TInstant::TryParseX509Deprecated(const TStringBuf input, TInstant& instant) {
    TInstant parsed;
    switch (input.size()) {
        case 13:
            parsed = ParseUnsafe<TX509ValidityDateTimeParserDeprecated, TInstant, false>(input.data(), 13);
            break;
        case 15:
            parsed = ParseUnsafe<TX509Validity4yDateTimeParserDeprecated, TInstant, false>(input.data(), 15);
            break;
        default:
            return false;
    }
    if (TInstant::Max() == parsed) {
        return false;
    }
    instant = parsed;
    return true;
}

TInstant TInstant::ParseIso8601(const TStringBuf input) {
    return ParseUnsafe<TIso8601DateTimeParser, TInstant>(input.data(), input.size());
}

TInstant TInstant::ParseRfc822(const TStringBuf input) {
    return ParseUnsafe<TRfc822DateTimeParser, TInstant>(input.data(), input.size());
}

TInstant TInstant::ParseHttp(const TStringBuf input) {
    return ParseUnsafe<THttpDateTimeParser, TInstant>(input.data(), input.size());
}

TInstant TInstant::ParseX509Validity(const TStringBuf input) {
    switch (input.size()) {
    case 13:
        return ParseUnsafe<TX509ValidityDateTimeParser, TInstant>(input.data(), 13);
    case 15:
        return ParseUnsafe<TX509Validity4yDateTimeParser, TInstant>(input.data(), 15);
    default:
        ythrow TDateTimeParseException();
    }
}

bool TInstant::TryParseIso8601(const TStringBuf input, TInstant& instant) {
    const auto parsed = ParseUnsafe<TIso8601DateTimeParser, TInstant, false>(input.data(), input.size());
    if (TInstant::Max() == parsed) {
        return false;
    }
    instant = parsed;
    return true;
}

bool TInstant::TryParseRfc822(const TStringBuf input, TInstant& instant) {
    const auto parsed = ParseUnsafe<TRfc822DateTimeParser, TInstant, false>(input.data(), input.size());
    if (TInstant::Max() == parsed) {
        return false;
    }
    instant = parsed;
    return true;
}

bool TInstant::TryParseHttp(const TStringBuf input, TInstant& instant) {
    const auto parsed = ParseUnsafe<THttpDateTimeParser, TInstant, false>(input.data(), input.size());
    if (TInstant::Max() == parsed) {
        return false;
    }
    instant = parsed;
    return true;
}

bool TInstant::TryParseX509(const TStringBuf input, TInstant& instant) {
    TInstant parsed;
    switch (input.size()) {
        case 13:
            parsed = ParseUnsafe<TX509ValidityDateTimeParser, TInstant, false>(input.data(), 13);
            break;
        case 15:
            parsed = ParseUnsafe<TX509Validity4yDateTimeParser, TInstant, false>(input.data(), 15);
            break;
        default:
            return false;
    }
    if (TInstant::Max() == parsed) {
        return false;
    }
    instant = parsed;
    return true;
}

bool ParseRFC822DateTimeDeprecated(const char* input, time_t& utcTime) {
    return ParseRFC822DateTimeDeprecated(input, strlen(input), utcTime);
}

bool ParseISO8601DateTimeDeprecated(const char* input, time_t& utcTime) {
    return ParseISO8601DateTimeDeprecated(input, strlen(input), utcTime);
}

bool ParseHTTPDateTimeDeprecated(const char* input, time_t& utcTime) {
    return ParseHTTPDateTimeDeprecated(input, strlen(input), utcTime);
}

bool ParseX509ValidityDateTimeDeprecated(const char* input, time_t& utcTime) {
    return ParseX509ValidityDateTimeDeprecated(input, strlen(input), utcTime);
}

bool ParseRFC822DateTimeDeprecated(const char* input, size_t inputLen, time_t& utcTime) {
    try {
        utcTime = ParseUnsafe<TRfc822DateTimeParserDeprecated, TInstant>(input, inputLen).TimeT();
        return true;
    } catch (const TDateTimeParseException&) {
        return false;
    }
}

bool ParseISO8601DateTimeDeprecated(const char* input, size_t inputLen, time_t& utcTime) {
    try {
        utcTime = ParseUnsafe<TIso8601DateTimeParserDeprecated, TInstant>(input, inputLen).TimeT();
        return true;
    } catch (const TDateTimeParseException&) {
        return false;
    }
}

bool ParseHTTPDateTimeDeprecated(const char* input, size_t inputLen, time_t& utcTime) {
    try {
        utcTime = ParseUnsafe<THttpDateTimeParserDeprecated, TInstant>(input, inputLen).TimeT();
        return true;
    } catch (const TDateTimeParseException&) {
        return false;
    }
}

bool ParseX509ValidityDateTimeDeprecated(const char* input, size_t inputLen, time_t& utcTime) {
    TInstant r;
    switch (inputLen) {
    case 13:
        r = Parse<TX509ValidityDateTimeParserDeprecated, TInstant>(input, 13, TInstant::Max());
        break;
    case 15:
        r = Parse<TX509Validity4yDateTimeParserDeprecated, TInstant>(input, 15, TInstant::Max());
        break;
    default:
        return false;
    }
    if (r == TInstant::Max())
        return false;
    utcTime = r.TimeT();
    return true;
}

bool ParseRFC822DateTime(const char* input, time_t& utcTime) {
    return ParseRFC822DateTime(input, strlen(input), utcTime);
}

bool ParseISO8601DateTime(const char* input, time_t& utcTime) { 
    return ParseISO8601DateTime(input, strlen(input), utcTime); 
} 
 
bool ParseHTTPDateTime(const char* input, time_t& utcTime) { 
    return ParseHTTPDateTime(input, strlen(input), utcTime); 
} 
 
bool ParseX509ValidityDateTime(const char* input, time_t& utcTime) {
    return ParseX509ValidityDateTime(input, strlen(input), utcTime);
}
 
bool ParseRFC822DateTime(const char* input, size_t inputLen, time_t& utcTime) {
    try { 
        utcTime = ParseUnsafe<TRfc822DateTimeParser, TInstant>(input, inputLen).TimeT();
        return true; 
    } catch (const TDateTimeParseException&) { 
        return false;
    } 
} 
 
bool ParseISO8601DateTime(const char* input, size_t inputLen, time_t& utcTime) {
    try { 
        utcTime = ParseUnsafe<TIso8601DateTimeParser, TInstant>(input, inputLen).TimeT();
        return true;
    } catch (const TDateTimeParseException&) { 
        return false; 
    }
}
 
bool ParseHTTPDateTime(const char* input, size_t inputLen, time_t& utcTime) { 
    try { 
        utcTime = ParseUnsafe<THttpDateTimeParser, TInstant>(input, inputLen).TimeT();
        return true; 
    } catch (const TDateTimeParseException&) { 
        return false; 
    } 
} 

bool ParseX509ValidityDateTime(const char* input, size_t inputLen, time_t& utcTime) {
    TInstant r;
    switch (inputLen) {
    case 13:
        r = Parse<TX509ValidityDateTimeParser, TInstant>(input, 13, TInstant::Max());
        break;
    case 15:
        r = Parse<TX509Validity4yDateTimeParser, TInstant>(input, 15, TInstant::Max());
        break;
    default:
        return false;
    }
    if (r == TInstant::Max())
        return false;
    utcTime = r.TimeT();
    return true;
}

%%{ 
 
machine TDurationParser; 
 
include DateTimeParserCommon; 
 
 
multiplier 
    = '' #   >{ MultiplierPower =  6; } # work around Ragel bugs 
    | 'w'  @{ MultiplierPower =  6; Multiplier = 604800; }
    | 'd'  @{ MultiplierPower =  6; Multiplier = 86400; }
    | 'h'  @{ MultiplierPower =  6; Multiplier = 3600; }
    | 'm'  @{ MultiplierPower =  6; Multiplier = 60; }
    | 's'  @{ MultiplierPower =  6; Multiplier = 1; }
    | 'ms' @{ MultiplierPower =  3; Multiplier = 1; }
    | 'us' @{ MultiplierPower =  0; Multiplier = 1; }
    | 'ns' @{ MultiplierPower = -3; Multiplier = 1; }
    ; 
 
integer = int @{ IntegerPart = I; }; 
 
fraction = '.' digit {1,6} >clear_int $update_int @{ FractionPart = I; FractionDigits = Dc; } digit*; 
 
duration = integer fraction? multiplier; 
 
main := duration; 
 
write data noerror; 
 
}%% 
 
TDurationParser::TDurationParser() 
    : cs(0) 
    , I(0) 
    , Dc(0) 
    , MultiplierPower(6) 
    , Multiplier(1)
    , IntegerPart(0) 
    , FractionPart(0) 
    , FractionDigits(0) 
{ 
    Y_UNUSED(TDurationParser_en_main);
    %% write init; 
} 
 
bool TDurationParser::ParsePart(const char* input, size_t len) { 
    const char* p = input; 
    const char* pe = input + len; 
 
    %% write exec; 
    return cs != %%{ write error; }%%; 
} 
 
static inline ui64 DecPower(ui64 part, i32 power) {
    if (power >= 0)
        return part * Power(10, power);
    return part / Power(10, -power);
} 
 
TDuration TDurationParser::GetResult(TDuration defaultValue) const { 
    if (cs < TDurationParser_first_final) 
        return defaultValue; 
    ui64 us = 0; 
    us += Multiplier * DecPower(IntegerPart, MultiplierPower);
    us += Multiplier * DecPower(FractionPart, MultiplierPower - FractionDigits);
    return TDuration::MicroSeconds(us); 
} 
 
bool TDuration::TryParse(const TStringBuf input, TDuration& result) {
    TDuration r = ::Parse<TDurationParser, TDuration>(input.data(), input.size(), TDuration::Max());
    if (r == TDuration::Max())
        return false;
    result = r;
    return true;
}
 
TDuration TDuration::Parse(const TStringBuf input) {
    return ParseUnsafe<TDurationParser, TDuration>(input.data(), input.size());
}