/****************************************************************************

**

** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the QtCore module of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** GNU Lesser General Public License Usage

** This file may be used under the terms of the GNU Lesser General Public

** License version 2.1 as published by the Free Software Foundation and

** appearing in the file LICENSE.LGPL included in the packaging of this

** file. Please review the following information to ensure the GNU Lesser

** General Public License version 2.1 requirements will be met:

** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights. These rights are described in the Nokia Qt 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.

**

** Other Usage

** Alternatively, this file may be used in accordance with the terms and

** conditions contained in a signed written agreement between you and Nokia.

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include "qplatformdefs.h"

#include "qstring.h"

#include "qvector.h"

#include "qlist.h"

#include "qthreadstorage.h"

#include "qdir.h"

#include "qstringlist.h"

#include "qdatetime.h"

#ifndef QT_NO_QOBJECT

#include <private/qthread_p.h>

#endif

#include <stdio.h>

#include <stdlib.h>

#include <limits.h>

#include <stdarg.h>

#include <string.h>

#ifndef QT_NO_EXCEPTIONS

#  include <string>

#  include <exception>

#endif

#if !defined(Q_OS_WINCE)

#  include <errno.h>

#  if defined(Q_CC_MSVC)

#    include <crtdbg.h>

#  endif

#endif

#if defined(Q_OS_VXWORKS)

#  include <envLib.h>

#endif

#if defined(Q_OS_MACX) && !defined(QT_NO_CORESERVICES)

#include <CoreServices/CoreServices.h>

#endif

#if defined(Q_OS_SYMBIAN)

#include <e32def.h>

#include <e32debug.h>

#include <f32file.h>

#include <e32math.h>

# include "private/qcore_symbian_p.h"

_LIT(qt_S60Filter, "Series60v?.*.sis");

_LIT(qt_symbianSystemInstallDir, "z:\\system\\install\\");

#endif

QT_BEGIN_NAMESPACE

/*!

    \class QFlag

    \brief The QFlag class is a helper data type for QFlags.

    It is equivalent to a plain \c int, except with respect to

    function overloading and type conversions. You should never need

    to use this class in your applications.

    \sa QFlags

*/

/*!

    \fn QFlag::QFlag(int value)

    Constructs a QFlag object that stores the given \a value.

*/

/*!

    \fn QFlag::operator int() const

    Returns the value stored by the QFlag object.

*/

/*!

    \class QFlags

    \brief The QFlags class provides a type-safe way of storing

    OR-combinations of enum values.

    \ingroup tools

    The QFlags<Enum> class is a template class, where Enum is an enum

    type. QFlags is used throughout Qt for storing combinations of

    enum values.

    The traditional C++ approach for storing OR-combinations of enum

    values is to use an \c int or \c uint variable. The inconvenience

    with this approach is that there's no type checking at all; any

    enum value can be OR'd with any other enum value and passed on to

    a function that takes an \c int or \c uint.

    Qt uses QFlags to provide type safety. For example, the

    Qt::Alignment type is simply a typedef for

    QFlags<Qt::AlignmentFlag>. QLabel::setAlignment() takes a

    Qt::Alignment parameter, which means that any combination of

    Qt::AlignmentFlag values,or 0, is legal:

    \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp 0

    If you try to pass a value from another enum or just a plain

    integer other than 0, the compiler will report an error. If you

    need to cast integer values to flags in a untyped fashion, you can

    use the explicit QFlags constructor as cast operator.

    If you want to use QFlags for your own enum types, use

    the Q_DECLARE_FLAGS() and Q_DECLARE_OPERATORS_FOR_FLAGS().

    Example:

    \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp 1

    You can then use the \c MyClass::Options type to store

    combinations of \c MyClass::Option values.

    \section1 Flags and the Meta-Object System

    The Q_DECLARE_FLAGS() macro does not expose the flags to the meta-object

    system, so they cannot be used by Qt Script or edited in Qt Designer.

    To make the flags available for these purposes, the Q_FLAGS() macro must

    be used:

    \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp meta-object flags

    \section1 Naming Convention

    A sensible naming convention for enum types and associated QFlags

    types is to give a singular name to the enum type (e.g., \c

    Option) and a plural name to the QFlags type (e.g., \c Options).

    When a singular name is desired for the QFlags type (e.g., \c

    Alignment), you can use \c Flag as the suffix for the enum type

    (e.g., \c AlignmentFlag).

    \sa QFlag

*/

