return p;
}
-#if defined(qMemCopy)
-# undef qMemCopy
-#endif
-#if defined(qMemSet)
-# undef qMemSet
-#endif
-
-void *qMemCopy(void *dest, const void *src, size_t n) { return memcpy(dest, src, n); }
-void *qMemSet(void *dest, int c, size_t n) { return memset(dest, c, n); }
-
static QtMsgHandler handler = 0; // pointer to debug handler
#if defined(Q_CC_MWERKS) && defined(Q_OS_MACX)
return false;
}
+void *qMallocAligned(size_t size, size_t alignment)
+{
+ return qReallocAligned(0, size, 0, alignment);
+}
+
+void *qReallocAligned(void *oldptr, size_t newsize, size_t oldsize, size_t alignment)
+{
+ // fake an aligned allocation
+ Q_UNUSED(oldsize);
+
+ void *actualptr = oldptr ? static_cast<void **>(oldptr)[-1] : 0;
+ if (alignment <= sizeof(void*)) {
+ // special, fast case
+ void **newptr = static_cast<void **>(qRealloc(actualptr, newsize + sizeof(void*)));
+ if (!newptr)
+ return 0;
+ if (newptr == actualptr) {
+ // realloc succeeded without reallocating
+ return oldptr;
+ }
+
+ *newptr = newptr;
+ return newptr + 1;
+ }
+
+ // qMalloc returns pointers aligned at least at sizeof(size_t) boundaries
+ // but usually more (8- or 16-byte boundaries).
+ // So we overallocate by alignment-sizeof(size_t) bytes, so we're guaranteed to find a
+ // somewhere within the first alignment-sizeof(size_t) that is properly aligned.
+
+ // However, we need to store the actual pointer, so we need to allocate actually size +
+ // alignment anyway.
+
+ void *real = qRealloc(actualptr, newsize + alignment);
+ if (!real)
+ return 0;
+
+ quintptr faked = reinterpret_cast<quintptr>(real) + alignment;
+ faked &= ~(alignment - 1);
+
+ void **faked_ptr = reinterpret_cast<void **>(faked);
+
+ // now save the value of the real pointer at faked-sizeof(void*)
+ // by construction, alignment > sizeof(void*) and is a power of 2, so
+ // faked-sizeof(void*) is properly aligned for a pointer
+ faked_ptr[-1] = real;
+
+ return faked_ptr;
+}
+
+void qFreeAligned(void *ptr)
+{
+ if (!ptr)
+ return;
+ void **ptr2 = static_cast<void **>(ptr);
+ free(ptr2[-1]);
+}
+
/*!
\macro Q_BYTE_ORDER
\relates <QtGlobal>
#include <qconfig.h>
#include <stddef.h>
+#include <stdlib.h>
+#include <string.h>
#define QT_VERSION_STR "4.8.7"
/*
value1 = value2;
value2 = t;
#else
- using std::swap;
- swap(value1, value2);
+ std::swap(value1, value2);
#endif
}
These functions make it possible to use standard C++ functions with
a similar name from Qt header files (especially template classes).
*/
-Q_CORE_EXPORT void *qMalloc(size_t size);
-Q_CORE_EXPORT void qFree(void *ptr);
-Q_CORE_EXPORT void *qRealloc(void *ptr, size_t size);
+Q_CORE_EXPORT_INLINE void *qMalloc(size_t size) { return ::malloc(size); }
+Q_CORE_EXPORT_INLINE void qFree(void *ptr) { ::free(ptr); }
+Q_CORE_EXPORT_INLINE void *qRealloc(void *ptr, size_t size) { return ::realloc(ptr, size); }
+Q_CORE_EXPORT_INLINE void *qMemCopy(void *dest, const void *src, size_t n) { return memcpy(dest, src, n); }
+Q_CORE_EXPORT_INLINE void *qMemSet(void *dest, int c, size_t n) { return memset(dest, c, n); }
Q_CORE_EXPORT void *qMallocAligned(size_t size, size_t alignment);
Q_CORE_EXPORT void *qReallocAligned(void *ptr, size_t size, size_t oldsize, size_t alignment);
Q_CORE_EXPORT void qFreeAligned(void *ptr);
-Q_CORE_EXPORT void *qMemCopy(void *dest, const void *src, size_t n);
-Q_CORE_EXPORT void *qMemSet(void *dest, int c, size_t n);
/*
+++ /dev/null
-/****************************************************************************
-**
-** Copyright (C) 2015 The Qt Company Ltd.
-** Contact: http://www.qt.io/licensing/
-**
-** This file is part of the QtCore module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see http://www.qt.io/terms-conditions. For further
-** information use the contact form at http://www.qt.io/contact-us.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 2.1 or version 3 as published by the Free
-** Software Foundation and appearing in the file LICENSE.LGPLv21 and
-** LICENSE.LGPLv3 included in the packaging of this file. Please review the
-** following information to ensure the GNU Lesser General Public License
-** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
-** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
-**
-** As a special exception, The Qt Company gives you certain additional
-** rights. These rights are described in The Qt Company LGPL Exception
-** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 3.0 as published by the Free Software
-** Foundation and appearing in the file LICENSE.GPL included in the
-** packaging of this file. Please review the following information to
-** ensure the GNU General Public License version 3.0 requirements will be
-** met: http://www.gnu.org/copyleft/gpl.html.
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#include "qplatformdefs.h"
-
-#include <stdlib.h>
-
-/*
- Define the container allocation functions in a separate file, so that our
- users can easily override them.
-*/
-
-QT_BEGIN_NAMESPACE
-
-void *qMalloc(size_t size)
-{
- return ::malloc(size);
-}
-
-void qFree(void *ptr)
-{
- ::free(ptr);
-}
-
-void *qRealloc(void *ptr, size_t size)
-{
- return ::realloc(ptr, size);
-}
-
-void *qMallocAligned(size_t size, size_t alignment)
-{
- return qReallocAligned(0, size, 0, alignment);
-}
-
-void *qReallocAligned(void *oldptr, size_t newsize, size_t oldsize, size_t alignment)
-{
- // fake an aligned allocation
- Q_UNUSED(oldsize);
-
- void *actualptr = oldptr ? static_cast<void **>(oldptr)[-1] : 0;
- if (alignment <= sizeof(void*)) {
- // special, fast case
- void **newptr = static_cast<void **>(qRealloc(actualptr, newsize + sizeof(void*)));
- if (!newptr)
- return 0;
- if (newptr == actualptr) {
- // realloc succeeded without reallocating
- return oldptr;
- }
-
- *newptr = newptr;
- return newptr + 1;
- }
-
- // qMalloc returns pointers aligned at least at sizeof(size_t) boundaries
- // but usually more (8- or 16-byte boundaries).
- // So we overallocate by alignment-sizeof(size_t) bytes, so we're guaranteed to find a
- // somewhere within the first alignment-sizeof(size_t) that is properly aligned.
-
- // However, we need to store the actual pointer, so we need to allocate actually size +
- // alignment anyway.
-
- void *real = qRealloc(actualptr, newsize + alignment);
- if (!real)
- return 0;
-
- quintptr faked = reinterpret_cast<quintptr>(real) + alignment;
- faked &= ~(alignment - 1);
-
- void **faked_ptr = reinterpret_cast<void **>(faked);
-
- // now save the value of the real pointer at faked-sizeof(void*)
- // by construction, alignment > sizeof(void*) and is a power of 2, so
- // faked-sizeof(void*) is properly aligned for a pointer
- faked_ptr[-1] = real;
-
- return faked_ptr;
-}
-
-void qFreeAligned(void *ptr)
-{
- if (!ptr)
- return;
- void **ptr2 = static_cast<void **>(ptr);
- free(ptr2[-1]);
-}
-
-QT_END_NAMESPACE
-
OSDN Git Service
