Skip to content

Commit b699a36

Browse files
jsmall-zzzjsmall-zzz
authored
JSONBuilder (shader-slang#1865)
* #include an absolute path didn't work - because paths were taken to always be relative. * WIP JSONWriter/JSONParser. * Checking different Layout styles for JSON. * Add slang-json-parser.h/.cpp * WIP JSONValue. * Added JSONValue::destroy/Recursive. * Improvement to JSONValue. * Improve text double conversion precision. Testing. * Simplify double parsing (just use atof). JSON comparison More testing of conversions and start of JSONValue. * Add <math.h> for isnan, isinf etc. * Small improvement with object comparison. * Fix typo in getArgsByName. * Removed use of isnan and isinf as includes don't work on linux. * Improve JSON unit test. * Added asInteger/asFloat/asBool to JSONValue. * Add SourceLoc to JSONListener. * Added ability to walk the JSONValue * JSONBuilder. * Add converting from lexemes via JSONBuilder. * Fix VS warning. * Fix warning for res not being used.
1 parent 7a3c87b commit b699a36

7 files changed

+615
-55
lines changed

‎source/compiler-core/slang-json-lexer.cpp

+11
Original file line numberDiff line numberDiff line change
@@ -80,6 +80,17 @@ bool JSONLexer::advanceIf(JSONTokenType type)
8080
return false;
8181
}
8282

83+
bool JSONLexer::advanceIf(JSONTokenType type, JSONToken& out)
84+
{
85+
if (type == peekType())
86+
{
87+
out = m_token;
88+
advance();
89+
return true;
90+
}
91+
return false;
92+
}
93+
8394
UnownedStringSlice JSONLexer::getLexeme(const JSONToken& tok) const
8495
{
8596
auto offset = m_sourceView->getRange().getOffset(tok.loc);

‎source/compiler-core/slang-json-lexer.h

+1
Original file line numberDiff line numberDiff line change
@@ -61,6 +61,7 @@ class JSONLexer
6161

6262
/// Returns true and advances if current token is type
6363
bool advanceIf(JSONTokenType type);
64+
bool advanceIf(JSONTokenType type, JSONToken& out);
6465

6566
/// Must be called before use
6667
SlangResult init(SourceView* sourceView, DiagnosticSink* sink);

‎source/compiler-core/slang-json-parser.cpp

+102-28
Original file line numberDiff line numberDiff line change
@@ -3,6 +3,8 @@
33

44
#include "slang-json-diagnostics.h"
55

6+
#include "../core/slang-string-escape-util.h"
7+
68
/*
79
https://www.json.org/json-en.html
810
*/
@@ -11,21 +13,26 @@ namespace Slang {
1113

1214
SlangResult JSONParser::_parseObject()
1315
{
14-
SLANG_RETURN_ON_FAIL(m_lexer->expect(JSONTokenType::LBrace));
15-
16-
m_listener->startObject();
16+
{
17+
const SourceLoc loc = m_lexer->peekLoc();
18+
SLANG_RETURN_ON_FAIL(m_lexer->expect(JSONTokenType::LBrace));
19+
m_listener->startObject(loc);
20+
}
1721

18-
if (m_lexer->advanceIf(JSONTokenType::RBrace))
1922
{
20-
m_listener->endObject();
21-
return SLANG_OK;
23+
const SourceLoc loc = m_lexer->peekLoc();
24+
if (m_lexer->advanceIf(JSONTokenType::RBrace))
25+
{
26+
m_listener->endObject(loc);
27+
return SLANG_OK;
28+
}
2229
}
2330

2431
while (true)
2532
{
2633
JSONToken keyToken;
2734
SLANG_RETURN_ON_FAIL(m_lexer->expect(JSONTokenType::StringLiteral, keyToken));
28-
m_listener->addLexemeKey(m_lexer->getLexeme(keyToken));
35+
m_listener->addKey(m_lexer->getLexeme(keyToken), keyToken.loc);
2936

3037
SLANG_RETURN_ON_FAIL(m_lexer->expect(JSONTokenType::Colon));
3138

@@ -38,21 +45,29 @@ SlangResult JSONParser::_parseObject()
3845
break;
3946
}
4047

41-
SLANG_RETURN_ON_FAIL(m_lexer->expect(JSONTokenType::RBrace));
42-
m_listener->endObject();
48+
{
49+
const SourceLoc loc = m_lexer->peekLoc();
50+
SLANG_RETURN_ON_FAIL(m_lexer->expect(JSONTokenType::RBrace));
51+
m_listener->endObject(loc);
52+
}
4353
return SLANG_OK;
4454
}
4555

4656
SlangResult JSONParser::_parseArray()
4757
{
48-
SLANG_RETURN_ON_FAIL(m_lexer->expect(JSONTokenType::LBracket));
49-
50-
m_listener->startArray();
58+
{
59+
const SourceLoc loc = m_lexer->peekLoc();
60+
SLANG_RETURN_ON_FAIL(m_lexer->expect(JSONTokenType::LBracket));
61+
m_listener->startArray(loc);
62+
}
5163

52-
if (m_lexer->advanceIf(JSONTokenType::RBracket))
5364
{
54-
m_listener->endArray();
55-
return SLANG_OK;
65+
const SourceLoc loc = m_lexer->peekLoc();
66+
if (m_lexer->advanceIf(JSONTokenType::RBracket))
67+
{
68+
m_listener->endArray(loc);
69+
return SLANG_OK;
70+
}
5671
}
5772

5873
while (true)
@@ -65,8 +80,11 @@ SlangResult JSONParser::_parseArray()
6580
break;
6681
}
6782

68-
SLANG_RETURN_ON_FAIL(m_lexer->expect(JSONTokenType::RBracket));
69-
m_listener->endArray();
83+
{
84+
const SourceLoc loc = m_lexer->peekLoc();
85+
SLANG_RETURN_ON_FAIL(m_lexer->expect(JSONTokenType::RBracket));
86+
m_listener->endArray(loc);
87+
}
7088
return SLANG_OK;
7189
}
7290

@@ -81,7 +99,8 @@ SlangResult JSONParser::_parseValue()
8199
case JSONTokenType::FloatLiteral:
82100
case JSONTokenType::StringLiteral:
83101
{
84-
m_listener->addLexemeValue(m_lexer->peekType(), m_lexer->peekLexeme());
102+
const JSONToken& tok = m_lexer->peekToken();
103+
m_listener->addLexemeValue(tok.type, m_lexer->peekLexeme(), tok.loc);
85104
m_lexer->advance();
86105
return SLANG_OK;
87106
}
@@ -256,8 +275,9 @@ void JSONWriter::_maybeEmitFieldComma()
256275
}
257276
}
258277

