Skip to content

Commit 8a96a95

Browse files
miloyipmiloyip
authored
Merge branch 'master' into fix-noexcept
2 parents f54f6b5 + f5f6052 commit 8a96a95

14 files changed

+228
-193
lines changed

‎include/rapidjson/prettywriter.h

Lines changed: 12 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -92,26 +92,26 @@ class PrettyWriter : public Writer<OutputStream, SourceEncoding, TargetEncoding,
9292
*/
9393
//@{
9494

95-
bool Null() { PrettyPrefix(kNullType); return Base::WriteNull(); }
96-
bool Bool(bool b) { PrettyPrefix(b ? kTrueType : kFalseType); return Base::WriteBool(b); }
97-
bool Int(int i) { PrettyPrefix(kNumberType); return Base::WriteInt(i); }
98-
bool Uint(unsigned u) { PrettyPrefix(kNumberType); return Base::WriteUint(u); }
99-
bool Int64(int64_t i64) { PrettyPrefix(kNumberType); return Base::WriteInt64(i64); }
100-
bool Uint64(uint64_t u64) { PrettyPrefix(kNumberType); return Base::WriteUint64(u64); }
101-
bool Double(double d) { PrettyPrefix(kNumberType); return Base::WriteDouble(d); }
95+
bool Null() { PrettyPrefix(kNullType); return Base::EndValue(Base::WriteNull()); }
96+
bool Bool(bool b) { PrettyPrefix(b ? kTrueType : kFalseType); return Base::EndValue(Base::WriteBool(b)); }
97+
bool Int(int i) { PrettyPrefix(kNumberType); return Base::EndValue(Base::WriteInt(i)); }
98+
bool Uint(unsigned u) { PrettyPrefix(kNumberType); return Base::EndValue(Base::WriteUint(u)); }
99+
bool Int64(int64_t i64) { PrettyPrefix(kNumberType); return Base::EndValue(Base::WriteInt64(i64)); }
100+
bool Uint64(uint64_t u64) { PrettyPrefix(kNumberType); return Base::EndValue(Base::WriteUint64(u64)); }
101+
bool Double(double d) { PrettyPrefix(kNumberType); return Base::EndValue(Base::WriteDouble(d)); }
102102

103103
bool RawNumber(const Ch* str, SizeType length, bool copy = false) {
104104
RAPIDJSON_ASSERT(str != 0);
105105
(void)copy;
106106
PrettyPrefix(kNumberType);
107-
return Base::WriteString(str, length);
107+
return Base::EndValue(Base::WriteString(str, length));
108108
}
109109

110110
bool String(const Ch* str, SizeType length, bool copy = false) {
111111
RAPIDJSON_ASSERT(str != 0);
112112
(void)copy;
113113
PrettyPrefix(kStringType);
114-
return Base::WriteString(str, length);
114+
return Base::EndValue(Base::WriteString(str, length));
115115
}
116116

117117
#if RAPIDJSON_HAS_STDSTRING
@@ -146,7 +146,7 @@ class PrettyWriter : public Writer<OutputStream, SourceEncoding, TargetEncoding,
146146
Base::os_->Put('\n');
147147
WriteIndent();
148148
}
149-
bool ret = Base::WriteEndObject();
149+
bool ret = Base::EndValue(Base::WriteEndObject());
150150
(void)ret;
151151
RAPIDJSON_ASSERT(ret == true);
152152
if (Base::level_stack_.Empty()) // end of json text
@@ -170,7 +170,7 @@ class PrettyWriter : public Writer<OutputStream, SourceEncoding, TargetEncoding,
170170
Base::os_->Put('\n');
171171
WriteIndent();
172172
}
173-
bool ret = Base::WriteEndArray();
173+
bool ret = Base::EndValue(Base::WriteEndArray());
174174
(void)ret;
175175
RAPIDJSON_ASSERT(ret == true);
176176
if (Base::level_stack_.Empty()) // end of json text
@@ -201,7 +201,7 @@ class PrettyWriter : public Writer<OutputStream, SourceEncoding, TargetEncoding,
201201
bool RawValue(const Ch* json, size_t length, Type type) {
202202
RAPIDJSON_ASSERT(json != 0);
203203
PrettyPrefix(type);
204-
return Base::WriteRawValue(json, length);
204+
return Base::EndValue(Base::WriteRawValue(json, length));
205205
}
206206

