Fix clang warnings.

asfernandes · asfernandes · commit fd5a02494fcb · 2025-06-21T15:40:53.000-03:00
diff --git a/src/common/ThreadStart.h b/src/common/ThreadStart.h
@@ -171,7 +171,7 @@ class ThreadFinishSync
 			threadArg->exceptionHandler(ex, threadRoutine);
 		}
 
-		if (cleanup)
+		if (cleanup != nullptr)
 			cleanup(threadArg);
 		closing = true;
 	}
diff --git a/src/common/TimeZoneUtil.cpp b/src/common/TimeZoneUtil.cpp
@@ -1057,11 +1057,10 @@ ISC_TIMESTAMP_TZ TimeZoneUtil::dateToTimeStampTz(const ISC_DATE& date, Callbacks
 
 //-------------------------------------
 
-TimeZoneRuleIterator::TimeZoneRuleIterator(USHORT aId, const ISC_TIMESTAMP_TZ& aFrom, const ISC_TIMESTAMP_TZ& aTo)
-	: id(aId),
-	  icuLib(UnicodeUtil::getConversionICU()),
+TimeZoneRuleIterator::TimeZoneRuleIterator(USHORT id, const ISC_TIMESTAMP_TZ& aFrom, const ISC_TIMESTAMP_TZ& aTo)
+	: icuLib(UnicodeUtil::getConversionICU()),
 	  toTicks(TimeStamp::timeStampToTicks(aTo.utc_timestamp)),
-	  icuCalendar(getDesc(aId)->getCalendar(icuLib))
+	  icuCalendar(getDesc(id)->getCalendar(icuLib))
 {
 	UErrorCode icuErrorCode = U_ZERO_ERROR;
 
diff --git a/src/common/TimeZoneUtil.h b/src/common/TimeZoneUtil.h
@@ -199,7 +199,7 @@ class IcuCalendarWrapper
 class TimeZoneRuleIterator
 {
 public:
-	TimeZoneRuleIterator(USHORT aId, const ISC_TIMESTAMP_TZ& aFrom, const ISC_TIMESTAMP_TZ& aTo);
+	TimeZoneRuleIterator(USHORT id, const ISC_TIMESTAMP_TZ& aFrom, const ISC_TIMESTAMP_TZ& aTo);
 
 public:
 	bool next();
@@ -211,7 +211,6 @@ class TimeZoneRuleIterator
 	SSHORT dstOffset;
 
 private:
-	const USHORT id;
 	UnicodeUtil::ConversionICU& icuLib;
 	SINT64 startTicks;
 	SINT64 toTicks;
diff --git a/src/common/classes/array.h b/src/common/classes/array.h
@@ -186,7 +186,7 @@ class Array : protected Storage
 	void copyFrom(const Array<T, Storage>& source)
 	{
 		ensureCapacity(source.count, false);
-		memcpy(data, source.data, sizeof(T) * source.count);
+		memcpy(static_cast<void*>(data), source.data, sizeof(T) * source.count);
 		count = source.count;
 	}
 
@@ -244,7 +244,7 @@ class Array : protected Storage
 		fb_assert(index <= count);
 		fb_assert(count < FB_MAX_SIZEOF);
 		ensureCapacity(count + 1);
-		memmove(data + index + 1, data + index, sizeof(T) * (count++ - index));
+		memmove(static_cast<void*>(data + index + 1), data + index, sizeof(T) * (count++ - index));
 		data[index] = item;
 	}
 
@@ -253,8 +253,8 @@ class Array : protected Storage
 		fb_assert(index <= count);
 		fb_assert(count <= FB_MAX_SIZEOF - items.count);
 		ensureCapacity(count + items.count);
-		memmove(data + index + items.count, data + index, sizeof(T) * (count - index));
-		memcpy(data + index, items.data, items.count);
+		memmove(static_cast<void*>(data + index + items.count), data + index, sizeof(T) * (count - index));
+		memcpy(static_cast<void*>(data + index), items.data, items.count);
 		count += items.count;
 	}
 
@@ -263,8 +263,8 @@ class Array : protected Storage
 		fb_assert(index <= count);
 		fb_assert(count <= FB_MAX_SIZEOF - itemsCount);
 		ensureCapacity(count + itemsCount);
-		memmove(data + index + itemsCount, data + index, sizeof(T) * (count - index));
-		memcpy(data + index, items, sizeof(T) * itemsCount);
+		memmove(static_cast<void*>(data + index + itemsCount), data + index, sizeof(T) * (count - index));
+		memcpy(static_cast<void*>(data + index), items, sizeof(T) * itemsCount);
 		count += itemsCount;
 	}
 