259-
void JSONWriter::startObject()
278+
void JSONWriter::startObject(SourceLoc loc)
260279
{
280+
SLANG_UNUSED(loc);
261281
SLANG_ASSERT(m_state.canEmitValue());
262282

263283
_maybeEmitComma();
@@ -276,8 +296,9 @@ void JSONWriter::startObject()
276296
m_state.m_flags = 0;
277297
}
278298

279-
void JSONWriter::endObject()
299+
void JSONWriter::endObject(SourceLoc loc)
280300
{
301+
SLANG_UNUSED(loc);
281302
SLANG_ASSERT(m_state.m_kind == State::Kind::Object);
282303

283304
_handleFormat(Location::BeforeCloseObject);
@@ -289,8 +310,9 @@ void JSONWriter::endObject()
289310
m_stack.removeLast();
290311
}
291312

292-
void JSONWriter::startArray()
313+
void JSONWriter::startArray(SourceLoc loc)
293314
{
315+
SLANG_UNUSED(loc);
294316
SLANG_ASSERT(m_state.canEmitValue());
295317

296318
_maybeEmitComma();
@@ -309,8 +331,9 @@ void JSONWriter::startArray()
309331
m_state.m_flags = 0;
310332
}
311333

312-
void JSONWriter::endArray()
334+
void JSONWriter::endArray(SourceLoc loc)
313335
{
336+
SLANG_UNUSED(loc);
314337
SLANG_ASSERT(m_state.m_kind == State::Kind::Array);
315338

316339
_handleFormat(Location::BeforeCloseArray);
@@ -322,8 +345,9 @@ void JSONWriter::endArray()
322345
m_stack.removeLast();
323346
}
324347