207207
protected:

‎include/rapidjson/rapidjson.h

Lines changed: 15 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -269,16 +269,11 @@
269269
/*! \ingroup RAPIDJSON_CONFIG
270270
\param x pointer to align
271271
272-
Some machines require strict data alignment. Currently the default uses 4 bytes
273-
alignment on 32-bit platforms and 8 bytes alignment for 64-bit platforms.
272+
Some machines require strict data alignment. The default is 8 bytes.
274273
User can customize by defining the RAPIDJSON_ALIGN function macro.
275274
*/
276275
#ifndef RAPIDJSON_ALIGN
277-
#if RAPIDJSON_64BIT == 1
278-
#define RAPIDJSON_ALIGN(x) (((x) + static_cast<uint64_t>(7u)) & ~static_cast<uint64_t>(7u))
279-
#else
280-
#define RAPIDJSON_ALIGN(x) (((x) + 3u) & ~3u)
281-
#endif
276+
#define RAPIDJSON_ALIGN(x) (((x) + static_cast<size_t>(7u)) & ~static_cast<size_t>(7u))
282277
#endif
283278

284279
///////////////////////////////////////////////////////////////////////////////
@@ -617,6 +612,19 @@ RAPIDJSON_NAMESPACE_END
617612
#endif // RAPIDJSON_HAS_CXX11_NOEXCEPT
618613
#endif // RAPIDJSON_NOEXCEPT_ASSERT
619614

615+
///////////////////////////////////////////////////////////////////////////////
616+
// RAPIDJSON_NOEXCEPT_ASSERT
617+
618+
#ifdef RAPIDJSON_ASSERT_THROWS
619+
#if RAPIDJSON_HAS_CXX11_NOEXCEPT
620+
#define RAPIDJSON_NOEXCEPT_ASSERT(x)
621+
#else
622+
#define RAPIDJSON_NOEXCEPT_ASSERT(x) RAPIDJSON_ASSERT(x)
623+
#endif // RAPIDJSON_HAS_CXX11_NOEXCEPT
624+
#else
625+
#define RAPIDJSON_NOEXCEPT_ASSERT(x) RAPIDJSON_ASSERT(x)
626+
#endif // RAPIDJSON_ASSERT_THROWS
627+
620628
///////////////////////////////////////////////////////////////////////////////
621629
// new/delete
622630

‎include/rapidjson/reader.h