/*!

    \typedef QFlags::enum_type

    Typedef for the Enum template type.

*/

/*!

    \fn QFlags::QFlags(const QFlags &other)

    Constructs a copy of \a other.

*/

/*!

    \fn QFlags::QFlags(Enum flag)

    Constructs a QFlags object storing the given \a flag.

*/

/*!

    \fn QFlags::QFlags(Zero zero)

    Constructs a QFlags object with no flags set. \a zero must be a

    literal 0 value.

*/

/*!

    \fn QFlags::QFlags(QFlag value)

    Constructs a QFlags object initialized with the given integer \a

    value.

    The QFlag type is a helper type. By using it here instead of \c

    int, we effectively ensure that arbitrary enum values cannot be

    cast to a QFlags, whereas untyped enum values (i.e., \c int

    values) can.

*/

/*!

    \fn QFlags &QFlags::operator=(const QFlags &other)

    Assigns \a other to this object and returns a reference to this

    object.

*/

/*!

    \fn QFlags &QFlags::operator&=(int mask)

    Performs a bitwise AND operation with \a mask and stores the

    result in this QFlags object. Returns a reference to this object.

    \sa operator&(), operator|=(), operator^=()

*/

/*!

    \fn QFlags &QFlags::operator&=(uint mask)

    \overload

*/

/*!

    \fn QFlags &QFlags::operator|=(QFlags other)

    Performs a bitwise OR operation with \a other and stores the

    result in this QFlags object. Returns a reference to this object.

    \sa operator|(), operator&=(), operator^=()

*/

/*!

    \fn QFlags &QFlags::operator|=(Enum other)

    \overload

*/

/*!

    \fn QFlags &QFlags::operator^=(QFlags other)

    Performs a bitwise XOR operation with \a other and stores the

    result in this QFlags object. Returns a reference to this object.

    \sa operator^(), operator&=(), operator|=()

*/

/*!

    \fn QFlags &QFlags::operator^=(Enum other)

    \overload

*/

/*!

    \fn QFlags::operator int() const

    Returns the value stored in the QFlags object as an integer.

*/

/*!

    \fn QFlags QFlags::operator|(QFlags other) const

    Returns a QFlags object containing the result of the bitwise OR

    operation on this object and \a other.

    \sa operator|=(), operator^(), operator&(), operator~()

*/

/*!

    \fn QFlags QFlags::operator|(Enum other) const

    \overload

*/

/*!

    \fn QFlags QFlags::operator^(QFlags other) const

    Returns a QFlags object containing the result of the bitwise XOR

    operation on this object and \a other.

    \sa operator^=(), operator&(), operator|(), operator~()

*/

/*!

    \fn QFlags QFlags::operator^(Enum other) const

    \overload

*/

/*!

    \fn QFlags QFlags::operator&(int mask) const

    Returns a QFlags object containing the result of the bitwise AND

    operation on this object and \a mask.

    \sa operator&=(), operator|(), operator^(), operator~()

*/

/*!

    \fn QFlags QFlags::operator&(uint mask) const

    \overload

*/

/*!

    \fn QFlags QFlags::operator&(Enum mask) const

    \overload

*/

/*!

    \fn QFlags QFlags::operator~() const

    Returns a QFlags object that contains the bitwise negation of

    this object.

    \sa operator&(), operator|(), operator^()

*/

/*!

    \fn bool QFlags::operator!() const

    Returns true if no flag is set (i.e., if the value stored by the

    QFlags object is 0); otherwise returns false.

*/

/*!

    \fn bool QFlags::testFlag(Enum flag) const

    \since 4.2

    Returns true if the \a flag is set, otherwise false.

*/

