Bug Summary

File:comphelper/source/misc/types.cxx
Location:line 465, column 5
Description:Access to field 'pType' results in a dereference of a null pointer (loaded from variable 'pSequenceTD')

Annotated Source Code

1/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2/*
3 * This file is part of the LibreOffice project.
4 *
5 * This Source Code Form is subject to the terms of the Mozilla Public
6 * License, v. 2.0. If a copy of the MPL was not distributed with this
7 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 *
9 * This file incorporates work covered by the following license notice:
10 *
11 * Licensed to the Apache Software Foundation (ASF) under one or more
12 * contributor license agreements. See the NOTICE file distributed
13 * with this work for additional information regarding copyright
14 * ownership. The ASF licenses this file to you under the Apache
15 * License, Version 2.0 (the "License"); you may not use this file
16 * except in compliance with the License. You may obtain a copy of
17 * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 */
19
20#include <comphelper/types.hxx>
21#include <comphelper/extract.hxx>
22#include <com/sun/star/util/Date.hpp>
23#include <com/sun/star/util/Time.hpp>
24#include <com/sun/star/util/DateTime.hpp>
25#include <com/sun/star/awt/FontUnderline.hpp>
26#include <com/sun/star/awt/FontStrikeout.hpp>
27#include <com/sun/star/awt/FontDescriptor.hpp>
28#include <osl/diagnose.h>
29#include <typelib/typedescription.hxx>
30
31#include <memory.h>
32
33
34//.........................................................................
35namespace comphelper
36{
37//.........................................................................
38
39using namespace ::com::sun::star::uno;
40using namespace ::com::sun::star::awt;
41using namespace ::com::sun::star::util;
42using namespace ::com::sun::star::lang;
43
44//-------------------------------------------------------------------------
45sal_Bool operator ==(const DateTime& _rLeft, const DateTime& _rRight)
46{
47 return ( _rLeft.HundredthSeconds == _rRight.HundredthSeconds) &&
48 ( _rLeft.Seconds == _rRight.Seconds) &&
49 ( _rLeft.Minutes == _rRight.Minutes) &&
50 ( _rLeft.Hours == _rRight.Hours) &&
51 ( _rLeft.Day == _rRight.Day) &&
52 ( _rLeft.Month == _rRight.Month) &&
53 ( _rLeft.Year == _rRight.Year) ;
54}
55
56//-------------------------------------------------------------------------
57sal_Bool operator ==(const Date& _rLeft, const Date& _rRight)
58{
59 return ( _rLeft.Day == _rRight.Day) &&
60 ( _rLeft.Month == _rRight.Month) &&
61 ( _rLeft.Year == _rRight.Year) ;
62}
63
64//-------------------------------------------------------------------------
65sal_Bool operator ==(const Time& _rLeft, const Time& _rRight)
66{
67 return ( _rLeft.HundredthSeconds == _rRight.HundredthSeconds) &&
68 ( _rLeft.Seconds == _rRight.Seconds) &&
69 ( _rLeft.Minutes == _rRight.Minutes) &&
70 ( _rLeft.Hours == _rRight.Hours) ;
71}
72
73//------------------------------------------------------------------------------
74sal_Int64 getINT64(const Any& _rAny)
75{
76 sal_Int64 nReturn = 0;
77 OSL_VERIFY( _rAny >>= nReturn )do { if (!(_rAny >>= nReturn)) do { if (true &&
(!(0))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), (
"legacy.osl"), ("/usr/local/src/libreoffice/comphelper/source/misc/types.cxx"
":" "77" ": "), "OSL_ASSERT: %s", "0"); } } while (false); }
while (0);
78 return nReturn;
79}
80
81//------------------------------------------------------------------------------
82sal_Int32 getINT32(const Any& _rAny)
83{
84 sal_Int32 nReturn = 0;
85 OSL_VERIFY( _rAny >>= nReturn )do { if (!(_rAny >>= nReturn)) do { if (true &&
(!(0))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), (
"legacy.osl"), ("/usr/local/src/libreoffice/comphelper/source/misc/types.cxx"
":" "85" ": "), "OSL_ASSERT: %s", "0"); } } while (false); }
while (0);
86 return nReturn;
87}
88
89//------------------------------------------------------------------------------
90sal_Int16 getINT16(const Any& _rAny)
91{
92 sal_Int16 nReturn = 0;
93 OSL_VERIFY( _rAny >>= nReturn )do { if (!(_rAny >>= nReturn)) do { if (true &&
(!(0))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), (
"legacy.osl"), ("/usr/local/src/libreoffice/comphelper/source/misc/types.cxx"
":" "93" ": "), "OSL_ASSERT: %s", "0"); } } while (false); }
while (0);
94 return nReturn;
95}
96
97//------------------------------------------------------------------------------
98double getDouble(const Any& _rAny)
99{
100 double nReturn = 0.0;
101 OSL_VERIFY( _rAny >>= nReturn )do { if (!(_rAny >>= nReturn)) do { if (true &&
(!(0))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), (
"legacy.osl"), ("/usr/local/src/libreoffice/comphelper/source/misc/types.cxx"
":" "101" ": "), "OSL_ASSERT: %s", "0"); } } while (false); }
while (0);
102 return nReturn;
103}
104
105//------------------------------------------------------------------------------
106float getFloat(const Any& _rAny)
107{
108 float nReturn = 0.0;
109 OSL_VERIFY( _rAny >>= nReturn )do { if (!(_rAny >>= nReturn)) do { if (true &&
(!(0))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), (
"legacy.osl"), ("/usr/local/src/libreoffice/comphelper/source/misc/types.cxx"
":" "109" ": "), "OSL_ASSERT: %s", "0"); } } while (false); }
while (0);
110 return nReturn;
111}
112
113//------------------------------------------------------------------------------
114::rtl::OUString getString(const Any& _rAny)
115{
116 ::rtl::OUString nReturn;
117 OSL_VERIFY( _rAny >>= nReturn )do { if (!(_rAny >>= nReturn)) do { if (true &&
(!(0))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), (
"legacy.osl"), ("/usr/local/src/libreoffice/comphelper/source/misc/types.cxx"
":" "117" ": "), "OSL_ASSERT: %s", "0"); } } while (false); }
while (0);
118 return nReturn;
119}
120
121//------------------------------------------------------------------------------
122sal_Bool getBOOL(const Any& _rAny)
123{
124 sal_Bool nReturn = sal_False((sal_Bool)0);
125 if (_rAny.getValueType() == ::getCppuBooleanType())
126 nReturn = *(sal_Bool*)_rAny.getValue();
127 else
128 OSL_FAIL("comphelper::getBOOL : invalid argument !")do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/usr/local/src/libreoffice/comphelper/source/misc/types.cxx"
":" "128" ": "), "%s", "comphelper::getBOOL : invalid argument !"
); } } while (false);
129 return nReturn;
130}
131
132//------------------------------------------------------------------------------
133sal_Int32 getEnumAsINT32(const Any& _rAny) throw(IllegalArgumentException)
134{
135 sal_Int32 nReturn = 0;
136 if (! ::cppu::enum2int(nReturn,_rAny) )
137 throw IllegalArgumentException();
138 return nReturn;
139}
140
141//------------------------------------------------------------------------------
142FontDescriptor getDefaultFont()
143{
144 FontDescriptor aReturn;
145 aReturn.Slant = FontSlant_DONTKNOW;
146 aReturn.Underline = FontUnderline::DONTKNOW;
147 aReturn.Strikeout = FontStrikeout::DONTKNOW;
148 return aReturn;
149}
150
151//------------------------------------------------------------------------------
152sal_Bool isAssignableFrom(const Type& _rAssignable, const Type& _rFrom)
153{
154 // getthe type lib descriptions
155 typelib_TypeDescription* pAssignable = NULL__null;
156 _rAssignable.getDescription(&pAssignable);
157
158 typelib_TypeDescription* pFrom = NULL__null;
159 _rFrom.getDescription(&pFrom);
160
161 // and ask the type lib
162 return typelib_typedescription_isAssignableFrom(pAssignable, pFrom);
163}
164
165//------------------------------------------------------------------
166template<class TYPE>
167sal_Bool tryCompare(const void* _pData, const Any& _rValue, sal_Bool& _bIdentical, TYPE& _rOut)
168{
169 sal_Bool bSuccess = _rValue >>= _rOut;
170 _bIdentical = bSuccess && (_rOut == *reinterpret_cast<const TYPE*>(_pData));
171 return bSuccess;
172}
173
174//------------------------------------------------------------------
175sal_Bool tryCompare(const void* _pData, const Any& _rValue, sal_Bool& _bIdentical, sal_Unicode& _rOut)
176{
177 sal_Bool bSuccess = ( _rValue.getValueTypeClass() == TypeClass_CHAR );
178 if ( bSuccess )
179 _rOut = *static_cast< const sal_Unicode* >( _rValue.getValue() );
180 _bIdentical = bSuccess && ( _rOut == *static_cast< const sal_Unicode* >( _pData ) );
181 return bSuccess;
182}
183
184//------------------------------------------------------------------
185sal_Bool compare_impl(const Type& _rType, const void* pData, const Any& _rValue)
186{
187 sal_Bool bRes = sal_True((sal_Bool)1);
188
189 if (_rType.getTypeClass() == TypeClass_ANY)
190 {
191 // beides AnyWerte
192 if (_rValue.getValueType().getTypeClass() == TypeClass_ANY)
193 bRes = compare_impl(
194 reinterpret_cast<const Any*>(pData)->getValueType(),
195 reinterpret_cast<const Any*>(pData)->getValue(),
196 *reinterpret_cast<const Any*>(_rValue.getValue()));
197 else
198 bRes = compare_impl(
199 reinterpret_cast<const Any*>(pData)->getValueType(),
200 reinterpret_cast<const Any*>(pData)->getValue(),
201 _rValue);
202 }
203 else if ( (_rType.getTypeClass() == TypeClass_VOID)
204 || (_rValue.getValueType().getTypeClass() == TypeClass_VOID)
205 )
206 {
207 bRes = _rType.getTypeClass() == _rValue.getValueType().getTypeClass();
208 }
209 else
210 {
211 sal_Bool bConversionSuccess = sal_False((sal_Bool)0);
212 switch (_rType.getTypeClass())
213 {
214 case TypeClass_VOID:
215 bConversionSuccess = sal_True((sal_Bool)1);
216 bRes = _rValue.getValueType().getTypeClass() == TypeClass_VOID;
217 break;
218 case TypeClass_BOOLEAN:
219 {
220 sal_Bool aDummy;
221 bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy);
222 break;
223 }
224 case TypeClass_CHAR:
225 {
226 sal_Unicode aDummy(0);
227 bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy);
228 break;
229 }
230 case TypeClass_STRING:
231 {
232 ::rtl::OUString aDummy;
233 bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy);
234 break;
235 }
236 case TypeClass_FLOAT:
237 {
238 float aDummy;
239 bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy);
240 break;
241 }
242 case TypeClass_DOUBLE:
243 {
244 double aDummy;
245 bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy);
246 break;
247 }
248 case TypeClass_BYTE:
249 {
250 sal_Int8 aDummy;
251 bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy);
252 break;
253 }
254 case TypeClass_SHORT:
255 {
256 sal_Int16 aDummy;
257 bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy);
258 break;
259 }
260 case TypeClass_ENUM:
261 {
262 sal_Int32 nAsInt32 = 0;
263 bConversionSuccess = ::cppu::enum2int(nAsInt32, _rValue);
264 bRes = bConversionSuccess && (nAsInt32== *reinterpret_cast<const sal_Int32*>(pData));
265 break;
266 }
267 case TypeClass_LONG:
268 {
269 sal_Int32 aDummy;
270 bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy);
271 break;
272 }
273 case TypeClass_UNSIGNED_SHORT:
274 {
275 sal_uInt16 aDummy;
276 bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy);
277 break;
278 }
279 case TypeClass_UNSIGNED_LONG:
280 {
281 sal_uInt32 aDummy;
282 bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy);
283 break;
284 }
285 case TypeClass_INTERFACE:
286 {
287 InterfaceRef aDummy;
288 bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy);
289 break;
290 }
291 case TypeClass_STRUCT:
292 if (isA(_rType, static_cast<FontDescriptor*>(NULL__null)))
293 {
294 FontDescriptor aTemp;
295 bConversionSuccess = _rValue >>= aTemp;
296 if (bConversionSuccess)
297 {
298 bRes = *(FontDescriptor*)pData == aTemp;
299 }
300 else
301 bRes = sal_False((sal_Bool)0);
302 break;
303 }
304 if (isA(_rType, static_cast<Date*>(NULL__null)))
305 {
306 Date aDummy;
307 bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy);
308 break;
309 }
310 if (isA(_rType, static_cast<Time*>(NULL__null)))
311 {
312 Time aDummy;
313 bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy);
314 break;
315 }
316 if (isA(_rType, static_cast<DateTime*>(NULL__null)))
317 {
318 DateTime aDummy;
319 bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy);
320 break;
321 }
322 break;
323 case TypeClass_SEQUENCE:
324 if (isA(_rType, static_cast< Sequence<sal_Int8>* >(NULL__null)))
325 {
326 Sequence<sal_Int8> aTemp;
327 bConversionSuccess = _rValue >>= aTemp;
328 if (bConversionSuccess)
329 {
330 const Sequence<sal_Int8>& rLeftSeq = *reinterpret_cast<const Sequence<sal_Int8>*>(pData);
331 const Sequence<sal_Int8>& rRightSeq = aTemp;
332 bRes = rLeftSeq.getLength() == rRightSeq.getLength() &&
333 memcmp(rLeftSeq.getConstArray(), rRightSeq.getConstArray(), rLeftSeq.getLength()) == 0;
334 }
335 }
336 else if (isA(_rType, static_cast< Sequence<sal_uInt8>* >(NULL__null)))
337 {
338 Sequence<sal_uInt8> aTemp;
339 bConversionSuccess = _rValue >>= aTemp;
340 if (bConversionSuccess)
341 {
342 const Sequence<sal_uInt8>& rLeftSeq = *reinterpret_cast<const Sequence<sal_uInt8>*>(pData);
343 const Sequence<sal_uInt8>& rRightSeq = aTemp;
344 bRes = rLeftSeq.getLength() == rRightSeq.getLength() &&
345 memcmp(rLeftSeq.getConstArray(), rRightSeq.getConstArray(), rLeftSeq.getLength()) == 0;
346 }
347 }
348 else if (isA(_rType, static_cast< Sequence<sal_Int16>* >(NULL__null)))
349 {
350 Sequence<sal_Int16> aTemp;
351 bConversionSuccess = _rValue >>= aTemp;
352 if (bConversionSuccess)
353 {
354 const Sequence<sal_Int16>& rLeftSeq = *reinterpret_cast<const Sequence<sal_Int16>*>(pData);
355 const Sequence<sal_Int16>& rRightSeq = aTemp;
356 bRes = rLeftSeq.getLength() == rRightSeq.getLength() &&
357 memcmp(rLeftSeq.getConstArray(), rRightSeq.getConstArray(), rLeftSeq.getLength()*sizeof(sal_Int16)) == 0;
358 }
359 }
360 else if (isA(_rType, static_cast< Sequence<sal_uInt16>* >(NULL__null)))
361 {
362 Sequence<sal_uInt16> aTemp;
363 bConversionSuccess = _rValue >>= aTemp;
364 if (bConversionSuccess)
365 {
366 const Sequence<sal_uInt16>& rLeftSeq = *reinterpret_cast<const Sequence<sal_uInt16>*>(pData);
367 const Sequence<sal_uInt16>& rRightSeq = aTemp;
368 bRes = rLeftSeq.getLength() == rRightSeq.getLength() &&
369 memcmp(rLeftSeq.getConstArray(), rRightSeq.getConstArray(), rLeftSeq.getLength()*sizeof(sal_uInt16)) == 0;
370 }
371 }
372 else if (isA(_rType, static_cast< Sequence<sal_Int32>* >(NULL__null)))
373 {
374 Sequence<sal_Int32> aTemp;
375 bConversionSuccess = _rValue >>= aTemp;
376 if (bConversionSuccess)
377 {
378 const Sequence<sal_Int32>& rLeftSeq = *reinterpret_cast<const Sequence<sal_Int32>*>(pData);
379 const Sequence<sal_Int32>& rRightSeq = aTemp;
380 bRes = rLeftSeq.getLength() == rRightSeq.getLength() &&
381 memcmp(rLeftSeq.getConstArray(), rRightSeq.getConstArray(), rLeftSeq.getLength()*sizeof(sal_Int32)) == 0;
382 }
383 }
384 else if (isA(_rType, static_cast< Sequence<sal_uInt32>* >(NULL__null)))
385 {
386 Sequence<sal_uInt32> aTemp;
387 bConversionSuccess = _rValue >>= aTemp;
388 if (bConversionSuccess)
389 {
390 const Sequence<sal_uInt32>& rLeftSeq = *reinterpret_cast<const Sequence<sal_uInt32>*>(pData);
391 const Sequence<sal_uInt32>& rRightSeq = aTemp;
392 bRes = rLeftSeq.getLength() == rRightSeq.getLength() &&
393 memcmp(rLeftSeq.getConstArray(), rRightSeq.getConstArray(), rLeftSeq.getLength()*sizeof(sal_uInt32)) == 0;
394 }
395 }
396 else if (isA(_rType, static_cast< Sequence< ::rtl::OUString >* >(NULL__null)))
397 {
398 Sequence< ::rtl::OUString > aTemp;
399 bConversionSuccess = _rValue >>= aTemp;
400 if (bConversionSuccess)
401 {
402 const Sequence< ::rtl::OUString >& rLeftSeq = *reinterpret_cast<const Sequence< ::rtl::OUString>*>(pData);
403 const Sequence< ::rtl::OUString >& rRightSeq = aTemp;
404 sal_Int32 nSeqLen = rLeftSeq.getLength();
405 bRes = ( nSeqLen == rRightSeq.getLength() );
406 for ( sal_Int32 n = 0; bRes && ( n < nSeqLen ); n++ )
407 {
408 const ::rtl::OUString& rS1 = rLeftSeq.getConstArray()[n];
409 const ::rtl::OUString& rS2 = rRightSeq.getConstArray()[n];
410 bRes = ( rS1 == rS2 );
411 }
412 }
413 }
414 break;
415 default:
416 bRes = sal_False((sal_Bool)0);
417 }
418
419 bRes = bRes && bConversionSuccess;
420 }
421 return bRes;
422}
423
424//------------------------------------------------------------------------------
425sal_Bool compare(const Any& rLeft, const Any& rRight)
426{
427 return compare_impl(rLeft.getValueType(), rLeft.getValue(), rRight);
428}
429
430//-------------------------------------------------------------------------
431sal_Bool operator ==(const FontDescriptor& _rLeft, const FontDescriptor& _rRight)
432{
433 return ( _rLeft.Name.equals( _rRight.Name ) ) &&
434 ( _rLeft.Height == _rRight.Height ) &&
435 ( _rLeft.Width == _rRight.Width ) &&
436 ( _rLeft.StyleName.equals( _rRight.StyleName ) ) &&
437 ( _rLeft.Family == _rRight.Family ) &&
438 ( _rLeft.CharSet == _rRight.CharSet ) &&
439 ( _rLeft.Pitch == _rRight.Pitch ) &&
440 ( _rLeft.CharacterWidth == _rRight.CharacterWidth ) &&
441 ( _rLeft.Weight == _rRight.Weight ) &&
442 ( _rLeft.Slant == _rRight.Slant ) &&
443 ( _rLeft.Underline == _rRight.Underline ) &&
444 ( _rLeft.Strikeout == _rRight.Strikeout ) &&
445 ( _rLeft.Orientation == _rRight.Orientation ) &&
446 ( _rLeft.Kerning == _rRight.Kerning ) &&
447 ( _rLeft.WordLineMode == _rRight.WordLineMode ) &&
448 ( _rLeft.Type == _rRight.Type ) ;
449}
450
451//-------------------------------------------------------------------------
452Type getSequenceElementType(const Type& _rSequenceType)
453{
454 OSL_ENSURE(_rSequenceType.getTypeClass() == TypeClass_SEQUENCE,do { if (true && (!(_rSequenceType.getTypeClass() == TypeClass_SEQUENCE
))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"
), ("/usr/local/src/libreoffice/comphelper/source/misc/types.cxx"
":" "455" ": "), "%s", "getSequenceElementType: must be called with a sequence type!"
); } } while (false)
455 "getSequenceElementType: must be called with a sequence type!")do { if (true && (!(_rSequenceType.getTypeClass() == TypeClass_SEQUENCE
))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"
), ("/usr/local/src/libreoffice/comphelper/source/misc/types.cxx"
":" "455" ": "), "%s", "getSequenceElementType: must be called with a sequence type!"
); } } while (false);
456
457 if (!(_rSequenceType.getTypeClass() == TypeClass_SEQUENCE))
1
Taking false branch
→
458 return Type();
459
460 TypeDescription aTD(_rSequenceType);
461 typelib_IndirectTypeDescription* pSequenceTD =
462 reinterpret_cast< typelib_IndirectTypeDescription* >(aTD.get());
463
464 OSL_ASSERT(pSequenceTD)do { if (true && (!(pSequenceTD))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/usr/local/src/libreoffice/comphelper/source/misc/types.cxx"
":" "464" ": "), "OSL_ASSERT: %s", "pSequenceTD"); } } while
(false);
465 OSL_ASSERT(pSequenceTD->pType)do { if (true && (!(pSequenceTD->pType))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/usr/local/src/libreoffice/comphelper/source/misc/types.cxx"
":" "465" ": "), "OSL_ASSERT: %s", "pSequenceTD->pType");
} } while (false);
2
←
Within the expansion of the macro 'OSL_ASSERT':
a
Access to field 'pType' results in a dereference of a null pointer (loaded from variable 'pSequenceTD')
466
467 if (pSequenceTD && pSequenceTD->pType)
468 return Type(pSequenceTD->pType);
469
470 return Type();
471}
472//.........................................................................
473} // namespace comphelper
474//.........................................................................
475
476/* vim:set shiftwidth=4 softtabstop=4 expandtab: */