Lines changed: 23 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -606,7 +606,7 @@ class GenericReader {
606606
parseResult_.Clear();
607607
state_ = IterativeParsingStartState;
608608
}
609-
609+
610610
//! Parse one token from JSON text
611611
/*! \tparam InputStream Type of input stream, implementing Stream concept
612612
\tparam Handler Type of handler, implementing Handler concept.
@@ -618,23 +618,23 @@ class GenericReader {
618618
bool IterativeParseNext(InputStream& is, Handler& handler) {
619619
while (RAPIDJSON_LIKELY(is.Peek() != '\0')) {
620620
SkipWhitespaceAndComments<parseFlags>(is);
621-
621+
622622
Token t = Tokenize(is.Peek());
623623
IterativeParsingState n = Predict(state_, t);
624624
IterativeParsingState d = Transit<parseFlags>(state_, t, n, is, handler);
625-
625+
626626
// If we've finished or hit an error...
627627
if (RAPIDJSON_UNLIKELY(IsIterativeParsingCompleteState(d))) {
628628
// Report errors.
629629
if (d == IterativeParsingErrorState) {
630630
HandleError(state_, is);
631631
return false;
632632
}
633-
633+
634634
// Transition to the finish state.
635635
RAPIDJSON_ASSERT(d == IterativeParsingFinishState);
636636
state_ = d;
637-
637+
638638
// If StopWhenDone is not set...
639639
if (!(parseFlags & kParseStopWhenDoneFlag)) {
640640
// ... and extra non-whitespace data is found...
@@ -645,30 +645,30 @@ class GenericReader {
645645
return false;
646646
}
647647
}
648-
648+
649649
// Success! We are done!
650650
return true;
651651
}
652-
652+
653653
// Transition to the new state.
654654
state_ = d;
655655

656656
// If we parsed anything other than a delimiter, we invoked the handler, so we can return true now.
657657
if (!IsIterativeParsingDelimiterState(n))
658658
return true;
659659
}
660-
660+
661661
// We reached the end of file.
662662
stack_.Clear();
663663

664664
if (state_ != IterativeParsingFinishState) {
665665
HandleError(state_, is);
666666
return false;
667667
}
668-
668+
669669
return true;
670670
}
671-
671+
672672
//! Check if token-by-token parsing JSON text is complete
673673
/*! \return Whether the JSON has been fully decoded.
674674
*/
@@ -1523,7 +1523,7 @@ class GenericReader {
15231523
}
15241524
}
15251525
}
1526-
1526+
15271527
if (RAPIDJSON_UNLIKELY(!useNanOrInf)) {
15281528
RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, s.Tell());
15291529
}
@@ -1701,7 +1701,7 @@ class GenericReader {
17011701
d = internal::StrtodNormalPrecision(d, p);
17021702

17031703
// Use > max, instead of == inf, to fix bogus warning -Wfloat-equal
1704-
if (d > std::numeric_limits<double>::max()) {
1704+
if (d > (std::numeric_limits<double>::max)()) {
17051705
// Overflow
17061706
// TODO: internal::StrtodX should report overflow (or underflow)
17071707
RAPIDJSON_PARSE_ERROR(kParseErrorNumberTooBig, startOffset);
@@ -1769,12 +1769,12 @@ class GenericReader {
17691769

17701770
// Single value state
17711771
IterativeParsingValueState,
1772-
1772+
17731773
// Delimiter states (at bottom)
17741774
IterativeParsingElementDelimiterState,
17751775
IterativeParsingMemberDelimiterState,
17761776
IterativeParsingKeyValueDelimiterState,
1777-
1777+
17781778
cIterativeParsingStateCount
17791779
};
17801780

@@ -2167,43 +2167,43 @@ class GenericReader {
21672167
RAPIDJSON_FORCEINLINE bool IsIterativeParsingDelimiterState(IterativeParsingState s) const {
21682168
return s >= IterativeParsingElementDelimiterState;
21692169
}
2170-
2170+
21712171
RAPIDJSON_FORCEINLINE bool IsIterativeParsingCompleteState(IterativeParsingState s) const {
21722172
return s <= IterativeParsingErrorState;
21732173
}
2174-
2174+
21752175
template <unsigned parseFlags, typename InputStream, typename Handler>
21762176
ParseResult IterativeParse(InputStream& is, Handler& handler) {
21772177
parseResult_.Clear();
21782178
ClearStackOnExit scope(*this);
21792179
IterativeParsingState state = IterativeParsingStartState;
2180-
2180+
21812181
SkipWhitespaceAndComments<parseFlags>(is);
21822182
RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
21832183
while (is.Peek() != '\0') {
21842184
Token t = Tokenize(is.Peek());
21852185
IterativeParsingState n = Predict(state, t);
21862186
IterativeParsingState d = Transit<parseFlags>(state, t, n, is, handler);
2187-
2187+
21882188
if (d == IterativeParsingErrorState) {
21892189
HandleError(state, is);
21902190
break;
21912191
}
2192-
2192+
21932193
state = d;
2194-
2194+
21952195
// Do not further consume streams if a root JSON has been parsed.
21962196
if ((parseFlags & kParseStopWhenDoneFlag) && state == IterativeParsingFinishState)
21972197
break;
2198-
2198+
21992199
SkipWhitespaceAndComments<parseFlags>(is);
22002200
RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
22012201
}
2202-
2202+
22032203
// Handle the end of file.
22042204
if (state != IterativeParsingFinishState)
22052205
HandleError(state, is);
2206-
2206+
22072207
return parseResult_;
22082208
}
22092209

‎test/perftest/platformtest.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -76,7 +76,7 @@ TEST_F(Platform, strlen) {
7676

7777
TEST_F(Platform, memcmp) {
7878
for (int i = 0; i < kTrialCount; i++) {
79-
EXPECT_EQ(0, memcmp(temp_, json_, length_));
79+
EXPECT_EQ(0u, memcmp(temp_, json_, length_));
8080
}
8181
}
8282

‎test/unittest/allocatorstest.cpp

Lines changed: 12 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -63,23 +63,21 @@ TEST(Allocator, MemoryPoolAllocator) {
6363
}
6464

6565
TEST(Allocator, Alignment) {
66-
#if RAPIDJSON_64BIT == 1
67-
EXPECT_EQ(RAPIDJSON_UINT64_C2(0x00000000, 0x00000000), RAPIDJSON_ALIGN(0));
68-
for (uint64_t i = 1; i < 8; i++) {
69-
EXPECT_EQ(RAPIDJSON_UINT64_C2(0x00000000, 0x00000008), RAPIDJSON_ALIGN(i));
70-
EXPECT_EQ(RAPIDJSON_UINT64_C2(0x00000000, 0x00000010), RAPIDJSON_ALIGN(RAPIDJSON_UINT64_C2(0x00000000, 0x00000008) + i));
71-
EXPECT_EQ(RAPIDJSON_UINT64_C2(0x00000001, 0x00000000), RAPIDJSON_ALIGN(RAPIDJSON_UINT64_C2(0x00000000, 0xFFFFFFF8) + i));
72-
EXPECT_EQ(RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0xFFFFFFF8), RAPIDJSON_ALIGN(RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0xFFFFFFF0) + i));
66+
if (sizeof(size_t) >= 8) {
67+
EXPECT_EQ(RAPIDJSON_UINT64_C2(0x00000000, 0x00000000), RAPIDJSON_ALIGN(0));
68+
for (uint64_t i = 1; i < 8; i++) {
69+
EXPECT_EQ(RAPIDJSON_UINT64_C2(0x00000000, 0x00000008), RAPIDJSON_ALIGN(i));
70+
EXPECT_EQ(RAPIDJSON_UINT64_C2(0x00000000, 0x00000010), RAPIDJSON_ALIGN(RAPIDJSON_UINT64_C2(0x00000000, 0x00000008) + i));
71+
EXPECT_EQ(RAPIDJSON_UINT64_C2(0x00000001, 0x00000000), RAPIDJSON_ALIGN(RAPIDJSON_UINT64_C2(0x00000000, 0xFFFFFFF8) + i));
72+
EXPECT_EQ(RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0xFFFFFFF8), RAPIDJSON_ALIGN(RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0xFFFFFFF0) + i));
73+
}
7374
}
74-
#else
75+
7576
EXPECT_EQ(0u, RAPIDJSON_ALIGN(0u));
76-
for (uint32_t i = 1; i < 4; i++) {
77-
EXPECT_EQ(4u, RAPIDJSON_ALIGN(i));
78-
EXPECT_EQ(8u, RAPIDJSON_ALIGN(4u + i));
79-
EXPECT_EQ(0xFFFFFFF8u, RAPIDJSON_ALIGN(0xFFFFFFF4u + i));
80-
EXPECT_EQ(0xFFFFFFFCu, RAPIDJSON_ALIGN(0xFFFFFFF8u + i));
77+
for (uint32_t i = 1; i < 8; i++) {
78+
EXPECT_EQ(8u, RAPIDJSON_ALIGN(i));
79+
EXPECT_EQ(0xFFFFFFF8u, RAPIDJSON_ALIGN(0xFFFFFFF0u + i));
8180
}
82-
#endif
8381
}
8482

8583
TEST(Allocator, Issue399) {

0 commit comments

Comments
 (0)