js/src/builtin/temporal/TemporalParser.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
   2  * vim: set ts=8 sts=2 et sw=2 tw=80:
   3  * This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #ifndef builtin_temporal_TemporalParser_h
   8 #define builtin_temporal_TemporalParser_h
   9
  10 #include "mozilla/Assertions.h"
  11
  12 #include <cstdlib>
  13 #include <stdint.h>
  14
  15 #include "builtin/temporal/TemporalUnit.h"
  16 #include "js/RootingAPI.h"
  17 #include "js/TypeDecls.h"
  18
  19 class JSLinearString;
  20 class JS_PUBLIC_API JSTracer;
  21
  22 namespace js::temporal {
  23
  24 struct Duration;
  25 struct PlainDate;
  26 struct PlainDateTime;
  27 struct PlainTime;
  28
  29 struct ParsedTimeZone {
  30   JSLinearString* name = nullptr;
  31   int32_t offset = INT32_MIN;
  32
  33   void trace(JSTracer* trc);
  34
  35   static ParsedTimeZone fromName(JSLinearString* name) {
  36     MOZ_ASSERT(name);
  37     return {name, 0};
  38   }
  39
  40   static ParsedTimeZone fromOffset(int32_t offset) {
  41     MOZ_ASSERT(std::abs(offset) < UnitsPerDay(TemporalUnit::Minute));
  42     return {nullptr, offset};
  43   }
  44
  45   explicit operator bool() const {
  46     return name != nullptr || offset != INT32_MIN;
  47   }
  48 };
  49
  50 /**
  51  * ParseTemporalInstantString ( isoString )
  52  */
  53 bool ParseTemporalInstantString(JSContext* cx, JS::Handle<JSString*> str,
  54                                 PlainDateTime* result, int64_t* offset);
  55
  56 /**
  57  * ParseTemporalTimeZoneString ( timeZoneString )
  58  */
  59 bool ParseTemporalTimeZoneString(JSContext* cx, JS::Handle<JSString*> str,
  60                                  JS::MutableHandle<ParsedTimeZone> result);
  61
  62 /**
  63  * ParseTimeZoneIdentifier ( identifier )
  64  */
  65 bool ParseTimeZoneIdentifier(JSContext* cx, JS::Handle<JSString*> str,
  66                              JS::MutableHandle<ParsedTimeZone> result);
  67
  68 /**
  69  * ParseTimeZoneOffsetString ( isoString )
  70  */
  71 bool ParseTimeZoneOffsetString(JSContext* cx, JS::Handle<JSString*> str,
  72                                int32_t* result);
  73
  74 /**
  75  * ParseDateTimeUTCOffset ( offsetString )
  76  */
  77 bool ParseDateTimeUTCOffset(JSContext* cx, JS::Handle<JSString*> str,
  78                             int64_t* result);
  79
  80 /**
  81  * ParseTemporalDurationString ( isoString )
  82  */
  83 bool ParseTemporalDurationString(JSContext* cx, JS::Handle<JSString*> str,
  84                                  Duration* result);
  85
  86 /**
  87  * ParseTemporalCalendarString ( isoString )
  88  */
  89 JSLinearString* ParseTemporalCalendarString(JSContext* cx,
  90                                             JS::Handle<JSString*> str);
  91
  92 /**
  93  * ParseTemporalTimeString ( isoString )
  94  */
  95 bool ParseTemporalTimeString(JSContext* cx, JS::Handle<JSString*> str,
  96                              PlainTime* result);
  97
  98 /**
  99  * ParseTemporalDateString ( isoString )
 100  */
 101 bool ParseTemporalDateString(JSContext* cx, JS::Handle<JSString*> str,
 102                              PlainDate* result,
 103                              JS::MutableHandle<JSString*> calendar);
 104
 105 /**
 106  * ParseTemporalMonthDayString ( isoString )
 107  */
 108 bool ParseTemporalMonthDayString(JSContext* cx, JS::Handle<JSString*> str,
 109                                  PlainDate* result, bool* hasYear,
 110                                  JS::MutableHandle<JSString*> calendar);
 111
 112 /**
 113  * ParseTemporalYearMonthString ( isoString )
 114  */
 115 bool ParseTemporalYearMonthString(JSContext* cx, JS::Handle<JSString*> str,
 116                                   PlainDate* result,
 117                                   JS::MutableHandle<JSString*> calendar);
 118
 119 /**
 120  * ParseTemporalDateTimeString ( isoString )
 121  */
 122 bool ParseTemporalDateTimeString(JSContext* cx, JS::Handle<JSString*> str,
 123                                  PlainDateTime* result,
 124                                  JS::MutableHandle<JSString*> calendar);
 125
 126 /**
 127  * ParseTemporalZonedDateTimeString ( isoString )
 128  */
 129 bool ParseTemporalZonedDateTimeString(
 130     JSContext* cx, JS::Handle<JSString*> str, PlainDateTime* dateTime,
 131     bool* isUTC, bool* hasOffset, int64_t* timeZoneOffset,
 132     JS::MutableHandle<ParsedTimeZone> timeZoneName,
 133     JS::MutableHandle<JSString*> calendar);
 134
 135 /**
 136  * ParseTemporalRelativeToString ( isoString )
 137  */
 138 bool ParseTemporalRelativeToString(
 139     JSContext* cx, JS::Handle<JSString*> str, PlainDateTime* dateTime,
 140     bool* isUTC, bool* hasOffset, int64_t* timeZoneOffset,
 141     JS::MutableHandle<ParsedTimeZone> timeZoneName,
 142     JS::MutableHandle<JSString*> calendar);
 143
 144 } /* namespace js::temporal */
 145
 146 namespace js {
 147
 148 template <typename Wrapper>
 149 class WrappedPtrOperations<temporal::ParsedTimeZone, Wrapper> {
 150   const auto& object() const {
 151     return static_cast<const Wrapper*>(this)->get();
 152   }
 153
 154  public:
 155   JS::Handle<JSLinearString*> name() const {
 156     return JS::Handle<JSLinearString*>::fromMarkedLocation(&object().name);
 157   }
 158
 159   int32_t offset() const { return object().offset; }
 160
 161   explicit operator bool() const { return bool(object()); }
 162 };
 163
 164 } /* namespace js */
 165
 166 #endif /* builtin_temporal_TemporalParser_h */