325-
void JSONWriter::addLexemeKey(const UnownedStringSlice& key)
348+
void JSONWriter::addKey(const UnownedStringSlice& key, SourceLoc loc)
326349
{
350+
SLANG_UNUSED(loc);
327351
SLANG_ASSERT(m_state.m_kind == State::Kind::Object && (m_state.m_flags & State::Flag::HasKey) == 0);
328352

329353
_maybeEmitFieldComma();
@@ -339,12 +363,27 @@ void JSONWriter::addLexemeKey(const UnownedStringSlice& key)
339363
m_state.m_flags &= ~State::Flag::HasPrevious;
340364
}
341365

342-
void JSONWriter::addLexemeValue(JSONTokenType type, const UnownedStringSlice& value)
366+
void JSONWriter::_preValue(SourceLoc loc)
343367
{
368+
SLANG_UNUSED(loc);
344369
SLANG_ASSERT(m_state.canEmitValue());
345370

346371
_maybeEmitComma();
347372
_maybeEmitIndent();
373+
}
374+
375+
void JSONWriter::_postValue()
376+
{
377+
// We have a previous
378+
m_state.m_flags |= State::Flag::HasPrevious;
379+
// We don't have a key
380+
m_state.m_flags &= ~State::Flag::HasKey;
381+
}
382+
383+
384+
void JSONWriter::addLexemeValue(JSONTokenType type, const UnownedStringSlice& value, SourceLoc loc)
385+
{
386+
_preValue(loc);
348387

349388
switch (type)
350389
{
@@ -375,10 +414,45 @@ void JSONWriter::addLexemeValue(JSONTokenType type, const UnownedStringSlice& va
375414
SLANG_ASSERT(!"Can only emit values");
376415
}
377416
}
378-
// We have a previous
379-
m_state.m_flags |= State::Flag::HasPrevious;
380-
// We don't have a key
381-
m_state.m_flags &= ~State::Flag::HasKey;
417+
418+
_postValue();
419+
}
420+
421+
void JSONWriter::addIntegerValue(int64_t value, SourceLoc loc)
422+
{
423+
_preValue(loc);
424+
m_builder << value;
425+
_postValue();
426+
}
427+
428+
void JSONWriter::addFloatValue(double value, SourceLoc loc)
429+
{
430+
_preValue(loc);
431+
m_builder << value;
432+
_postValue();
433+
}
434+
435+
void JSONWriter::addBoolValue(bool inValue, SourceLoc loc)
436+
{
437+
_preValue(loc);
438+
const UnownedStringSlice slice = inValue ? UnownedStringSlice::fromLiteral("true") : UnownedStringSlice::fromLiteral("false");
439+
m_builder << slice;
440+
_postValue();
441+
}
442+
443+
void JSONWriter::addNullValue(SourceLoc loc)
444+
{
445+
_preValue(loc);
446+
m_builder << UnownedStringSlice::fromLiteral("null");
447+
_postValue();
448+
}
449+
450+
void JSONWriter::addStringValue(const UnownedStringSlice& slice, SourceLoc loc)
451+
{
452+
_preValue(loc);
453+
StringEscapeHandler* handler = StringEscapeUtil::getHandler(StringEscapeUtil::Style::JSON);
454+
StringEscapeUtil::appendQuoted(handler, slice, m_builder);
455+
_postValue();
382456
}
383457

384458
} // namespace Slang

‎source/compiler-core/slang-json-parser.h

