temporal-parser.cc File Reference

#include "src/temporal/temporal-parser.h"
#include <optional>
#include "src/base/bounds.h"
#include "src/objects/string-inl.h"
#include "src/strings/char-predicates-inl.h"

Include dependency graph for temporal-parser.cc:

Go to the source code of this file.

Namespaces
namespace	v8
namespace	v8::internal

Macros
#define	SCAN_FORWARD(B, T, R)
#define	SCAN_EITHER_FORWARD(B, T1, T2, R)
#define	SATISIFY(T, R)
#define	IF_SATISFY_RETURN(T)
#define	SATISIFY_EITHER(T1, T2, T3, R)
#define	DURATION_WHOLE_FRACTION_DESIGNATOR(Name, name, d)
#define	DURATION_AND_DESIGNATOR(Name, name, d)
#define	IMPL_PARSE_METHOD(R, NAME)

Macro Definition Documentation

DURATION_AND_DESIGNATOR

#define DURATION_AND_DESIGNATOR	(		Name,
			name,
			d )

Value:

  template <typename Char>                                                  \
  int32_t ScanDuration##Name##Designator(base::Vector<Char> str, int32_t s, \
                                         ParsedISO8601Duration* r) {        \
    int32_t cur = s;                                                        \
    double name;                                                            \
    if ((cur += ScanDuration##Name(str, cur, &name)) == s) return 0;        \
    if (str.length() < (cur + 1) || AsciiAlphaToLower(str[cur++]) != (d)) { \
      return 0;                                                             \
    }                                                                       \
    r->name = name;                                                         \
    return cur - s;                                                         \
  }

Definition at line 1260 of file temporal-parser.cc.

DURATION_WHOLE_FRACTION_DESIGNATOR

#define DURATION_WHOLE_FRACTION_DESIGNATOR	(		Name,
			name,
			d )

Value:

  template <typename Char>                                                \
  int32_t ScanDurationWhole##Name##FractionDesignator(                    \
      base::Vector<Char> str, int32_t s, ParsedISO8601Duration* r) {      \
    int32_t cur = s;                                                      \
    double whole = ParsedISO8601Duration::kEmpty;                         \
    cur += ScanDurationWhole##Name(str, cur, &whole);                     \
    if (cur == s) return 0;                                               \
    int32_t fraction = ParsedISO8601Duration::kEmpty;                     \
    int32_t len = ScanDuration##Name##Fraction(str, cur, &fraction);      \
    cur += len;                                                           \
    if (str.length() < (cur + 1) || AsciiAlphaToLower(str[cur++]) != (d)) \
      return 0;                                                           \
    r->whole_##name = whole;                                              \
    r->name##_fraction = fraction;                                        \
    return cur - s;                                                       \
  }

Definition at line 1181 of file temporal-parser.cc.

IF_SATISFY_RETURN

#define IF_SATISFY_RETURN

(

T

)

Value:

  {                                      \
    if (Satisfy##T(str, r)) return true; \
  }

Definition at line 1101 of file temporal-parser.cc.

IMPL_PARSE_METHOD

#define IMPL_PARSE_METHOD	(		R,
			NAME )

Value:

  std::optional<R> TemporalParser::Parse##NAME(                            \
      Isolate* isolate, DirectHandle<String> iso_string) {                 \
    bool valid;                                                            \
    R parsed;                                                              \
    iso_string = String::Flatten(isolate, iso_string);                     \
    {                                                                      \
      DisallowGarbageCollection no_gc;                                     \
      String::FlatContent str_content = iso_string->GetFlatContent(no_gc); \
      if (str_content.IsOneByte()) {                                       \
        valid = Satisfy##NAME(str_content.ToOneByteVector(), &parsed);     \
      } else {                                                             \
        valid = Satisfy##NAME(str_content.ToUC16Vector(), &parsed);        \
      }                                                                    \
    }                                                                      \
    if (valid) return parsed;                                              \
    return std::nullopt;                                                   \
  }

Definition at line 1376 of file temporal-parser.cc.

SATISIFY

#define SATISIFY	(		T,
			R )

Value:

  template <typename Char>                        \
  bool Satisfy##T(base::Vector<Char> str, R* r) { \
    R ret;                                        \
    int32_t len = Scan##T(str, 0, &ret);          \
    if ((len > 0) && (len == str.length())) {     \
      *r = ret;                                   \
      return true;                                \
    }                                             \
    return false;                                 \
  }

Definition at line 1089 of file temporal-parser.cc.

SATISIFY_EITHER

#define SATISIFY_EITHER	(		T1,
			T2,
			T3,
			R )

Value:

  template <typename Char>                         \
  bool Satisfy##T1(base::Vector<Char> str, R* r) { \
    IF_SATISFY_RETURN(T2)                          \
    IF_SATISFY_RETURN(T3)                          \
    return false;                                  \
  }

Definition at line 1106 of file temporal-parser.cc.

SCAN_EITHER_FORWARD

#define SCAN_EITHER_FORWARD	(		B,
			T1,
			T2,
			R )

Value:

  template <typename Char>                                   \
  int32_t Scan##B(base::Vector<Char> str, int32_t s, R* r) { \
    int32_t len;                                             \
    if ((len = Scan##T1(str, s, r)) > 0) return len;         \
    return Scan##T2(str, s, r);                              \
  }

Definition at line 167 of file temporal-parser.cc.

SCAN_FORWARD

#define SCAN_FORWARD	(		B,
			T,
			R )

Value:

  template <typename Char>                                   \
  int32_t Scan##B(base::Vector<Char> str, int32_t s, R* r) { \
    return Scan##T(str, s, r);                               \
  }

Definition at line 155 of file temporal-parser.cc.