/*!

  \macro Q_DISABLE_COPY(Class)

  \relates QObject

  Disables the use of copy constructors and assignment operators

  for the given \a Class.

  Instances of subclasses of QObject should not be thought of as

  values that can be copied or assigned, but as unique identities.

  This means that when you create your own subclass of QObject

  (director or indirect), you should \e not give it a copy constructor

  or an assignment operator.  However, it may not enough to simply

  omit them from your class, because, if you mistakenly write some code

  that requires a copy constructor or an assignment operator (it's easy

  to do), your compiler will thoughtfully create it for you. You must

  do more.

  The curious user will have seen that the Qt classes derived

  from QObject typically include this macro in a private section:

  \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp 43

  It declares a copy constructor and an assignment operator in the

  private section, so that if you use them by mistake, the compiler

  will report an error.

  \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp 44

  But even this might not catch absolutely every case. You might be

  tempted to do something like this:

  \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp 45

  First of all, don't do that. Most compilers will generate code that

  uses the copy constructor, so the privacy violation error will be

  reported, but your C++ compiler is not required to generate code for

  this statement in a specific way. It could generate code using

  \e{neither} the copy constructor \e{nor} the assignment operator we

  made private. In that case, no error would be reported, but your

  application would probably crash when you called a member function

  of \c{w}.

*/

/*!

    \macro Q_DECLARE_FLAGS(Flags, Enum)

    \relates QFlags

    The Q_DECLARE_FLAGS() macro expands to

    \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp 2

    \a Enum is the name of an existing enum type, whereas \a Flags is

    the name of the QFlags<\e{Enum}> typedef.

    See the QFlags documentation for details.

    \sa Q_DECLARE_OPERATORS_FOR_FLAGS()

*/

/*!

    \macro Q_DECLARE_OPERATORS_FOR_FLAGS(Flags)

    \relates QFlags

    The Q_DECLARE_OPERATORS_FOR_FLAGS() macro declares global \c

    operator|() functions for \a Flags, which is of type QFlags<T>.

    See the QFlags documentation for details.

    \sa Q_DECLARE_FLAGS()

*/

/*!

    \headerfile <QtGlobal>

    \title Global Qt Declarations

    \ingroup funclists

    \brief The <QtGlobal> header file includes the fundamental global

    declarations. It is included by most other Qt header files.

    The global declarations include \l{types}, \l{functions} and

    \l{macros}.

    The type definitions are partly convenience definitions for basic

    types (some of which guarantee certain bit-sizes on all platforms

    supported by Qt), partly types related to Qt message handling. The

    functions are related to generating messages, Qt version handling

    and comparing and adjusting object values. And finally, some of

    the declared macros enable programmers to add compiler or platform

    specific code to their applications, while others are convenience

    macros for larger operations.

    \section1 Types

    The header file declares several type definitions that guarantee a

    specified bit-size on all platforms supported by Qt for various

    basic types, for example \l qint8 which is a signed char

    guaranteed to be 8-bit on all platforms supported by Qt. The

    header file also declares the \l qlonglong type definition for \c

    {long long int } (\c __int64 on Windows).

    Several convenience type definitions are declared: \l qreal for \c

    double, \l uchar for \c unsigned char, \l uint for \c unsigned

    int, \l ulong for \c unsigned long and \l ushort for \c unsigned

    short.

    Finally, the QtMsgType definition identifies the various messages

    that can be generated and sent to a Qt message handler;

    QtMsgHandler is a type definition for a pointer to a function with

    the signature \c {void myMsgHandler(QtMsgType, const char *)}.

    \section1 Functions

    The <QtGlobal> header file contains several functions comparing

    and adjusting an object's value. These functions take a template

    type as argument: You can retrieve the absolute value of an object

    using the qAbs() function, and you can bound a given object's

    value by given minimum and maximum values using the qBound()

    function. You can retrieve the minimum and maximum of two given

    objects using qMin() and qMax() respectively. All these functions

    return a corresponding template type; the template types can be

    replaced by any other type.

    Example:

    \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp 3

    <QtGlobal> also contains functions that generate messages from the

    given string argument: qCritical(), qDebug(), qFatal() and

    qWarning(). These functions call the message handler with the

    given message.

    Example:

    \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp 4

    The remaining functions are qRound() and qRound64(), which both

    accept a \l qreal value as their argument returning the value

    rounded up to the nearest integer and 64-bit integer respectively,

    the qInstallMsgHandler() function which installs the given

    QtMsgHandler, and the qVersion() function which returns the

    version number of Qt at run-time as a string.

    \section1 Macros

    The <QtGlobal> header file provides a range of macros (Q_CC_*)

    that are defined if the application is compiled using the

    specified platforms. For example, the Q_CC_SUN macro is defined if

    the application is compiled using Forte Developer, or Sun Studio

    C++.  The header file also declares a range of macros (Q_OS_*)

    that are defined for the specified platforms. For example,

    Q_OS_X11 which is defined for the X Window System.

    The purpose of these macros is to enable programmers to add

    compiler or platform specific code to their application.

    The remaining macros are convenience macros for larger operations:

    The QT_TRANSLATE_NOOP() and QT_TR_NOOP() macros provide the

    possibility of marking text for dynamic translation,

    i.e. translation without changing the stored source text. The

    Q_ASSERT() and Q_ASSERT_X() enables warning messages of various

    level of refinement. The Q_FOREACH() and foreach() macros

    implement Qt's foreach loop.

    The Q_INT64_C() and Q_UINT64_C() macros wrap signed and unsigned

    64-bit integer literals in a platform-independent way. The

    Q_CHECK_PTR() macro prints a warning containing the source code's

    file name and line number, saying that the program ran out of

    memory, if the pointer is 0. The qPrintable() macro represent an

    easy way of printing text.

    Finally, the QT_POINTER_SIZE macro expands to the size of a

    pointer in bytes, and the QT_VERSION and QT_VERSION_STR macros

    expand to a numeric value or a string, respectively, specifying

    Qt's version number, i.e the version the application is compiled

    against.

    \sa <QtAlgorithms>, QSysInfo

*/

