LCOV - code coverage report
Current view: top level - gi - js-value-inl.h (source / functions) Coverage Total Hit
Test: gjs- Code Coverage Lines: 92.8 % 111 103
Test Date: 2024-04-29 05:18:28 Functions: 98.6 % 73 72
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 85.7 % 56 48

             Branch data     Line data    Source code
       1                 :             : /* -*- mode: C++; c-basic-offset: 4; indent-tabs-mode: nil; -*- */
       2                 :             : // SPDX-License-Identifier: MIT OR LGPL-2.0-or-later
       3                 :             : // SPDX-FileCopyrightText: 2020 Marco Trevisan <marco.trevisan@canonical.com>
       4                 :             : 
       5                 :             : #pragma once
       6                 :             : 
       7                 :             : #include <config.h>
       8                 :             : 
       9                 :             : #include <stdint.h>
      10                 :             : 
      11                 :             : #include <cmath>  // for isnan
      12                 :             : #include <limits>
      13                 :             : #include <string>
      14                 :             : 
      15                 :             : #include <girepository.h>
      16                 :             : #include <glib-object.h>
      17                 :             : #include <glib.h>
      18                 :             : 
      19                 :             : #include <js/BigInt.h>
      20                 :             : #include <js/Conversions.h>
      21                 :             : #include <js/RootingAPI.h>
      22                 :             : #include <js/TypeDecls.h>
      23                 :             : #include <js/Utility.h>  // for UniqueChars
      24                 :             : #include <js/Value.h>    // for CanonicalizeNaN
      25                 :             : 
      26                 :             : #include "gi/gtype.h"
      27                 :             : #include "gi/value.h"
      28                 :             : #include "gjs/jsapi-util.h"
      29                 :             : #include "gjs/macros.h"
      30                 :             : 
      31                 :             : namespace Gjs {
      32                 :             : 
      33                 :             : template <typename T>
      34                 :             : struct TypeWrapper {
      35                 :             :     constexpr TypeWrapper() : m_value(0) {}
      36                 :        1613 :     explicit constexpr TypeWrapper(T v) : m_value(v) {}
      37                 :             :     constexpr operator T() const { return m_value; }
      38                 :        1609 :     constexpr operator T() { return m_value; }
      39                 :             : 
      40                 :             :  private:
      41                 :             :     T m_value;
      42                 :             : };
      43                 :             : 
      44                 :             : namespace JsValueHolder {
      45                 :             : 
      46                 :             : template <typename T1, typename T2>
      47                 :             : constexpr bool comparable_types() {
      48                 :             :     return std::is_arithmetic_v<T1> == std::is_arithmetic_v<T2> &&
      49                 :             :            std::is_signed_v<T1> == std::is_signed_v<T2>;
      50                 :             : }
      51                 :             : 
      52                 :             : template <typename T, typename Container>
      53                 :             : constexpr bool type_fits() {
      54                 :             :     if constexpr (comparable_types<T, Container>()) {
      55                 :             :         return (std::is_integral_v<T> == std::is_integral_v<Container> &&
      56                 :             :                 std::numeric_limits<T>::max() <=
      57                 :             :                     std::numeric_limits<Container>::max() &&
      58                 :             :                 std::numeric_limits<T>::lowest() >=
      59                 :             :                     std::numeric_limits<Container>::lowest());
      60                 :             :     }
      61                 :             : 
      62                 :             :     return false;
      63                 :             : }
      64                 :             : 
      65                 :             : /* The tag is needed to disambiguate types such as gboolean and GType
      66                 :             :  * which are in fact typedef's of other generic types.
      67                 :             :  * Setting a tag for a type allows to perform proper specialization. */
      68                 :             : template <typename T, GITypeTag TAG>
      69                 :             : constexpr auto get_strict() {
      70                 :             :     if constexpr (TAG != GI_TYPE_TAG_VOID) {
      71                 :             :         if constexpr (std::is_same_v<T, GType> && TAG == GI_TYPE_TAG_GTYPE)
      72                 :             :             return GType{};
      73                 :             :         else if constexpr (std::is_same_v<T, gboolean> &&
      74                 :             :                            TAG == GI_TYPE_TAG_BOOLEAN)
      75                 :             :             return gboolean{};
      76                 :             :         else
      77                 :             :             return;
      78                 :             :     } else {
      79                 :             :         if constexpr (std::is_same_v<T, char32_t>)
      80                 :             :             return char32_t{};
      81                 :             :         else if constexpr (type_fits<T, int32_t>())
      82                 :             :             return int32_t{};
      83                 :             :         else if constexpr (type_fits<T, uint32_t>())
      84                 :             :             return uint32_t{};
      85                 :             :         else if constexpr (type_fits<T, int64_t>())
      86                 :             :             return int64_t{};
      87                 :             :         else if constexpr (type_fits<T, uint64_t>())
      88                 :             :             return uint64_t{};
      89                 :             :         else if constexpr (type_fits<T, double>())
      90                 :             :             return double{};
      91                 :             :         else
      92                 :             :             return T{};
      93                 :             :     }
      94                 :             : }
      95                 :             : 
      96                 :             : template <typename T>
      97                 :             : constexpr auto get_relaxed() {
      98                 :             :     if constexpr (std::is_same_v<T, int64_t> || std::is_same_v<T, uint64_t>)
      99                 :             :         return TypeWrapper<T>{};
     100                 :             :     else if constexpr (type_fits<T, int32_t>())
     101                 :             :         return int32_t{};
     102                 :             :     else if constexpr (type_fits<T, uint16_t>())
     103                 :             :         return uint32_t{};
     104                 :             :     else if constexpr (std::is_arithmetic_v<T>)
     105                 :             :         return double{};
     106                 :             :     else
     107                 :             :         return T{};
     108                 :             : }
     109                 :             : 
     110                 :             : template <typename T, GITypeTag TAG = GI_TYPE_TAG_VOID>
     111                 :             : using Strict = decltype(JsValueHolder::get_strict<T, TAG>());
     112                 :             : 
     113                 :             : template <typename T>
     114                 :             : using Relaxed = decltype(JsValueHolder::get_relaxed<T>());
     115                 :             : 
     116                 :             : }  // namespace JsValueHolder
     117                 :             : 
     118                 :             : 
     119                 :             : template <typename T, typename MODE = JsValueHolder::Relaxed<T>>
     120                 :             : constexpr bool type_has_js_getter() {
     121                 :             :     return std::is_same_v<T, MODE>;
     122                 :             : }
     123                 :             : 
     124                 :             : /* Avoid implicit conversions */
     125                 :             : template <GITypeTag TAG = GI_TYPE_TAG_VOID, typename T>
     126                 :             : GJS_JSAPI_RETURN_CONVENTION inline bool js_value_to_c(JSContext*,
     127                 :             :                                                       const JS::HandleValue&,
     128                 :             :                                                       T*) = delete;
     129                 :             : 
     130                 :             : template <>
     131                 :       12724 : GJS_JSAPI_RETURN_CONVENTION inline bool js_value_to_c(
     132                 :             :     JSContext* cx, const JS::HandleValue& value, int32_t* out) {
     133                 :       12724 :     return JS::ToInt32(cx, value, out);
     134                 :             : }
     135                 :             : 
     136                 :             : template <>
     137                 :         144 : GJS_JSAPI_RETURN_CONVENTION inline bool js_value_to_c(
     138                 :             :     JSContext* cx, const JS::HandleValue& value, uint32_t* out) {
     139                 :         144 :     return JS::ToUint32(cx, value, out);
     140                 :             : }
     141                 :             : 
     142                 :             : template <>
     143                 :          24 : GJS_JSAPI_RETURN_CONVENTION inline bool js_value_to_c(
     144                 :             :     JSContext* cx, const JS::HandleValue& value, char32_t* out) {
     145                 :             :     uint32_t tmp;
     146                 :          24 :     bool retval = JS::ToUint32(cx, value, &tmp);
     147                 :          24 :     *out = tmp;
     148                 :          24 :     return retval;
     149                 :             : }
     150                 :             : 
     151                 :             : template <>
     152                 :         594 : GJS_JSAPI_RETURN_CONVENTION inline bool js_value_to_c(
     153                 :             :     JSContext* cx, const JS::HandleValue& value, int64_t* out) {
     154         [ -  + ]:         594 :     if (value.isBigInt()) {
     155                 :           0 :         *out = JS::ToBigInt64(value.toBigInt());
     156                 :           0 :         return true;
     157                 :             :     }
     158                 :         594 :     return JS::ToInt64(cx, value, out);
     159                 :             : }
     160                 :             : 
     161                 :             : template <>
     162                 :           7 : GJS_JSAPI_RETURN_CONVENTION inline bool js_value_to_c(
     163                 :             :     JSContext* cx, const JS::HandleValue& value, uint64_t* out) {
     164         [ -  + ]:           7 :     if (value.isBigInt()) {
     165                 :           0 :         *out = JS::ToBigUint64(value.toBigInt());
     166                 :           0 :         return true;
     167                 :             :     }
     168                 :           7 :     return JS::ToUint64(cx, value, out);
     169                 :             : }
     170                 :             : 
     171                 :             : template <>
     172                 :       11984 : GJS_JSAPI_RETURN_CONVENTION inline bool js_value_to_c(
     173                 :             :     JSContext* cx, const JS::HandleValue& value, double* out) {
     174                 :       11984 :     return JS::ToNumber(cx, value, out);
     175                 :             : }
     176                 :             : 
     177                 :             : template <>
     178                 :          12 : GJS_JSAPI_RETURN_CONVENTION inline bool js_value_to_c<GI_TYPE_TAG_BOOLEAN>(
     179                 :             :     JSContext*, const JS::HandleValue& value, gboolean* out) {
     180                 :          12 :     *out = !!JS::ToBoolean(value);
     181                 :          12 :     return true;
     182                 :             : }
     183                 :             : 
     184                 :             : template <>
     185                 :           5 : GJS_JSAPI_RETURN_CONVENTION inline bool js_value_to_c<GI_TYPE_TAG_GTYPE>(
     186                 :             :     JSContext* cx, const JS::HandleValue& value, GType* out) {
     187         [ +  + ]:           5 :     if (!value.isObject())
     188                 :           2 :         return false;
     189                 :             : 
     190                 :           3 :     JS::RootedObject elem_obj(cx);
     191                 :           3 :     elem_obj = &value.toObject();
     192                 :             : 
     193         [ -  + ]:           3 :     if (!gjs_gtype_get_actual_gtype(cx, elem_obj, out))
     194                 :           0 :         return false;
     195                 :             : 
     196         [ -  + ]:           3 :     if (*out == G_TYPE_INVALID)
     197                 :           0 :         return false;
     198                 :             : 
     199                 :           3 :     return true;
     200                 :           3 : }
     201                 :             : 
     202                 :             : template <>
     203                 :          10 : GJS_JSAPI_RETURN_CONVENTION inline bool js_value_to_c(
     204                 :             :     JSContext* cx, const JS::HandleValue& value, GValue* out) {
     205                 :          10 :     *out = G_VALUE_INIT;
     206                 :          10 :     return gjs_value_to_g_value(cx, value, out);
     207                 :             : }
     208                 :             : 
     209                 :             : template <>
     210                 :          94 : GJS_JSAPI_RETURN_CONVENTION inline bool js_value_to_c(
     211                 :             :     JSContext* cx, const JS::HandleValue& value, char** out) {
     212                 :          94 :     JS::UniqueChars tmp_result = gjs_string_to_utf8(cx, value);
     213                 :             : 
     214         [ +  + ]:          94 :     if (!tmp_result)
     215                 :           1 :         return false;
     216                 :             : 
     217                 :          93 :     *out = g_strdup(tmp_result.get());
     218                 :          93 :     return true;
     219                 :          94 : }
     220                 :             : 
     221                 :             : template <typename BigT>
     222                 :        2611 : [[nodiscard]] inline constexpr BigT max_safe_big_number() {
     223                 :        2611 :     return (BigT(1) << std::numeric_limits<double>::digits) - 1;
     224                 :             : }
     225                 :             : 
     226                 :             : template <typename BigT>
     227                 :        2416 : [[nodiscard]] inline constexpr BigT min_safe_big_number() {
     228                 :             :     if constexpr (std::is_signed_v<BigT>)
     229                 :         217 :         return -(max_safe_big_number<BigT>());
     230                 :             : 
     231                 :        2199 :     return std::numeric_limits<BigT>::lowest();
     232                 :             : }
     233                 :             : 
     234                 :             : template <typename WantedType, GITypeTag TAG = GI_TYPE_TAG_VOID, typename T>
     235                 :       13714 : GJS_JSAPI_RETURN_CONVENTION inline bool js_value_to_c_checked(
     236                 :             :     JSContext* cx, const JS::HandleValue& value, T* out, bool* out_of_range) {
     237                 :             :     static_assert(std::numeric_limits<T>::max() >=
     238                 :             :                           std::numeric_limits<WantedType>::max() &&
     239                 :             :                       std::numeric_limits<T>::lowest() <=
     240                 :             :                           std::numeric_limits<WantedType>::lowest(),
     241                 :             :                   "Container can't contain wanted type");
     242                 :             : 
     243                 :             :     if constexpr (std::is_same_v<WantedType, uint64_t> ||
     244                 :             :                   std::is_same_v<WantedType, int64_t>) {
     245         [ +  - ]:        1670 :         if (out_of_range) {
     246                 :        1670 :             JS::BigInt* bi = nullptr;
     247                 :        1670 :             *out_of_range = false;
     248                 :             : 
     249         [ +  + ]:        1670 :             if (value.isBigInt()) {
     250                 :          60 :                 bi = value.toBigInt();
     251         [ +  + ]:        1610 :             } else if (value.isNumber()) {
     252                 :        1604 :                 double number = value.toNumber();
     253         [ +  + ]:        1604 :                 if (!std::isfinite(number)) {
     254                 :          15 :                     *out = 0;
     255                 :          15 :                     return true;
     256                 :             :                 }
     257                 :        1589 :                 number = std::trunc(number);
     258                 :        1589 :                 bi = JS::NumberToBigInt(cx, number);
     259         [ -  + ]:        1589 :                 if (!bi)
     260                 :           0 :                     return false;
     261                 :             :             }
     262                 :             : 
     263         [ +  + ]:        1655 :             if (bi) {
     264                 :        1649 :                 *out_of_range = Gjs::bigint_is_out_of_range(bi, out);
     265                 :        1649 :                 return true;
     266                 :             :             }
     267                 :             :         }
     268                 :             :     }
     269                 :             : 
     270                 :             :     if constexpr (std::is_same_v<WantedType, T>)
     271                 :          14 :         return js_value_to_c<TAG>(cx, value, out);
     272                 :             : 
     273                 :             :     // JS::ToIntNN() converts undefined, NaN, infinity to 0
     274                 :             :     if constexpr (std::is_integral_v<WantedType>) {
     275   [ +  +  +  +  :       23877 :         if (value.isUndefined() ||
                   +  + ]
     276         [ +  + ]:       11952 :             (value.isDouble() && !std::isfinite(value.toDouble()))) {
     277                 :          27 :             *out = 0;
     278                 :          27 :             return true;
     279                 :             :         }
     280                 :             :     }
     281                 :             : 
     282                 :             :     if constexpr (std::is_arithmetic_v<T>) {
     283                 :       12009 :         bool ret = js_value_to_c<TAG>(cx, value, out);
     284         [ +  - ]:       12009 :         if (out_of_range) {
     285                 :             :             // Infinity and NaN preserved between floating point types
     286                 :             :             if constexpr (std::is_floating_point_v<WantedType> &&
     287                 :             :                           std::is_floating_point_v<T>) {
     288         [ +  + ]:         111 :                 if (!std::isfinite(*out)) {
     289                 :           5 :                     *out_of_range = false;
     290                 :           5 :                     return ret;
     291                 :             :                 }
     292                 :             :             }
     293                 :             : 
     294                 :       12004 :             *out_of_range =
     295                 :       12004 :                 (*out >
     296         [ +  + ]:       24006 :                      static_cast<T>(std::numeric_limits<WantedType>::max()) ||
     297                 :       12002 :                  *out <
     298         [ +  + ]:       12002 :                      static_cast<T>(std::numeric_limits<WantedType>::lowest()));
     299                 :             : 
     300                 :             :             if constexpr (std::is_integral_v<WantedType> &&
     301                 :             :                           std::is_floating_point_v<T>)
     302                 :       11738 :                 *out_of_range |= std::isnan(*out);
     303                 :             :         }
     304                 :       12004 :         return ret;
     305                 :             :         // https://trac.cppcheck.net/ticket/10731
     306                 :             :         // cppcheck-suppress missingReturn
     307                 :             :     }
     308                 :             : }
     309                 :             : 
     310                 :             : template <typename WantedType, GITypeTag TAG = GI_TYPE_TAG_VOID>
     311                 :        1613 : GJS_JSAPI_RETURN_CONVENTION inline bool js_value_to_c_checked(
     312                 :             :     JSContext* cx, const JS::HandleValue& value, TypeWrapper<WantedType>* out,
     313                 :             :     bool* out_of_range) {
     314                 :             :     static_assert(std::is_integral_v<WantedType>);
     315                 :             : 
     316                 :             :     WantedType wanted_out;
     317         [ -  + ]:        1613 :     if (!js_value_to_c_checked<WantedType, TAG>(cx, value, &wanted_out,
     318                 :             :                                                 out_of_range))
     319                 :           0 :         return false;
     320                 :             : 
     321                 :        1613 :     *out = TypeWrapper<WantedType>{wanted_out};
     322                 :             : 
     323                 :        1613 :     return true;
     324                 :             : }
     325                 :             : 
     326                 :             : template <typename T, GITypeTag TAG = GI_TYPE_TAG_VOID>
     327                 :       14951 : GJS_JSAPI_RETURN_CONVENTION inline bool c_value_to_js(
     328                 :             :     JSContext* cx [[maybe_unused]], T value,
     329                 :             :     JS::MutableHandleValue js_value_p) {
     330                 :             :     if constexpr (std::is_same_v<T, bool>) {
     331                 :             :         js_value_p.setBoolean(value);
     332                 :             :         return true;
     333                 :             :     } else if constexpr (std::is_same_v<  // NOLINT(readability/braces)
     334                 :             :                              T, gboolean> &&
     335                 :             :                          TAG == GI_TYPE_TAG_BOOLEAN) {
     336                 :        1067 :         js_value_p.setBoolean(value);
     337                 :        1067 :         return true;
     338                 :             :     } else if constexpr (std::is_arithmetic_v<T>) {
     339                 :             :         if constexpr (std::is_same_v<T, int64_t> ||
     340                 :             :                       std::is_same_v<T, uint64_t>) {
     341   [ +  +  +  +  :        2368 :             if (value < Gjs::min_safe_big_number<T>() ||
                   +  + ]
     342                 :        1179 :                 value > Gjs::max_safe_big_number<T>()) {
     343                 :          30 :                 js_value_p.setDouble(value);
     344                 :          30 :                 return true;
     345                 :             :             }
     346                 :             :         }
     347                 :             :         if constexpr (std::is_floating_point_v<T>) {
     348                 :          53 :             js_value_p.setDouble(JS::CanonicalizeNaN(double{value}));
     349                 :          53 :             return true;
     350                 :             :         }
     351                 :       13097 :         js_value_p.setNumber(value);
     352                 :       13097 :         return true;
     353                 :             :     } else if constexpr (std::is_same_v<T,  // NOLINT(readability/braces)
     354                 :             :                                         char*> ||
     355                 :             :                          std::is_same_v<T, const char*>) {
     356         [ +  + ]:         704 :         if (!value) {
     357                 :           9 :             js_value_p.setNull();
     358                 :           9 :             return true;
     359                 :             :         }
     360                 :         695 :         return gjs_string_from_utf8(cx, value, js_value_p);
     361                 :             :     } else {
     362                 :             :         static_assert(std::is_arithmetic_v<T>, "Unsupported type");
     363                 :             :     }
     364                 :             : }
     365                 :             : 
     366                 :             : template <typename T, GITypeTag TAG = GI_TYPE_TAG_VOID>
     367                 :       14247 : GJS_JSAPI_RETURN_CONVENTION inline bool c_value_to_js_checked(
     368                 :             :     JSContext* cx [[maybe_unused]], T value,
     369                 :             :     JS::MutableHandleValue js_value_p) {
     370                 :             :     if constexpr (std::is_same_v<T, int64_t> || std::is_same_v<T, uint64_t>) {
     371   [ +  +  +  +  :        2368 :         if (value < Gjs::min_safe_big_number<T>() ||
                   +  + ]
     372                 :        1179 :             value > Gjs::max_safe_big_number<T>()) {
     373                 :          30 :             g_warning(
     374                 :             :                 "Value %s cannot be safely stored in a JS Number "
     375                 :             :                 "and may be rounded",
     376                 :             :                 std::to_string(value).c_str());
     377                 :             :         }
     378                 :             :     }
     379                 :             : 
     380                 :       14247 :     return c_value_to_js<T, TAG>(cx, value, js_value_p);
     381                 :             : }
     382                 :             : 
     383                 :             : }  // namespace Gjs
        

Generated by: LCOV version 2.0-1