@@ -285,39 +285,39 @@ class Array : protected Storage
 	{
 		fb_assert(count <= FB_MAX_SIZEOF - itemsCount);
 		ensureCapacity(count + itemsCount);
-		memcpy(data + count, items, sizeof(T) * itemsCount);
+		memcpy(static_cast<void*>(data + count), items, sizeof(T) * itemsCount);
 		count += itemsCount;
 	}
 
 	T* remove(const size_type index) noexcept
 	{
-  		fb_assert(index < count);
-  		memmove(data + index, data + index + 1, sizeof(T) * (--count - index));
+		fb_assert(index < count);
+		memmove(static_cast<void*>(data + index), data + index + 1, sizeof(T) * (--count - index));
 		return &data[index];
 	}
 
 	T* removeRange(const size_type from, const size_type to) noexcept
 	{
-  		fb_assert(from <= to);
-  		fb_assert(to <= count);
-  		memmove(data + from, data + to, sizeof(T) * (count - to));
+		fb_assert(from <= to);
+		fb_assert(to <= count);
+		memmove(static_cast<void*>(data + from), data + to, sizeof(T) * (count - to));
 		count -= (to - from);
 		return &data[from];
 	}
 
 	T* removeCount(const size_type index, const size_type n) noexcept
 	{
-  		fb_assert(index + n <= count);
-  		memmove(data + index, data + index + n, sizeof(T) * (count - index - n));
+		fb_assert(index + n <= count);
+		memmove(static_cast<void*>(data + index), data + index + n, sizeof(T) * (count - index - n));
 		count -= n;
 		return &data[index];
 	}
 
 	T* remove(T* itr) noexcept
 	{
 		const size_type index = itr - begin();
-  		fb_assert(index < count);
-  		memmove(data + index, data + index + 1, sizeof(T) * (--count - index));
+		fb_assert(index < count);
+		memmove(static_cast<void*>(data + index), data + index + 1, sizeof(T) * (--count - index));
 		return &data[index];
 	}
 
@@ -337,7 +337,7 @@ class Array : protected Storage
 	{
 		fb_assert(newCount >= count);
 		ensureCapacity(newCount);
-		memset(data + count, 0, sizeof(T) * (newCount - count));
+		memset(static_cast<void*>(data + count), 0, sizeof(T) * (newCount - count));
 		count = newCount;
 	}
 
@@ -371,7 +371,7 @@ class Array : protected Storage
 	{
 		fb_assert(count <= FB_MAX_SIZEOF - L.count);
 		ensureCapacity(count + L.count);
-		memcpy(data + count, L.data, sizeof(T) * L.count);
+		memcpy(static_cast<void*>(data + count), L.data, sizeof(T) * L.count);
 		count += L.count;
 	}
 
@@ -383,7 +383,7 @@ class Array : protected Storage
 	void assign(const T* items, const size_type itemsCount)
 	{
 		resize(itemsCount);
-		memcpy(data, items, sizeof(T) * count);
+		memcpy(static_cast<void*>(data), items, sizeof(T) * count);
 	}
 
 	size_type getCount() const noexcept { return count; }