/*!

    \typedef qreal

    \relates <QtGlobal>

    Typedef for \c double on all platforms except for those using CPUs with

    ARM architectures.

    On ARM-based platforms, \c qreal is a typedef for \c float for performance

    reasons.

*/

/*! \typedef uchar

    \relates <QtGlobal>

    Convenience typedef for \c{unsigned char}.

*/

/*!

    \fn qt_set_sequence_auto_mnemonic(bool on)

    \relates <QtGlobal>

    Enables automatic mnemonics on Mac if \a on is true; otherwise

    this feature is disabled.

    Note that this function is only available on Mac where mnemonics

    are disabled by default.

    To access to this function, use an extern declaration:

    extern void qt_set_sequence_auto_mnemonic(bool b);

    \sa {QShortcut#mnemonic}{QShortcut}

*/

/*! \typedef ushort

    \relates <QtGlobal>

    Convenience typedef for \c{unsigned short}.

*/

/*! \typedef uint

    \relates <QtGlobal>

    Convenience typedef for \c{unsigned int}.

*/

/*! \typedef ulong

    \relates <QtGlobal>

    Convenience typedef for \c{unsigned long}.

*/

/*! \typedef qint8

    \relates <QtGlobal>

    Typedef for \c{signed char}. This type is guaranteed to be 8-bit

    on all platforms supported by Qt.

*/

/*!

    \typedef quint8

    \relates <QtGlobal>

    Typedef for \c{unsigned char}. This type is guaranteed to

    be 8-bit on all platforms supported by Qt.

*/

/*! \typedef qint16

    \relates <QtGlobal>

    Typedef for \c{signed short}. This type is guaranteed to be

    16-bit on all platforms supported by Qt.

*/

/*!

    \typedef quint16

    \relates <QtGlobal>

    Typedef for \c{unsigned short}. This type is guaranteed to

    be 16-bit on all platforms supported by Qt.

*/

/*! \typedef qint32

    \relates <QtGlobal>

    Typedef for \c{signed int}. This type is guaranteed to be 32-bit

    on all platforms supported by Qt.

*/

/*!

    \typedef quint32

    \relates <QtGlobal>

    Typedef for \c{unsigned int}. This type is guaranteed to

    be 32-bit on all platforms supported by Qt.

*/

/*! \typedef qint64

    \relates <QtGlobal>

    Typedef for \c{long long int} (\c __int64 on Windows). This type

    is guaranteed to be 64-bit on all platforms supported by Qt.

    Literals of this type can be created using the Q_INT64_C() macro:

    \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp 5

    \sa Q_INT64_C(), quint64, qlonglong

*/

/*!

    \typedef quint64

    \relates <QtGlobal>

    Typedef for \c{unsigned long long int} (\c{unsigned __int64} on

    Windows). This type is guaranteed to be 64-bit on all platforms

    supported by Qt.

    Literals of this type can be created using the Q_UINT64_C()

    macro:

    \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp 6

    \sa Q_UINT64_C(), qint64, qulonglong

*/

