Daily bump.
[official-gcc.git] / gcc / json.cc
blob026cc5d14f797960f4a1d01159c334cd8e39718b
1 /* JSON trees
2 Copyright (C) 2017-2021 Free Software Foundation, Inc.
3 Contributed by David Malcolm <dmalcolm@redhat.com>.
5 This file is part of GCC.
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.
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.
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/>. */
21 #include "config.h"
22 #include "system.h"
23 #include "coretypes.h"
24 #include "json.h"
25 #include "pretty-print.h"
26 #include "math.h"
27 #include "selftest.h"
29 using namespace json;
31 /* class json::value. */
33 /* Dump this json::value tree to OUTF.
34 No formatting is done. There are no guarantees about the order
35 in which the key/value pairs of json::objects are printed. */
37 void
38 value::dump (FILE *outf) const
40 pretty_printer pp;
41 pp_buffer (&pp)->stream = outf;
42 print (&pp);
43 pp_flush (&pp);
46 /* class json::object, a subclass of json::value, representing
47 an unordered collection of key/value pairs. */
49 /* json:object's dtor. */
51 object::~object ()
53 for (map_t::iterator it = m_map.begin (); it != m_map.end (); ++it)
55 free (const_cast <char *>((*it).first));
56 delete ((*it).second);
60 /* Implementation of json::value::print for json::object. */
62 void
63 object::print (pretty_printer *pp) const
65 /* Note that the order is not guaranteed. */
66 pp_character (pp, '{');
67 for (map_t::iterator it = m_map.begin (); it != m_map.end (); ++it)
69 if (it != m_map.begin ())
70 pp_string (pp, ", ");
71 const char *key = const_cast <char *>((*it).first);
72 value *value = (*it).second;
73 pp_doublequote (pp);
74 pp_string (pp, key); // FIXME: escaping?
75 pp_doublequote (pp);
76 pp_string (pp, ": ");
77 value->print (pp);
79 pp_character (pp, '}');
82 /* Set the json::value * for KEY, taking ownership of V
83 (and taking a copy of KEY if necessary). */
85 void
86 object::set (const char *key, value *v)
88 gcc_assert (key);
89 gcc_assert (v);
91 value **ptr = m_map.get (key);
92 if (ptr)
94 /* If the key is already present, delete the existing value
95 and overwrite it. */
96 delete *ptr;
97 *ptr = v;
99 else
100 /* If the key wasn't already present, take a copy of the key,
101 and store the value. */
102 m_map.put (xstrdup (key), v);
105 /* Get the json::value * for KEY.
107 The object retains ownership of the value. */
109 value *
110 object::get (const char *key) const
112 gcc_assert (key);
114 value **ptr = const_cast <map_t &> (m_map).get (key);
115 if (ptr)
116 return *ptr;
117 else
118 return NULL;
121 /* class json::array, a subclass of json::value, representing
122 an ordered collection of values. */
124 /* json::array's dtor. */
126 array::~array ()
128 unsigned i;
129 value *v;
130 FOR_EACH_VEC_ELT (m_elements, i, v)
131 delete v;
134 /* Implementation of json::value::print for json::array. */
136 void
137 array::print (pretty_printer *pp) const
139 pp_character (pp, '[');
140 unsigned i;
141 value *v;
142 FOR_EACH_VEC_ELT (m_elements, i, v)
144 if (i)
145 pp_string (pp, ", ");
146 v->print (pp);
148 pp_character (pp, ']');
151 /* Append non-NULL value V to a json::array, taking ownership of V. */
153 void
154 array::append (value *v)
156 gcc_assert (v);
157 m_elements.safe_push (v);
160 /* class json::float_number, a subclass of json::value, wrapping a double. */
162 /* Implementation of json::value::print for json::float_number. */
164 void
165 float_number::print (pretty_printer *pp) const
167 char tmp[1024];
168 snprintf (tmp, sizeof (tmp), "%g", m_value);
169 pp_string (pp, tmp);
172 /* class json::integer_number, a subclass of json::value, wrapping a long. */
174 /* Implementation of json::value::print for json::integer_number. */
176 void
177 integer_number::print (pretty_printer *pp) const
179 char tmp[1024];
180 snprintf (tmp, sizeof (tmp), "%ld", m_value);
181 pp_string (pp, tmp);
185 /* class json::string, a subclass of json::value. */
187 /* json::string's ctor. */
189 string::string (const char *utf8)
191 gcc_assert (utf8);
192 m_utf8 = xstrdup (utf8);
195 /* Implementation of json::value::print for json::string. */
197 void
198 string::print (pretty_printer *pp) const
200 pp_character (pp, '"');
201 for (const char *ptr = m_utf8; *ptr; ptr++)
203 char ch = *ptr;
204 switch (ch)
206 case '"':
207 pp_string (pp, "\\\"");
208 break;
209 case '\\':
210 pp_string (pp, "\\n");
211 break;
212 case '\b':
213 pp_string (pp, "\\b");
214 break;
215 case '\f':
216 pp_string (pp, "\\f");
217 break;
218 case '\n':
219 pp_string (pp, "\\n");
220 break;
221 case '\r':
222 pp_string (pp, "\\r");
223 break;
224 case '\t':
225 pp_string (pp, "\\t");
226 break;
228 default:
229 pp_character (pp, ch);
232 pp_character (pp, '"');
235 /* class json::literal, a subclass of json::value. */
237 /* Implementation of json::value::print for json::literal. */
239 void
240 literal::print (pretty_printer *pp) const
242 switch (m_kind)
244 case JSON_TRUE:
245 pp_string (pp, "true");
246 break;
247 case JSON_FALSE:
248 pp_string (pp, "false");
249 break;
250 case JSON_NULL:
251 pp_string (pp, "null");
252 break;
253 default:
254 gcc_unreachable ();
259 #if CHECKING_P
261 namespace selftest {
263 /* Selftests. */
265 /* Verify that JV->print () prints EXPECTED_JSON. */
267 static void
268 assert_print_eq (const json::value &jv, const char *expected_json)
270 pretty_printer pp;
271 jv.print (&pp);
272 ASSERT_STREQ (expected_json, pp_formatted_text (&pp));
275 /* Verify that object::get works as expected. */
277 static void
278 test_object_get ()
280 object obj;
281 value *val = new json::string ("value");
282 obj.set ("foo", val);
283 ASSERT_EQ (obj.get ("foo"), val);
284 ASSERT_EQ (obj.get ("not-present"), NULL);
287 /* Verify that JSON objects are written correctly. We can't test more than
288 one key/value pair, as we don't impose a guaranteed ordering. */
290 static void
291 test_writing_objects ()
293 object obj;
294 obj.set ("foo", new json::string ("bar"));
295 assert_print_eq (obj, "{\"foo\": \"bar\"}");
298 /* Verify that JSON arrays are written correctly. */
300 static void
301 test_writing_arrays ()
303 array arr;
304 assert_print_eq (arr, "[]");
306 arr.append (new json::string ("foo"));
307 assert_print_eq (arr, "[\"foo\"]");
309 arr.append (new json::string ("bar"));
310 assert_print_eq (arr, "[\"foo\", \"bar\"]");
313 /* Verify that JSON numbers are written correctly. */
315 static void
316 test_writing_float_numbers ()
318 assert_print_eq (float_number (0), "0");
319 assert_print_eq (float_number (42), "42");
320 assert_print_eq (float_number (-100), "-100");
321 assert_print_eq (float_number (123456789), "1.23457e+08");
324 static void
325 test_writing_integer_numbers ()
327 assert_print_eq (integer_number (0), "0");
328 assert_print_eq (integer_number (42), "42");
329 assert_print_eq (integer_number (-100), "-100");
330 assert_print_eq (integer_number (123456789), "123456789");
331 assert_print_eq (integer_number (-123456789), "-123456789");
334 /* Verify that JSON strings are written correctly. */
336 static void
337 test_writing_strings ()
339 string foo ("foo");
340 assert_print_eq (foo, "\"foo\"");
342 string contains_quotes ("before \"quoted\" after");
343 assert_print_eq (contains_quotes, "\"before \\\"quoted\\\" after\"");
346 /* Verify that JSON literals are written correctly. */
348 static void
349 test_writing_literals ()
351 assert_print_eq (literal (JSON_TRUE), "true");
352 assert_print_eq (literal (JSON_FALSE), "false");
353 assert_print_eq (literal (JSON_NULL), "null");
355 assert_print_eq (literal (true), "true");
356 assert_print_eq (literal (false), "false");
359 /* Run all of the selftests within this file. */
361 void
362 json_cc_tests ()
364 test_object_get ();
365 test_writing_objects ();
366 test_writing_arrays ();
367 test_writing_float_numbers ();
368 test_writing_integer_numbers ();
369 test_writing_strings ();
370 test_writing_literals ();
373 } // namespace selftest
375 #endif /* #if CHECKING_P */