cppcheck/lib/platform.h

183 lines
5.2 KiB
C
Raw Normal View History

/*
* Cppcheck - A tool for static C/C++ code analysis
2019-09-01 11:49:43 +02:00
* Copyright (C) 2007-2019 Cppcheck team.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
//---------------------------------------------------------------------------
#ifndef platformH
#define platformH
//---------------------------------------------------------------------------
#include "config.h"
#include "utils.h"
2017-05-27 04:33:47 +02:00
2018-10-20 15:28:34 +02:00
#include <climits>
#include <string>
/// @addtogroup Core
/// @{
namespace tinyxml2 {
class XMLDocument;
}
namespace cppcheck {
/**
* @brief Platform settings
*/
class CPPCHECKLIB Platform {
private:
static long long min_value(int bit) {
if (bit >= 64)
2018-10-20 15:28:34 +02:00
return LLONG_MIN;
return -(1LL << (bit-1));
}
static long long max_value(int bit) {
if (bit >= 64)
return (~0ULL) >> 1;
return (1LL << (bit-1)) - 1LL;
}
public:
Platform();
virtual ~Platform() {}
bool isIntValue(long long value) const {
return value >= min_value(int_bit) && value <= max_value(int_bit);
}
bool isIntValue(unsigned long long value) const {
return value <= max_value(int_bit);
}
bool isLongValue(long long value) const {
return value >= min_value(long_bit) && value <= max_value(long_bit);
}
bool isLongValue(unsigned long long value) const {
return value <= max_value(long_bit);
}
bool isLongLongValue(unsigned long long value) const {
return value <= max_value(long_long_bit);
}
nonneg int char_bit; /// bits in char
nonneg int short_bit; /// bits in short
nonneg int int_bit; /// bits in int
nonneg int long_bit; /// bits in long
nonneg int long_long_bit; /// bits in long long
/** size of standard types */
nonneg int sizeof_bool;
nonneg int sizeof_short;
nonneg int sizeof_int;
nonneg int sizeof_long;
nonneg int sizeof_long_long;
nonneg int sizeof_float;
nonneg int sizeof_double;
nonneg int sizeof_long_double;
nonneg int sizeof_wchar_t;
nonneg int sizeof_size_t;
nonneg int sizeof_pointer;
char defaultSign; // unsigned:'u', signed:'s', unknown:'\0'
enum PlatformType {
Unspecified, // No platform specified
Native, // whatever system this code was compiled on
Win32A,
Win32W,
Win64,
Unix32,
Unix64,
PlatformFile
};
/** platform type */
PlatformType platformType;
/** set the platform type for predefined platforms */
bool platform(PlatformType type);
2018-03-11 15:06:08 +01:00
/**
* load platform file
* @param exename application path
* @param filename platform filename
* @return returns true if file was loaded successfully
*/
bool loadPlatformFile(const char exename[], const std::string &filename);
/** load platform from xml document, primarily for testing */
bool loadFromXmlDocument(const tinyxml2::XMLDocument *doc);
/**
* @brief Returns true if platform type is Windows
* @return true if Windows platform type.
*/
bool isWindowsPlatform() const {
return platformType == Win32A ||
platformType == Win32W ||
platformType == Win64;
}
const char *platformString() const {
return platformString(platformType);
}
static const char *platformString(PlatformType pt) {
switch (pt) {
case Unspecified:
return "Unspecified";
case Native:
return "Native";
case Win32A:
return "win32A";
case Win32W:
return "win32W";
case Win64:
return "win64";
case Unix32:
return "unix32";
case Unix64:
return "unix64";
case PlatformFile:
return "platformFile";
default:
return "unknown";
}
}
long long unsignedCharMax() const {
2017-10-20 01:53:20 +02:00
return max_value(char_bit + 1);
}
long long signedCharMax() const {
return max_value(char_bit);
}
long long signedCharMin() const {
return min_value(char_bit);
}
};
}
/// @}
//---------------------------------------------------------------------------
#endif // platformH