/*!

    \typedef quintptr

    \relates <QtGlobal>

    Integral type for representing a pointers (useful for hashing,

    etc.).

    Typedef for either quint32 or quint64. This type is guaranteed to

    be the same size as a pointer on all platforms supported by Qt. On

    a system with 32-bit pointers, quintptr is a typedef for quint32;

    on a system with 64-bit pointers, quintptr is a typedef for

    quint64.

    Note that quintptr is unsigned. Use qptrdiff for signed values.

    \sa qptrdiff, quint32, quint64

*/

/*!

    \typedef qptrdiff

    \relates <QtGlobal>

    Integral type for representing pointer differences.

    Typedef for either qint32 or qint64. This type is guaranteed to be

    the same size as a pointer on all platforms supported by Qt. On a

    system with 32-bit pointers, quintptr is a typedef for quint32; on

    a system with 64-bit pointers, quintptr is a typedef for quint64.

    Note that qptrdiff is signed. Use quintptr for unsigned values.

    \sa quintptr, qint32, qint64

*/

/*!

    \typedef QtMsgHandler

    \relates <QtGlobal>

    This is a typedef for a pointer to a function with the following

    signature:

    \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp 7

    \sa QtMsgType, qInstallMsgHandler()

*/

/*!

    \enum QtMsgType

    \relates <QtGlobal>

    This enum describes the messages that can be sent to a message

    handler (QtMsgHandler). You can use the enum to identify and

    associate the various message types with the appropriate

    actions.

    \value QtDebugMsg

           A message generated by the qDebug() function.

    \value QtWarningMsg

           A message generated by the qWarning() function.

    \value QtCriticalMsg

           A message generated by the qCritical() function.

    \value QtFatalMsg

           A message generated by the qFatal() function.

    \value QtSystemMsg

    \sa QtMsgHandler, qInstallMsgHandler()

*/

/*! \macro qint64 Q_INT64_C(literal)

    \relates <QtGlobal>

    Wraps the signed 64-bit integer \a literal in a

    platform-independent way.

    Example:

    \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp 8

    \sa qint64, Q_UINT64_C()

*/

/*! \macro quint64 Q_UINT64_C(literal)

    \relates <QtGlobal>

    Wraps the unsigned 64-bit integer \a literal in a

    platform-independent way.

    Example:

    \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp 9

    \sa quint64, Q_INT64_C()

*/

/*! \typedef qlonglong

    \relates <QtGlobal>

    Typedef for \c{long long int} (\c __int64 on Windows). This is

    the same as \l qint64.

    \sa qulonglong, qint64

*/

/*!

    \typedef qulonglong

    \relates <QtGlobal>

    Typedef for \c{unsigned long long int} (\c{unsigned __int64} on

    Windows). This is the same as \l quint64.

    \sa quint64, qlonglong

*/

/*! \fn const T &qAbs(const T &value)

    \relates <QtGlobal>

    Compares \a value to the 0 of type T and returns the absolute

    value. Thus if T is \e {double}, then \a value is compared to

    \e{(double) 0}.

    Example:

    \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp 10

*/

/*! \fn int qRound(qreal value)

    \relates <QtGlobal>

    Rounds \a value to the nearest integer.

    Example:

    \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp 11

*/

/*! \fn qint64 qRound64(qreal value)

    \relates <QtGlobal>

    Rounds \a value to the nearest 64-bit integer.

    Example:

    \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp 12

*/

/*! \fn const T &qMin(const T &value1, const T &value2)

    \relates <QtGlobal>

    Returns the minimum of \a value1 and \a value2.

    Example:

    \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp 13

    \sa qMax(), qBound()

*/

/*! \fn const T &qMax(const T &value1, const T &value2)

    \relates <QtGlobal>

    Returns the maximum of \a value1 and \a value2.

    Example:

    \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp 14

    \sa qMin(), qBound()

*/

/*! \fn const T &qBound(const T &min, const T &value, const T &max)

    \relates <QtGlobal>

    Returns \a value bounded by \a min and \a max. This is equivalent

    to qMax(\a min, qMin(\a value, \a max)).

    Example:

    \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp 15

    \sa qMin(), qMax()

*/