+35-13
Original file line numberDiff line numberDiff line change
@@ -11,18 +11,32 @@ class JSONListener
1111
{
1212
public:
1313
/// Start an object
14-
virtual void startObject() = 0;
14+
virtual void startObject(SourceLoc loc) = 0;
1515
/// End an object
16-
virtual void endObject() = 0;
16+
virtual void endObject(SourceLoc loc) = 0;
1717
/// Start an array
18-
virtual void startArray() = 0;
18+
virtual void startArray(SourceLoc loc) = 0;
1919
/// End and array
20-
virtual void endArray() = 0;
20+
virtual void endArray(SourceLoc loc) = 0;
2121

22-
/// Add the key lexeme. Must be followed by addLexemeValue.
23-
virtual void addLexemeKey(const UnownedStringSlice& key) = 0;
22+
23+
/// Add the key. Must be followed by addXXXValue.
24+
virtual void addKey(const UnownedStringSlice& key, SourceLoc loc) = 0;
2425
/// Can be performed in an array or after an addLexemeKey in an object
25-
virtual void addLexemeValue(JSONTokenType type, const UnownedStringSlice& value) = 0;
26+
virtual void addLexemeValue(JSONTokenType type, const UnownedStringSlice& value, SourceLoc loc) = 0;
27+
28+
/// An integer value
29+
virtual void addIntegerValue(int64_t value, SourceLoc loc) = 0;
30+
/// Add a floating point value
31+
virtual void addFloatValue(double value, SourceLoc loc) = 0;
32+
/// Add a boolean value
33+
virtual void addBoolValue(bool value, SourceLoc loc) = 0;
34+
35+
/// Add a string value. NOTE! string is unescaped/quoted
36+
virtual void addStringValue(const UnownedStringSlice& string, SourceLoc loc) = 0;
37+
38+
/// Add a null value
39+
virtual void addNullValue(SourceLoc loc) = 0;
2640
};
2741

2842
class JSONWriter : public JSONListener
@@ -75,12 +89,17 @@ class JSONWriter : public JSONListener
7589
static bool isAfter(Location loc) { return isObjectLike(loc) && (Index(loc) & 2) != 0; }
7690

7791
// Implement JSONListener
78-
virtual void startObject() SLANG_OVERRIDE;
79-
virtual void endObject() SLANG_OVERRIDE;
80-
virtual void startArray() SLANG_OVERRIDE;
81-
virtual void endArray() SLANG_OVERRIDE;
82-
virtual void addLexemeKey(const UnownedStringSlice& key) SLANG_OVERRIDE;
83-
virtual void addLexemeValue(JSONTokenType type, const UnownedStringSlice& value) SLANG_OVERRIDE;
92+
virtual void startObject(SourceLoc loc) SLANG_OVERRIDE;
93+
virtual void endObject(SourceLoc loc) SLANG_OVERRIDE;
94+
virtual void startArray(SourceLoc loc) SLANG_OVERRIDE;
95+
virtual void endArray(SourceLoc loc) SLANG_OVERRIDE;
96+
virtual void addKey(const UnownedStringSlice& key, SourceLoc loc) SLANG_OVERRIDE;
97+
virtual void addLexemeValue(JSONTokenType type, const UnownedStringSlice& value, SourceLoc loc) SLANG_OVERRIDE;
98+
virtual void addIntegerValue(int64_t value, SourceLoc loc) SLANG_OVERRIDE;
99+
virtual void addFloatValue(double value, SourceLoc loc) SLANG_OVERRIDE;
100+
virtual void addBoolValue(bool value, SourceLoc loc) SLANG_OVERRIDE;
101+
virtual void addStringValue(const UnownedStringSlice& string, SourceLoc loc) SLANG_OVERRIDE;
102+
virtual void addNullValue(SourceLoc loc) SLANG_OVERRIDE;
84103

85104
/// Get the builder
86105
StringBuilder& getBuilder() { return m_builder; }
@@ -142,6 +161,9 @@ class JSONWriter : public JSONListener
142161
void _maybeEmitComma();
143162
void _maybeEmitFieldComma();
144163

164+
void _preValue(SourceLoc loc);
165+
void _postValue();
166+
145167
void _indent() { m_currentIndent++; }
146168
void _dedent() { --m_currentIndent; SLANG_ASSERT(m_currentIndent >= 0); }
147169

0 commit comments

Comments
 (0)