@@ -403,7 +403,7 @@ class Array : protected Storage
 	{
 		fb_assert(count <= FB_MAX_SIZEOF - itemsSize);
 		ensureCapacity(count + itemsSize);
-		memcpy(data + count, items, sizeof(T) * itemsSize);
+		memcpy(static_cast<void*>(data + count), items, sizeof(T) * itemsSize);
 		count += itemsSize;
 	}
 
@@ -533,7 +533,7 @@ class Array : protected Storage
 			T* newdata = static_cast<T*>
 				(this->getPool().allocate(sizeof(T) * newcapacity ALLOC_ARGS));
 			if (preserve)
-				memcpy(newdata, data, sizeof(T) * count);
+				memcpy(static_cast<void*>(newdata), data, sizeof(T) * count);
 			freeData();
 			data = newdata;
 			capacity = newcapacity;
diff --git a/src/dsql/AggNodes.cpp b/src/dsql/AggNodes.cpp
@@ -902,8 +902,9 @@ void ListAggNode::make(DsqlCompilerScratch* dsqlScratch, dsc* desc)
 bool ListAggNode::setParameterType(DsqlCompilerScratch* dsqlScratch,
 	std::function<void (dsc*)> makeDesc, bool forceVarChar)
 {
-	return PASS1_set_parameter_type(dsqlScratch, arg, makeDesc, forceVarChar) |
-		PASS1_set_parameter_type(dsqlScratch, delimiter, makeDesc, forceVarChar);
+	const bool argType = PASS1_set_parameter_type(dsqlScratch, arg, makeDesc, forceVarChar);
+	const bool delimiterType = PASS1_set_parameter_type(dsqlScratch, delimiter, makeDesc, forceVarChar);
+	return argType || delimiterType;
 }
 
 void ListAggNode::getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc)
diff --git a/src/dsql/ExprNodes.cpp b/src/dsql/ExprNodes.cpp
@@ -653,8 +653,9 @@ void ArithmeticNode::setParameterName(dsql_par* parameter) const
 bool ArithmeticNode::setParameterType(DsqlCompilerScratch* dsqlScratch,
 	std::function<void (dsc*)> makeDesc, bool forceVarChar)
 {
-	return PASS1_set_parameter_type(dsqlScratch, arg1, makeDesc, forceVarChar) |
-		PASS1_set_parameter_type(dsqlScratch, arg2, makeDesc, forceVarChar);
+	const bool arg1Type = PASS1_set_parameter_type(dsqlScratch, arg1, makeDesc, forceVarChar);
+	const bool arg2Type = PASS1_set_parameter_type(dsqlScratch, arg2, makeDesc, forceVarChar);
+	return arg1Type || arg2Type;
 }
 
 void ArithmeticNode::genBlr(DsqlCompilerScratch* dsqlScratch)
@@ -3273,8 +3274,10 @@ bool AtNode::setParameterType(DsqlCompilerScratch* dsqlScratch,
 			desc->setNullable(true);
 		};
 
-	return PASS1_set_parameter_type(dsqlScratch, dateTimeArg, makeDesc, forceVarChar) |
-		PASS1_set_parameter_type(dsqlScratch, zoneArg, makeZoneDesc, forceVarChar);
+	const bool dateTimeArgType = PASS1_set_parameter_type(dsqlScratch, dateTimeArg, makeDesc, forceVarChar);
+	const bool zoneArgType = PASS1_set_parameter_type(dsqlScratch, zoneArg, makeZoneDesc, forceVarChar);
+
+	return dateTimeArgType || zoneArgType;
 }
 
 void AtNode::genBlr(DsqlCompilerScratch* dsqlScratch)