/*!

    \typedef Q_INT8

    \relates <QtGlobal>

    \compat

    Use \l qint8 instead.

*/

/*!

    \typedef Q_UINT8

    \relates <QtGlobal>

    \compat

    Use \l quint8 instead.

*/

/*!

    \typedef Q_INT16

    \relates <QtGlobal>

    \compat

    Use \l qint16 instead.

*/

/*!

    \typedef Q_UINT16

    \relates <QtGlobal>

    \compat

    Use \l quint16 instead.

*/

/*!

    \typedef Q_INT32

    \relates <QtGlobal>

    \compat

    Use \l qint32 instead.

*/

/*!

    \typedef Q_UINT32

    \relates <QtGlobal>

    \compat

    Use \l quint32 instead.

*/

/*!

    \typedef Q_INT64

    \relates <QtGlobal>

    \compat

    Use \l qint64 instead.

*/

/*!

    \typedef Q_UINT64

    \relates <QtGlobal>

    \compat

    Use \l quint64 instead.

*/

/*!

    \typedef Q_LLONG

    \relates <QtGlobal>

    \compat

    Use \l qint64 instead.

*/

/*!

    \typedef Q_ULLONG

    \relates <QtGlobal>

    \compat

    Use \l quint64 instead.

*/

/*!

    \typedef Q_LONG

    \relates <QtGlobal>

    \compat

    Use \c{void *} instead.

*/

/*!

    \typedef Q_ULONG

    \relates <QtGlobal>

    \compat

    Use \c{void *} instead.

*/

/*! \fn bool qSysInfo(int *wordSize, bool *bigEndian)

    \relates <QtGlobal>

    Use QSysInfo::WordSize and QSysInfo::ByteOrder instead.

*/

/*!

    \fn bool qt_winUnicode()

    \relates <QtGlobal>

    This function always returns true.

    \sa QSysInfo

*/

/*!

    \fn int qWinVersion()

    \relates <QtGlobal>

    Use QSysInfo::WindowsVersion instead.

    \sa QSysInfo

*/

/*!

    \fn int qMacVersion()

    \relates <QtGlobal>

    Use QSysInfo::MacintoshVersion instead.

    \sa QSysInfo

*/

/*!

    \macro QT_VERSION_CHECK

    \relates <QtGlobal>

    Turns the major, minor and patch numbers of a version into an

    integer, 0xMMNNPP (MM = major, NN = minor, PP = patch). This can

    be compared with another similarly processed version id.

    \sa QT_VERSION

*/

/*!

    \macro QT_VERSION

    \relates <QtGlobal>

    This macro expands a numeric value of the form 0xMMNNPP (MM =

    major, NN = minor, PP = patch) that specifies Qt's version

    number. For example, if you compile your application against Qt

    4.1.2, the QT_VERSION macro will expand to 0x040102.

    You can use QT_VERSION to use the latest Qt features where

    available.

    Example:

    \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp 16

    \sa QT_VERSION_STR, qVersion()

*/

/*!

    \macro QT_VERSION_STR

    \relates <QtGlobal>

    This macro expands to a string that specifies Qt's version number

    (for example, "4.1.2"). This is the version against which the

    application is compiled.

    \sa qVersion(), QT_VERSION

*/

/*!

    \relates <QtGlobal>

    Returns the version number of Qt at run-time as a string (for

    example, "4.1.2"). This may be a different version than the

    version the application was compiled against.

    \sa QT_VERSION_STR

*/

const char *qVersion()

{

    return QT_VERSION_STR;

}

bool qSharedBuild()

{

#ifdef QT_SHARED

    return true;

#else

    return false;

#endif

}

/*****************************************************************************

  System detection routines

 *****************************************************************************/

/*!

    \class QSysInfo

    \brief The QSysInfo class provides information about the system.

    \list

    \o \l WordSize specifies the size of a pointer for the platform

       on which the application is compiled.

    \o \l ByteOrder specifies whether the platform is big-endian or

       little-endian.

    \o \l WindowsVersion specifies the version of the Windows operating

       system on which the application is run (Windows only)

    \o \l MacintoshVersion specifies the version of the Macintosh

       operating system on which the application is run (Mac only).

    \endlist

    Some constants are defined only on certain platforms. You can use

    the preprocessor symbols Q_WS_WIN and Q_WS_MAC to test that

    the application is compiled under Windows or Mac.

    \sa QLibraryInfo

*/

