LCOV - code coverage report
Current view: top level - gcc - json.h (source / functions) Coverage Total Hit
Test: gcc.info Lines: 94.1 % 68 64
Test Date: 2026-11-14 16:39:50 Functions: 80.0 % 20 16
Legend: Lines:     hit not hit

            Line data    Source code
       1              : /* JSON trees
       2              :    Copyright (C) 2017-2026 Free Software Foundation, Inc.
       3              :    Contributed by David Malcolm <dmalcolm@redhat.com>.
       4              : 
       5              : This file is part of GCC.
       6              : 
       7              : GCC is free software; you can redistribute it and/or modify it under
       8              : the terms of the GNU General Public License as published by the Free
       9              : Software Foundation; either version 3, or (at your option) any later
      10              : version.
      11              : 
      12              : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
      13              : WARRANTY; without even the implied warranty of MERCHANTABILITY or
      14              : FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
      15              : for more details.
      16              : 
      17              : You should have received a copy of the GNU General Public License
      18              : along with GCC; see the file COPYING3.  If not see
      19              : <http://www.gnu.org/licenses/>.  */
      20              : 
      21              : #ifndef GCC_JSON_H
      22              : #define GCC_JSON_H
      23              : 
      24              : #include "label-text.h"
      25              : 
      26              : /* Implementation of JSON, a lightweight data-interchange format.
      27              : 
      28              :    See http://www.json.org/
      29              :    and http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf
      30              :    and https://tools.ietf.org/html/rfc7159
      31              : 
      32              :    Supports parsing text into a DOM-like tree of json::value *, directly
      33              :    creating such trees, and dumping json::value * to text.  */
      34              : 
      35              : /* TODO: `libcpp/mkdeps.cc` wants JSON writing support for p1689r5 output;
      36              :    extract this code and move to libiberty.  */
      37              : 
      38              : namespace json
      39              : {
      40              : 
      41              : /* Forward decls of json::value and its subclasses (using indentation
      42              :    to denote inheritance.  */
      43              : 
      44              : class value;
      45              :   class object;
      46              :   class array;
      47              :   class float_number;
      48              :   class integer_number;
      49              :   class string;
      50              :   class literal;
      51              : 
      52              : /* An enum for discriminating the subclasses of json::value.  */
      53              : 
      54              : enum kind
      55              : {
      56              :   /* class json::object.  */
      57              :   JSON_OBJECT,
      58              : 
      59              :   /* class json::array.  */
      60              :   JSON_ARRAY,
      61              : 
      62              :   /* class json::integer_number.  */
      63              :   JSON_INTEGER,
      64              : 
      65              :   /* class json::float_number.  */
      66              :   JSON_FLOAT,
      67              : 
      68              :   /* class json::string.  */
      69              :   JSON_STRING,
      70              : 
      71              :   /* class json::literal uses these three values to identify the
      72              :      particular literal.  */
      73              :   JSON_TRUE,
      74              :   JSON_FALSE,
      75              :   JSON_NULL
      76              : };
      77              : 
      78              : namespace pointer { // json::pointer
      79              : 
      80              : /* Implementation of JSON pointer (RFC 6901).  */
      81              : 
      82              : /* A token within a JSON pointer, expressing the parent of a particular
      83              :    JSON value, and how it is descended from that parent.
      84              : 
      85              :    A JSON pointer can be built as a list of these tokens.  */
      86              : 
      87              : struct token
      88              : {
      89              :   enum class kind
      90              :   {
      91              :     root_value,
      92              :     object_member,
      93              :     array_index
      94              :   };
      95              : 
      96              :   token ();
      97              :   token (json::object &parent, const char *member);
      98              :   token (json::array &parent, size_t index);
      99              :   token (const token &other) = delete;
     100              :   token (token &&other) = delete;
     101              : 
     102              :   ~token ();
     103              : 
     104              :   token &
     105              :   operator= (const token &other) = delete;
     106              : 
     107              :   token &
     108              :   operator= (token &&other);
     109              : 
     110              :   void print (pretty_printer *pp) const;
     111              : 
     112              :   json::value *m_parent;
     113              :   union u
     114              :   {
     115              :     char *u_member;
     116              :     size_t u_index;
     117              :   } m_data;
     118              :   enum kind m_kind;
     119              : };
     120              : 
     121              : } // namespace json::pointer
     122              : 
     123              : /* Typesafe way to work with properties in JSON objects.  */
     124              : 
     125              : template <typename Traits>
     126          121 : struct property
     127              : {
     128           76 :   explicit property (const char *key)
     129           76 :   : m_key (label_text::borrow (key))
     130              :   {}
     131              : 
     132           39 :   explicit property (const char *key_prefix, const char *key)
     133           39 :   : m_key (label_text::take (concat (key_prefix, key, nullptr)))
     134              :   {}
     135              : 
     136              :   label_text m_key;
     137              : };
     138              : 
     139              : using string_property = property<string>;
     140              : using integer_property = property<integer_number>;
     141              : using bool_property = property<literal>;
     142              : using json_property = property<value>;
     143              : using array_of_string_property = property<array>;
     144              : 
     145              : template <typename EnumType>
     146              : struct enum_traits
     147              : {
     148              :   typedef EnumType enum_t;
     149              : 
     150              :   static enum_t get_unknown_value ();
     151              :   static bool maybe_get_value_from_string (const char *, enum_t &out);
     152              :   static const char *get_string_for_value (enum_t value);
     153              : };
     154              : 
     155              : template <typename EnumType>
     156              : using enum_property = property<enum_traits<EnumType>>;
     157              : 
     158              : /* Base class of JSON value.  */
     159              : 
     160      2748062 : class value
     161              : {
     162              :  public:
     163      3527341 :   virtual ~value () {}
     164              :   virtual enum kind get_kind () const = 0;
     165              :   virtual void print (pretty_printer *pp, bool formatted) const = 0;
     166              :   virtual std::unique_ptr<value> clone () const = 0;
     167              : 
     168              :   void dump (FILE *, bool formatted) const;
     169              :   void DEBUG_FUNCTION dump () const;
     170              : 
     171            0 :   virtual object *dyn_cast_object () { return nullptr; }
     172            0 :   virtual array *dyn_cast_array () { return nullptr; }
     173            0 :   virtual integer_number *dyn_cast_integer_number () { return nullptr; }
     174            0 :   virtual string *dyn_cast_string () { return nullptr; }
     175              : 
     176              :   static int compare (const json::value &val_a, const json::value &val_b);
     177              : 
     178              :   const pointer::token &get_pointer_token () const { return m_pointer_token; }
     179              :   void print_pointer (pretty_printer *pp) const;
     180              : 
     181              :   pointer::token m_pointer_token;
     182              : };
     183              : 
     184              : /* Subclass of value for objects: a collection of key/value pairs
     185              :    preserving the ordering in which keys were inserted.
     186              : 
     187              :    Preserving the order eliminates non-determinism in the output,
     188              :    making it easier for the user to compare repeated invocations.  */
     189              : 
     190              : class object : public value
     191              : {
     192              :  public:
     193              :   ~object ();
     194              : 
     195              :   typedef hash_map <char *, value *,
     196              :     simple_hashmap_traits<nofree_string_hash, value *> > map_t;
     197              : 
     198        18811 :   enum kind get_kind () const final override { return JSON_OBJECT; }
     199              :   void print (pretty_printer *pp, bool formatted) const final override;
     200              :   std::unique_ptr<value> clone () const final override;
     201              : 
     202          306 :   object *dyn_cast_object () final override { return this; }
     203              : 
     204          486 :   bool is_empty () const { return m_map.is_empty (); }
     205              : 
     206              :   void set (const char *key, value *v);
     207              : 
     208              :   /* Set the property KEY of this object, requiring V
     209              :      to be of a specific json::value subclass.
     210              : 
     211              :      This can be used to enforce type-checking, making it easier
     212              :      to comply with a schema, e.g.
     213              :        obj->set<some_subclass> ("property_name", value)
     214              :      leading to a compile-time error if VALUE is not of the
     215              :      appropriate subclass.  */
     216              :   template <typename JsonType>
     217      1331139 :   void set (const char *key, std::unique_ptr<JsonType> v)
     218              :   {
     219      1331206 :     set (key, v.release ());
     220              :   }
     221              : 
     222              :   value *get (const char *key) const;
     223              :   const map_t &get_map () const { return m_map; }
     224              : 
     225              :   const json::string *set_string (const char *key, const char *utf8_value);
     226              :   const json::string *set_string (const char *key, std::string utf8_value);
     227              :   const json::integer_number *set_integer (const char *key, long v);
     228              :   void set_float (const char *key, double v);
     229              : 
     230              :   /* Set to literal true/false.  */
     231              :   void set_bool (const char *key, bool v);
     232              : 
     233              :   /* Typesafe access to properties by name (such as from a schema).  */
     234              :   void set_string (const string_property &property, const char *utf8_value);
     235              :   void set_integer (const integer_property &property, long value);
     236              :   void set_bool (const bool_property &property, bool value);
     237              :   void set_array_of_string (const array_of_string_property &property,
     238              :                             std::unique_ptr<json::array> value);
     239              :   template <typename EnumType>
     240              :   bool maybe_get_enum (const enum_property<EnumType> &property,
     241              :                        EnumType &out) const;
     242              :   template <typename EnumType>
     243              :   void set_enum (const enum_property<EnumType> &property,
     244              :                  EnumType value);
     245              : 
     246              :   static int compare (const json::object &obj_a, const json::object &obj_b);
     247              : 
     248         4359 :   size_t get_num_keys () const { return m_keys.length (); }
     249         3167 :   const char *get_key (size_t i) const { return m_keys[i]; }
     250              : 
     251              :   std::unique_ptr<object> clone_as_object () const;
     252              : 
     253              :  private:
     254              :   map_t m_map;
     255              : 
     256              :   /* Keep track of order in which keys were inserted.  */
     257              :   auto_vec <const char *> m_keys;
     258              : };
     259              : 
     260              : /* Subclass of value for arrays.  */
     261              : 
     262       627117 : class array : public value
     263              : {
     264              :  public:
     265              :   ~array ();
     266              : 
     267          801 :   enum kind get_kind () const final override { return JSON_ARRAY; }
     268              :   void print (pretty_printer *pp, bool formatted) const final override;
     269              :   std::unique_ptr<value> clone () const final override;
     270              : 
     271         2100 :   array *dyn_cast_array () final override { return this; }
     272              : 
     273              :   void append (value *v);
     274              :   const json::string *append_string (const char *utf8_value);
     275              : 
     276              :   /* Append V to this array, requiring V
     277              :      to be a specific json::value subclass.
     278              : 
     279              :      This can be used to enforce type-checking, making it easier
     280              :      to comply with a schema, e.g.
     281              :        arr->append<some_subclass> (value)
     282              :      leading to a compile-time error if VALUE is not of the
     283              :      appropriate subclass.  */
     284              :   template <typename JsonType>
     285       628035 :   void append (std::unique_ptr<JsonType> v)
     286              :   {
     287       628035 :     append (v.release ());
     288              :   }
     289              : 
     290         2125 :   size_t size () const { return m_elements.length (); }
     291          928 :   value *operator[] (size_t i) const { return m_elements[i]; }
     292              : 
     293         3497 :   value **begin () { return m_elements.begin (); }
     294         3497 :   value **end () { return m_elements.end (); }
     295              :   const value * const *begin () const { return m_elements.begin (); }
     296              :   const value * const *end () const { return m_elements.end (); }
     297          422 :   size_t length () const { return m_elements.length (); }
     298          354 :   value *get (size_t idx) const { return m_elements[idx]; }
     299              : 
     300              :  private:
     301              :   auto_vec<value *> m_elements;
     302              : };
     303              : 
     304              : /* Subclass of value for floating-point numbers.  */
     305              : 
     306           28 : class float_number : public value
     307              : {
     308              :  public:
     309           60 :   float_number (double value) : m_value (value) {}
     310              : 
     311           88 :   enum kind get_kind () const final override { return JSON_FLOAT; }
     312              :   void print (pretty_printer *pp, bool formatted) const final override;
     313              :   std::unique_ptr<value> clone () const final override;
     314              : 
     315           44 :   double get () const { return m_value; }
     316              : 
     317              :  private:
     318              :   double m_value;
     319              : };
     320              : 
     321              : /* Subclass of value for integer-valued numbers.  */
     322              : 
     323           32 : class integer_number : public value
     324              : {
     325              :  public:
     326       691734 :   integer_number (long value) : m_value (value) {}
     327              : 
     328         2471 :   enum kind get_kind () const final override { return JSON_INTEGER; }
     329              :   void print (pretty_printer *pp, bool formatted) const final override;
     330              :   std::unique_ptr<value> clone () const final override;
     331              : 
     332          128 :   integer_number *dyn_cast_integer_number () final override { return this; }
     333              : 
     334         2462 :   long get () const { return m_value; }
     335              : 
     336              :  private:
     337              :   long m_value;
     338              : };
     339              : 
     340              : 
     341              : /* Subclass of value for strings.  */
     342              : 
     343              : class string : public value
     344              : {
     345              :  public:
     346              :   explicit string (const char *utf8);
     347              :   string (const char *utf8, size_t len);
     348      4241618 :   ~string () { free (m_utf8); }
     349              : 
     350        24182 :   enum kind get_kind () const final override { return JSON_STRING; }
     351              :   void print (pretty_printer *pp, bool formatted) const final override;
     352              :   std::unique_ptr<value> clone () const final override;
     353         2740 :   string *dyn_cast_string () final override { return this; }
     354              : 
     355        15443 :   const char *get_string () const { return m_utf8; }
     356              :   size_t get_length () const { return m_len; }
     357              : 
     358              :  private:
     359              :   char *m_utf8;
     360              :   size_t m_len;
     361              : };
     362              : 
     363              : /* Subclass of value for the three JSON literals "true", "false",
     364              :    and "null".  */
     365              : 
     366           32 : class literal : public value
     367              : {
     368              :  public:
     369          106 :   literal (enum kind kind) : m_kind (kind) {}
     370              : 
     371              :   /* Construct literal for a boolean value.  */
     372          833 :   literal (bool value): m_kind (value ? JSON_TRUE : JSON_FALSE) {}
     373              : 
     374          148 :   enum kind get_kind () const final override { return m_kind; }
     375              :   void print (pretty_printer *pp, bool formatted) const final override;
     376              :   std::unique_ptr<value> clone () const final override;
     377              : 
     378              :  private:
     379              :   enum kind m_kind;
     380              : };
     381              : 
     382              : 
     383              : template <typename EnumType>
     384              : inline bool
     385           24 : object::maybe_get_enum (const enum_property<EnumType> &property,
     386              :                         EnumType &out) const
     387              : {
     388           24 :   if (value *jv = get (property.m_key.get ()))
     389           20 :     if (string *jstr = jv->dyn_cast_string ())
     390              :       {
     391              :         if (enum_traits<EnumType>::maybe_get_value_from_string
     392           20 :             (jstr->get_string (), out))
     393              :           return true;
     394              :       }
     395              :   return false;
     396              : }
     397              : 
     398              : template <typename EnumType>
     399              : inline void
     400          555 : object::set_enum (const enum_property<EnumType> &property,
     401              :                   EnumType value)
     402              : {
     403              :   const char *str
     404          555 :     = json::enum_traits<EnumType>::get_string_for_value (value);
     405          555 :   set_string (property.m_key.get (), str);
     406          555 : }
     407              : 
     408              : } // namespace json
     409              : 
     410              : template <>
     411              : template <>
     412              : inline bool
     413              : is_a_helper <json::value *>::test (json::value *)
     414              : {
     415              :   return true;
     416              : }
     417              : 
     418              : template <>
     419              : template <>
     420              : inline bool
     421              : is_a_helper <const json::value *>::test (const json::value *)
     422              : {
     423              :   return true;
     424              : }
     425              : 
     426              : template <>
     427              : template <>
     428              : inline bool
     429              : is_a_helper <json::object *>::test (json::value *jv)
     430              : {
     431              :   return jv->get_kind () == json::JSON_OBJECT;
     432              : }
     433              : 
     434              : template <>
     435              : template <>
     436              : inline bool
     437              : is_a_helper <const json::object *>::test (const json::value *jv)
     438              : {
     439              :   return jv->get_kind () == json::JSON_OBJECT;
     440              : }
     441              : 
     442              : template <>
     443              : template <>
     444              : inline bool
     445            4 : is_a_helper <json::array *>::test (json::value *jv)
     446              : {
     447            4 :   return jv->get_kind () == json::JSON_ARRAY;
     448              : }
     449              : 
     450              : template <>
     451              : template <>
     452              : inline bool
     453            4 : is_a_helper <const json::array *>::test (const json::value *jv)
     454              : {
     455            4 :   return jv->get_kind () == json::JSON_ARRAY;
     456              : }
     457              : 
     458              : template <>
     459              : template <>
     460              : inline bool
     461              : is_a_helper <json::float_number *>::test (json::value *jv)
     462              : {
     463              :   return jv->get_kind () == json::JSON_FLOAT;
     464              : }
     465              : 
     466              : template <>
     467              : template <>
     468              : inline bool
     469            8 : is_a_helper <const json::float_number *>::test (const json::value *jv)
     470              : {
     471            8 :   return jv->get_kind () == json::JSON_FLOAT;
     472              : }
     473              : 
     474              : template <>
     475              : template <>
     476              : inline bool
     477           44 : is_a_helper <json::integer_number *>::test (json::value *jv)
     478              : {
     479           44 :   return jv->get_kind () == json::JSON_INTEGER;
     480              : }
     481              : 
     482              : template <>
     483              : template <>
     484              : inline bool
     485           12 : is_a_helper <const json::integer_number *>::test (const json::value *jv)
     486              : {
     487           12 :   return jv->get_kind () == json::JSON_INTEGER;
     488              : }
     489              : 
     490              : template <>
     491              : template <>
     492              : inline bool
     493            4 : is_a_helper <json::string *>::test (json::value *jv)
     494              : {
     495            4 :   return jv->get_kind () == json::JSON_STRING;
     496              : }
     497              : 
     498              : template <>
     499              : template <>
     500              : inline bool
     501           16 : is_a_helper <const json::string *>::test (const  json::value *jv)
     502              : {
     503           16 :   return jv->get_kind () == json::JSON_STRING;
     504              : }
     505              : 
     506              : template <>
     507              : template <>
     508              : inline bool
     509              : is_a_helper<json::literal *>::test (json::value *jv)
     510              : {
     511              :   return (jv->get_kind () == json::JSON_TRUE
     512              :           || jv->get_kind () == json::JSON_FALSE
     513              :           || jv->get_kind () == json::JSON_NULL);
     514              : }
     515              : 
     516              : template <>
     517              : template <>
     518              : inline bool
     519              : is_a_helper<const json::literal *>::test (const json::value *jv)
     520              : {
     521              :   return (jv->get_kind () == json::JSON_TRUE
     522              :           || jv->get_kind () == json::JSON_FALSE
     523              :           || jv->get_kind () == json::JSON_NULL);
     524              : }
     525              : 
     526              : #if CHECKING_P
     527              : 
     528              : namespace selftest {
     529              : 
     530              : class location;
     531              : 
     532              : extern void assert_json_print_eq (const location &loc,
     533              :                                   const json::value &jv,
     534              :                                   bool formatted,
     535              :                                   const char *expected_json);
     536              : 
     537              : } // namespace selftest
     538              : 
     539              : #define ASSERT_JSON_PRINT_EQ(JV, FORMATTED, EXPECTED_JSON)              \
     540              :   SELFTEST_BEGIN_STMT                                                   \
     541              :   assert_json_print_eq ((SELFTEST_LOCATION), (JV), (FORMATTED), (EXPECTED_JSON)); \
     542              :   SELFTEST_END_STMT
     543              : 
     544              : #endif /* #if CHECKING_P */
     545              : 
     546              : #endif  /* GCC_JSON_H  */
        

Generated by: LCOV version 2.5.0-beta

LCOV profile is generated on x86_64 machine using following configure options: configure --disable-bootstrap --enable-coverage=opt --enable-languages=c,c++,fortran,go,jit,lto,rust,m2 --enable-host-shared. GCC test suite is run with the built compiler.