@@ -4107,8 +4110,9 @@ void ConcatenateNode::setParameterName(dsql_par* parameter) const
 bool ConcatenateNode::setParameterType(DsqlCompilerScratch* dsqlScratch,
 	std::function<void (dsc*)> makeDesc, bool forceVarChar)
 {
-	return PASS1_set_parameter_type(dsqlScratch, arg1, makeDesc, forceVarChar) |
-		PASS1_set_parameter_type(dsqlScratch, arg2, makeDesc, forceVarChar);
+	const bool arg1Type = PASS1_set_parameter_type(dsqlScratch, arg1, makeDesc, forceVarChar);
+	const bool arg2Type = PASS1_set_parameter_type(dsqlScratch, arg2, makeDesc, forceVarChar);
+	return arg1Type || arg2Type;
 }
 
 void ConcatenateNode::genBlr(DsqlCompilerScratch* dsqlScratch)
@@ -11893,9 +11897,10 @@ void SubstringNode::setParameterName(dsql_par* parameter) const
 bool SubstringNode::setParameterType(DsqlCompilerScratch* dsqlScratch,
 	std::function<void (dsc*)> makeDesc, bool forceVarChar)
 {
-	return PASS1_set_parameter_type(dsqlScratch, expr, makeDesc, forceVarChar) |
-		PASS1_set_parameter_type(dsqlScratch, start, makeDesc, forceVarChar) |
-		PASS1_set_parameter_type(dsqlScratch, length, makeDesc, forceVarChar);
+	const bool exprType = PASS1_set_parameter_type(dsqlScratch, expr, makeDesc, forceVarChar);
+	const bool startType = PASS1_set_parameter_type(dsqlScratch, start, makeDesc, forceVarChar);
+	const bool lengthType = PASS1_set_parameter_type(dsqlScratch, length, makeDesc, forceVarChar);
+	return exprType || startType || lengthType;
 }
 
 void SubstringNode::genBlr(DsqlCompilerScratch* dsqlScratch)
@@ -12217,9 +12222,10 @@ void SubstringSimilarNode::setParameterName(dsql_par* parameter) const
 bool SubstringSimilarNode::setParameterType(DsqlCompilerScratch* dsqlScratch,
 	std::function<void (dsc*)> makeDesc, bool forceVarChar)
 {
-	return PASS1_set_parameter_type(dsqlScratch, expr, makeDesc, forceVarChar) |
-		PASS1_set_parameter_type(dsqlScratch, pattern, makeDesc, forceVarChar) |
-		PASS1_set_parameter_type(dsqlScratch, escape, makeDesc, forceVarChar);
+	const bool exprType = PASS1_set_parameter_type(dsqlScratch, expr, makeDesc, forceVarChar);
+	const bool patternType = PASS1_set_parameter_type(dsqlScratch, pattern, makeDesc, forceVarChar);
+	const bool escapeType = PASS1_set_parameter_type(dsqlScratch, escape, makeDesc, forceVarChar);
+	return exprType || patternType || escapeType;
 }
 
 void SubstringSimilarNode::genBlr(DsqlCompilerScratch* dsqlScratch)
@@ -12745,8 +12751,9 @@ void TrimNode::setParameterName(dsql_par* parameter) const
 bool TrimNode::setParameterType(DsqlCompilerScratch* dsqlScratch,
 	std::function<void (dsc*)> makeDesc, bool forceVarChar)
 {
-	return PASS1_set_parameter_type(dsqlScratch, value, makeDesc, forceVarChar) |
-		PASS1_set_parameter_type(dsqlScratch, trimChars, makeDesc, forceVarChar);
+	const bool valueType = PASS1_set_parameter_type(dsqlScratch, value, makeDesc, forceVarChar);
+	const bool trimCharsType = PASS1_set_parameter_type(dsqlScratch, trimChars, makeDesc, forceVarChar);
+	return valueType || trimCharsType;
 }
 
 void TrimNode::genBlr(DsqlCompilerScratch* dsqlScratch)