/*!

    \enum QSysInfo::Sizes

    This enum provides platform-specific information about the sizes of data

    structures used by the underlying architecture.

    \value WordSize The size in bits of a pointer for the platform on which

           the application is compiled (32 or 64).

*/

/*!

    \variable QSysInfo::WindowsVersion

    \brief the version of the Windows operating system on which the

           application is run (Windows only)

*/

/*!

    \fn QSysInfo::WindowsVersion QSysInfo::windowsVersion()

    \since 4.4

    Returns the version of the Windows operating system on which the

    application is run (Windows only).

*/

/*!

    \variable QSysInfo::MacintoshVersion

    \brief the version of the Macintosh operating system on which

           the application is run (Mac only).

*/

/*!

    \fn QSysInfo::SymbianVersion QSysInfo::symbianVersion()

    \since 4.6

    Returns the version of the Symbian operating system on which the

    application is run (Symbian only).

*/

/*!

    \fn QSysInfo::S60Version QSysInfo::s60Version()

    \since 4.6

    Returns the version of the S60 SDK system on which the

    application is run (S60 only).

*/

/*!

    \enum QSysInfo::Endian

    \value BigEndian  Big-endian byte order (also called Network byte order)

    \value LittleEndian  Little-endian byte order

    \value ByteOrder  Equals BigEndian or LittleEndian, depending on

                      the platform's byte order.

*/

/*!

    \enum QSysInfo::WinVersion

    This enum provides symbolic names for the various versions of the

    Windows operating system. On Windows, the

    QSysInfo::WindowsVersion variable gives the version of the system

    on which the application is run.

    MS-DOS-based versions:

    \value WV_32s   Windows 3.1 with Win 32s

    \value WV_95    Windows 95

    \value WV_98    Windows 98

    \value WV_Me    Windows Me

    NT-based versions (note that each operating system version is only represented once rather than each Windows edition):

    \value WV_NT    Windows NT (operating system version 4.0)

    \value WV_2000  Windows 2000 (operating system version 5.0)

    \value WV_XP    Windows XP (operating system version 5.1)

    \value WV_2003  Windows Server 2003, Windows Server 2003 R2, Windows Home Server, Windows XP Professional x64 Edition (operating system version 5.2)

    \value WV_VISTA Windows Vista, Windows Server 2008 (operating system version 6.0)

    \value WV_WINDOWS7 Windows 7, Windows Server 2008 R2 (operating system version 6.1)

    Alternatively, you may use the following macros which correspond directly to the Windows operating system version number:

    \value WV_4_0   Operating system version 4.0, corresponds to Windows NT

    \value WV_5_0   Operating system version 5.0, corresponds to Windows 2000

    \value WV_5_1   Operating system version 5.1, corresponds to Windows XP

    \value WV_5_2   Operating system version 5.2, corresponds to Windows Server 2003, Windows Server 2003 R2, Windows Home Server, and Windows XP Professional x64 Edition

    \value WV_6_0   Operating system version 6.0, corresponds to Windows Vista and Windows Server 2008

    \value WV_6_1   Operating system version 6.1, corresponds to Windows 7 and Windows Server 2008 R2

    CE-based versions:

    \value WV_CE    Windows CE

    \value WV_CENET Windows CE .NET

    \value WV_CE_5  Windows CE 5.x

    \value WV_CE_6  Windows CE 6.x

    The following masks can be used for testing whether a Windows

    version is MS-DOS-based, NT-based, or CE-based:

    \value WV_DOS_based MS-DOS-based version of Windows

    \value WV_NT_based  NT-based version of Windows

    \value WV_CE_based  CE-based version of Windows

    \sa MacVersion, SymbianVersion

*/

/*!

    \enum QSysInfo::MacVersion

    This enum provides symbolic names for the various versions of the

    Macintosh operating system. On Mac, the

    QSysInfo::MacintoshVersion variable gives the version of the

    system on which the application is run.

    \value MV_9        Mac OS 9 (unsupported)

    \value MV_10_0     Mac OS X 10.0 (unsupported)

    \value MV_10_1     Mac OS X 10.1 (unsupported)

    \value MV_10_2     Mac OS X 10.2 (unsupported)

    \value MV_10_3     Mac OS X 10.3

    \value MV_10_4     Mac OS X 10.4

    \value MV_10_5     Mac OS X 10.5

    \value MV_10_6     Mac OS X 10.6

    \value MV_10_7     Mac OS X 10.7

    \value MV_Unknown  An unknown and currently unsupported platform

    \value MV_CHEETAH  Apple codename for MV_10_0

    \value MV_PUMA     Apple codename for MV_10_1

    \value MV_JAGUAR   Apple codename for MV_10_2

    \value MV_PANTHER  Apple codename for MV_10_3

    \value MV_TIGER    Apple codename for MV_10_4

    \value MV_LEOPARD  Apple codename for MV_10_5

    \value MV_SNOWLEOPARD  Apple codename for MV_10_6

    \value MV_LION     Apple codename for MV_10_7

    \sa WinVersion, SymbianVersion

*/

/*!

    \enum QSysInfo::SymbianVersion

    This enum provides symbolic names for the various versions of the

    Symbian operating system. On Symbian, the

    QSysInfo::symbianVersion() function gives the version of the

    system on which the application is run.

    \value SV_9_2 Symbian OS v9.2

    \value SV_9_3 Symbian OS v9.3

    \value SV_9_4 Symbian OS v9.4

    \value SV_SF_1 S60 5th Edition (Symbian^1)

    \value SV_SF_2 Symbian^2

    \value SV_SF_3 Symbian^3 or Symbian Anna

    \value SV_SF_4 \e{This enum value is deprecated.}

    \value SV_API_5_3 Symbian/S60 API version 5.3 release

    \value SV_API_5_4 Symbian/S60 API version 5.4 release

    \value SV_Unknown An unknown and currently unsupported platform

    \sa S60Version, WinVersion, MacVersion

*/

/*!

    \enum QSysInfo::S60Version

    This enum provides symbolic names for the various versions of the

    S60 SDK. On S60, the

    QSysInfo::s60Version() function gives the version of the

    SDK on which the application is run.

    \value SV_S60_3_1 S60 3rd Edition Feature Pack 1

    \value SV_S60_3_2 S60 3rd Edition Feature Pack 2

    \value SV_S60_5_0 S60 5th Edition

    \value SV_S60_5_1 \e{This enum value is deprecated.}

    \value SV_S60_5_2 Symbian^3 and Symbian Anna

    \value SV_S60_5_3 Symbian/S60 API version 5.3 release

    \value SV_S60_5_4 Symbian/S60 API version 5.4 release

    \value SV_S60_Unknown An unknown and currently unsupported platform

    \omitvalue SV_S60_None

    \sa SymbianVersion, WinVersion, MacVersion

*/

/*!

    \macro Q_WS_MAC

    \relates <QtGlobal>

    Defined on Mac OS X.

    \sa Q_WS_WIN, Q_WS_X11, Q_WS_QWS, Q_WS_QPA, Q_WS_S60

*/

/*!

    \macro Q_WS_WIN

    \relates <QtGlobal>

    Defined on Windows.

    \sa Q_WS_MAC, Q_WS_X11, Q_WS_QWS, Q_WS_QPA, Q_WS_S60

*/

/*!

    \macro Q_WS_X11

    \relates <QtGlobal>

    Defined on X11.

    \sa Q_WS_MAC, Q_WS_WIN, Q_WS_QWS, Q_WS_QPA, Q_WS_S60

*/

/*!

    \macro Q_WS_QWS

    \relates <QtGlobal>

    Defined on Qt for Embedded Linux.

    \sa Q_WS_MAC, Q_WS_WIN, Q_WS_X11, Q_WS_QPA, Q_WS_S60

*/

/*!

    \macro Q_WS_QPA

    \relates <QtGlobal>

    Defined on Qt for Embedded Linux, Lite version.

    \sa Q_WS_MAC, Q_WS_WIN, Q_WS_X11, Q_WS_QWS, Q_WS_S60

*/

/*!

    \macro Q_OS_DARWIN

    \relates <QtGlobal>

    Defined on Darwin OS (synonym for Q_OS_MAC).

*/