@@ -14118,8 +14125,9 @@ void ValueIfNode::setParameterName(dsql_par* parameter) const
 bool ValueIfNode::setParameterType(DsqlCompilerScratch* dsqlScratch,
 	std::function<void (dsc*)> makeDesc, bool forceVarChar)
 {
-	return PASS1_set_parameter_type(dsqlScratch, trueValue, makeDesc, forceVarChar) |
-		PASS1_set_parameter_type(dsqlScratch, falseValue, makeDesc, forceVarChar);
+	const bool trueValueType = PASS1_set_parameter_type(dsqlScratch, trueValue, makeDesc, forceVarChar);
+	const bool falseValueType = PASS1_set_parameter_type(dsqlScratch, falseValue, makeDesc, forceVarChar);
+	return trueValueType || falseValueType;
 }
 
 void ValueIfNode::genBlr(DsqlCompilerScratch* dsqlScratch)
diff --git a/src/jrd/recsrc/RecursiveStream.cpp b/src/jrd/recsrc/RecursiveStream.cpp
@@ -311,7 +311,7 @@ void RecursiveStream::cleanupLevel(Request* request, Impure* impure) const
 	{
 		record_param* const rpb = &request->req_rpb[stream];
 		Record* const tempRecord = rpb->rpb_record;
-		memmove(rpb, p, sizeof(record_param));
+		memmove(static_cast<void*>(rpb), p, sizeof(record_param));
 		p += sizeof(record_param);
 
 		// We just restored record of current recursion level, delete record

Original file line number	Diff line number	Diff line change
`@@ -171,7 +171,7 @@ class ThreadFinishSync`
`171`	`171`	`threadArg->exceptionHandler(ex, threadRoutine);`
`172`	`172`	`}`
`173`	`173`
`174`		`- if (cleanup)`
	`174`	`+ if (cleanup != nullptr)`
`175`	`175`	`cleanup(threadArg);`
`176`	`176`	`closing = true;`
`177`	`177`	`}`
Original file line number	Diff line number	Diff line change
`@@ -186,7 +186,7 @@ class Array : protected Storage`
`186`	`186`	`void copyFrom(const Array<T, Storage>& source)`
`187`	`187`	`{`
`188`	`188`	`ensureCapacity(source.count, false);`
`189`		`- memcpy(data, source.data, sizeof(T) * source.count);`
	`189`	`+ memcpy(static_cast<void>(data), source.data, sizeof(T) source.count);`
`190`	`190`	`count = source.count;`
`191`	`191`	`}`
`192`	`192`
`@@ -244,7 +244,7 @@ class Array : protected Storage`
`244`	`244`	`fb_assert(index <= count);`
`245`	`245`	`fb_assert(count < FB_MAX_SIZEOF);`
`246`	`246`	`ensureCapacity(count + 1);`
`247`		`- memmove(data + index + 1, data + index, sizeof(T) * (count++ - index));`
	`247`	`+ memmove(static_cast<void>(data + index + 1), data + index, sizeof(T) (count++ - index));`
`248`	`248`	`data[index] = item;`
`249`	`249`	`}`
`250`	`250`
`@@ -253,8 +253,8 @@ class Array : protected Storage`
`253`	`253`	`fb_assert(index <= count);`
`254`	`254`	`fb_assert(count <= FB_MAX_SIZEOF - items.count);`
`255`	`255`	`ensureCapacity(count + items.count);`
`256`		`- memmove(data + index + items.count, data + index, sizeof(T) * (count - index));`
`257`		`- memcpy(data + index, items.data, items.count);`
	`256`	`+ memmove(static_cast<void>(data + index + items.count), data + index, sizeof(T) (count - index));`
	`257`	`+ memcpy(static_cast<void*>(data + index), items.data, items.count);`
`258`	`258`	`count += items.count;`
`259`	`259`	`}`
`260`	`260`
`@@ -263,8 +263,8 @@ class Array : protected Storage`
`263`	`263`	`fb_assert(index <= count);`
`264`	`264`	`fb_assert(count <= FB_MAX_SIZEOF - itemsCount);`
`265`	`265`	`ensureCapacity(count + itemsCount);`
`266`		`- memmove(data + index + itemsCount, data + index, sizeof(T) * (count - index));`
`267`		`- memcpy(data + index, items, sizeof(T) * itemsCount);`
	`266`	`+ memmove(static_cast<void>(data + index + itemsCount), data + index, sizeof(T) (count - index));`
	`267`	`+ memcpy(static_cast<void>(data + index), items, sizeof(T) itemsCount);`
`268`	`268`	`count += itemsCount;`
`269`	`269`	`}`
`270`	`270`
`@@ -285,39 +285,39 @@ class Array : protected Storage`
`285`	`285`	`{`
`286`	`286`	`fb_assert(count <= FB_MAX_SIZEOF - itemsCount);`
`287`	`287`	`ensureCapacity(count + itemsCount);`
`288`		`- memcpy(data + count, items, sizeof(T) * itemsCount);`
	`288`	`+ memcpy(static_cast<void>(data + count), items, sizeof(T) itemsCount);`
`289`	`289`	`count += itemsCount;`
`290`	`290`	`}`
`291`	`291`
`292`	`292`	`T* remove(const size_type index) noexcept`
`293`	`293`	`{`
`294`		`- fb_assert(index < count);`
`295`		`- memmove(data + index, data + index + 1, sizeof(T) * (--count - index));`
	`294`	`+ fb_assert(index < count);`
	`295`	`+ memmove(static_cast<void>(data + index), data + index + 1, sizeof(T) (--count - index));`
`296`	`296`	`return &data[index];`
`297`	`297`	`}`
`298`	`298`
`299`	`299`	`T* removeRange(const size_type from, const size_type to) noexcept`
`300`	`300`	`{`
`301`		`- fb_assert(from <= to);`
`302`		`- fb_assert(to <= count);`
`303`		`- memmove(data + from, data + to, sizeof(T) * (count - to));`
	`301`	`+ fb_assert(from <= to);`
	`302`	`+ fb_assert(to <= count);`
	`303`	`+ memmove(static_cast<void>(data + from), data + to, sizeof(T) (count - to));`
`304`	`304`	`count -= (to - from);`
`305`	`305`	`return &data[from];`
`306`	`306`	`}`
`307`	`307`
`308`	`308`	`T* removeCount(const size_type index, const size_type n) noexcept`
`309`	`309`	`{`
`310`		`- fb_assert(index + n <= count);`
`311`		`- memmove(data + index, data + index + n, sizeof(T) * (count - index - n));`
	`310`	`+ fb_assert(index + n <= count);`
	`311`	`+ memmove(static_cast<void>(data + index), data + index + n, sizeof(T) (count - index - n));`
`312`	`312`	`count -= n;`
`313`	`313`	`return &data[index];`
`314`	`314`	`}`
`315`	`315`
`316`	`316`	`T* remove(T* itr) noexcept`
`317`	`317`	`{`
`318`	`318`	`const size_type index = itr - begin();`
`319`		`- fb_assert(index < count);`
`320`		`- memmove(data + index, data + index + 1, sizeof(T) * (--count - index));`
	`319`	`+ fb_assert(index < count);`
	`320`	`+ memmove(static_cast<void>(data + index), data + index + 1, sizeof(T) (--count - index));`
`321`	`321`	`return &data[index];`
`322`	`322`	`}`
`323`	`323`
`@@ -337,7 +337,7 @@ class Array : protected Storage`
`337`	`337`	`{`
`338`	`338`	`fb_assert(newCount >= count);`
`339`	`339`	`ensureCapacity(newCount);`
`340`		`- memset(data + count, 0, sizeof(T) * (newCount - count));`
	`340`	`+ memset(static_cast<void>(data + count), 0, sizeof(T) (newCount - count));`
`341`	`341`	`count = newCount;`
`342`	`342`	`}`
`343`	`343`
`@@ -371,7 +371,7 @@ class Array : protected Storage`
`371`	`371`	`{`
`372`	`372`	`fb_assert(count <= FB_MAX_SIZEOF - L.count);`
`373`	`373`	`ensureCapacity(count + L.count);`
`374`		`- memcpy(data + count, L.data, sizeof(T) * L.count);`
	`374`	`+ memcpy(static_cast<void>(data + count), L.data, sizeof(T) L.count);`
`375`	`375`	`count += L.count;`
`376`	`376`	`}`
`377`	`377`
`@@ -383,7 +383,7 @@ class Array : protected Storage`
`383`	`383`	`void assign(const T* items, const size_type itemsCount)`
`384`	`384`	`{`
`385`	`385`	`resize(itemsCount);`
`386`		`- memcpy(data, items, sizeof(T) * count);`
	`386`	`+ memcpy(static_cast<void>(data), items, sizeof(T) count);`
`387`	`387`	`}`
`388`	`388`
`389`	`389`	`size_type getCount() const noexcept { return count; }`
`@@ -403,7 +403,7 @@ class Array : protected Storage`
`403`	`403`	`{`
`404`	`404`	`fb_assert(count <= FB_MAX_SIZEOF - itemsSize);`
`405`	`405`	`ensureCapacity(count + itemsSize);`
`406`		`- memcpy(data + count, items, sizeof(T) * itemsSize);`
	`406`	`+ memcpy(static_cast<void>(data + count), items, sizeof(T) itemsSize);`
`407`	`407`	`count += itemsSize;`
`408`	`408`	`}`
`409`	`409`
`@@ -533,7 +533,7 @@ class Array : protected Storage`
`533`	`533`	`T* newdata = static_cast<T*>`
`534`	`534`	`(this->getPool().allocate(sizeof(T) * newcapacity ALLOC_ARGS));`
`535`	`535`	`if (preserve)`
`536`		`- memcpy(newdata, data, sizeof(T) * count);`
	`536`	`+ memcpy(static_cast<void>(newdata), data, sizeof(T) count);`
`537`	`537`	`freeData();`
`538`	`538`	`data = newdata;`
`539`	`539`	`capacity = newcapacity;`
Original file line number	Diff line number	Diff line change
`@@ -902,8 +902,9 @@ void ListAggNode::make(DsqlCompilerScratch* dsqlScratch, dsc* desc)`
`902`	`902`	`bool ListAggNode::setParameterType(DsqlCompilerScratch* dsqlScratch,`
`903`	`903`	`std::function<void (dsc*)> makeDesc, bool forceVarChar)`
`904`	`904`	`{`
`905`		`- return PASS1_set_parameter_type(dsqlScratch, arg, makeDesc, forceVarChar) \|`
`906`		`- PASS1_set_parameter_type(dsqlScratch, delimiter, makeDesc, forceVarChar);`
	`905`	`+ const bool argType = PASS1_set_parameter_type(dsqlScratch, arg, makeDesc, forceVarChar);`
	`906`	`+ const bool delimiterType = PASS1_set_parameter_type(dsqlScratch, delimiter, makeDesc, forceVarChar);`
	`907`	`+ return argType \|\| delimiterType;`
`907`	`908`	`}`
`908`	`909`
`909`	`910`	`void ListAggNode::getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc)`
Original file line number	Diff line number	Diff line change
`@@ -311,7 +311,7 @@ void RecursiveStream::cleanupLevel(Request* request, Impure* impure) const`
`311`	`311`	`{`
`312`	`312`	`record_param* const rpb = &request->req_rpb[stream];`
`313`	`313`	`Record* const tempRecord = rpb->rpb_record;`
`314`		`- memmove(rpb, p, sizeof(record_param));`
	`314`	`+ memmove(static_cast<void*>(rpb), p, sizeof(record_param));`
`315`	`315`	`p += sizeof(record_param);`
`316`	`316`
`317`	`317`	`// We just restored record of current recursion level, delete record`