StarMirror/sandboxed-api
1
0
Fork 0
mirror of https://github.com/google/sandboxed-api.git synced 2024-03-22 13:11:30 +08:00
Code Issues Projects Releases Wiki Activity

Use absl::StrFormat() in Reg<T>::ToString()

Browse Source 
PiperOrigin-RevId: 322528126
Change-Id: Ia5344e53366a8b3c11ec0dbba7cff8e4192a7605
This commit is contained in:
Christian Blichmann 2020-07-22 01:20:20 -07:00 committed by Copybara-Service
parent aaa3eded8f
commit 833c9740aa
1 changed files with 53 additions and 99 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

122
sandboxed_api/var_reg.h
View File

@ -15,10 +15,12 @@
#ifndef SANDBOXED_API_VAR_REG_H_ #ifndef SANDBOXED_API_VAR_REG_H_
#define SANDBOXED_API_VAR_REG_H_ #define SANDBOXED_API_VAR_REG_H_
#include <inttypes.h>
#include <iostream> #include <iostream>
#include <type_traits>
#include <glog/logging.h> #include <glog/logging.h>
#include "absl/strings/str_cat.h"
#include "absl/strings/str_format.h"
#include "sandboxed_api/var_abstract.h" #include "sandboxed_api/var_abstract.h"
namespace sapi::v { namespace sapi::v {
@ -32,9 +34,11 @@ class Callable : public Var {
// Get pointer to the stored data. // Get pointer to the stored data.
virtual const void* GetDataPtr() = 0; virtual const void* GetDataPtr() = 0;
// Set internal data from ptr. // Set internal data from ptr.
virtual void SetDataFromPtr(const void* ptr, size_t max_sz) = 0; virtual void SetDataFromPtr(const void* ptr, size_t max_sz) = 0;
// Get data from inernal ptr.
// Get data from internal ptr.
void GetDataFromPtr(void* ptr, size_t max_sz) { void GetDataFromPtr(void* ptr, size_t max_sz) {
size_t min_sz = std::min<size_t>(GetSize(), max_sz); size_t min_sz = std::min<size_t>(GetSize(), max_sz);
memcpy(ptr, GetDataPtr(), min_sz); memcpy(ptr, GetDataPtr(), min_sz);
@ -48,8 +52,8 @@ class Callable : public Var {
template <typename T> template <typename T>
class Reg : public Callable { class Reg : public Callable {
public: public:
static_assert(std::is_integral<T>() || std::is_floating_point<T>() || static_assert(std::is_integral_v<T> || std::is_floating_point_v<T> ||
std::is_pointer<T>() || std::is_enum<T>(), std::is_pointer_v<T> || std::is_enum_v<T>,
"Only register-sized types are allowed as template argument " "Only register-sized types are allowed as template argument "
"for class Reg."); "for class Reg.");
@ -73,108 +77,58 @@ class Reg : public Callable {
size_t GetSize() const override { return sizeof(T); } size_t GetSize() const override { return sizeof(T); }
Type GetType() const override { Type GetType() const override;
if constexpr (std::is_integral<T>() || std::is_enum<T>()) {
std::string GetTypeString() const override;
std::string ToString() const override;
protected:
// The stored value.
T val_;
};
template <typename T>
Type Reg<T>::GetType() const {
if constexpr (std::is_integral_v<T> || std::is_enum_v<T>) {
return Type::kInt; return Type::kInt;
} }
if constexpr (std::is_floating_point<T>()) { if constexpr (std::is_floating_point_v<T>) {
return Type::kFloat; return Type::kFloat;
} }
if constexpr (std::is_pointer<T>()) { if constexpr (std::is_pointer_v<T>) {
return Type::kPointer; return Type::kPointer;
} }
// Not reached // Not reached
} }
std::string GetTypeString() const override { template <typename T>
if constexpr (std::is_integral<T>() || std::is_enum<T>()) { std::string Reg<T>::GetTypeString() const {
if constexpr (std::is_integral_v<T> || std::is_enum_v<T>) {
return "Integer"; return "Integer";
} }
if constexpr (std::is_floating_point<T>()) { if constexpr (std::is_floating_point_v<T>) {
return "Floating-point"; return "Floating-point";
} }
if constexpr (std::is_pointer<T>()) { if constexpr (std::is_pointer_v<T>) {
return "Pointer"; return "Pointer";
} }
// Not reached // Not reached
} }
std::string ToString() const override { return ValToString(); } template <typename T>
std::string Reg<T>::ToString() const {
protected: if constexpr (std::is_integral_v<T> || std::is_enum_v<T>) {
// The stored value. return absl::StrCat(val_);
T val_;
private:
std::string ValToString() const {
char buf[32];
bool signd = true;
if (std::is_integral<T>::value || std::is_enum<T>::value) {
if (std::is_integral<T>::value) {
signd = std::is_signed<T>::value;
} }
if constexpr (std::is_floating_point_v<T>) {
switch (sizeof(T)) { return absl::StrFormat("%.10f", val_);
case 1:
if (signd) {
snprintf(buf, sizeof(buf), "%" PRId8,
*(reinterpret_cast<const uint8_t*>(&val_)));
} else {
snprintf(buf, sizeof(buf), "%" PRIu8,
*(reinterpret_cast<const uint8_t*>(&val_)));
} }
break; if constexpr (std::is_pointer<T>::value) {
case 2: return absl::StrFormat("%p", val_);
if (signd) {
snprintf(buf, sizeof(buf), "%" PRId16,
*(reinterpret_cast<const uint16_t*>(&val_)));
} else {
snprintf(buf, sizeof(buf), "%" PRIu16,
*(reinterpret_cast<const uint16_t*>(&val_)));
} }
break; // Not reached.
case 4:
if (signd) {
snprintf(buf, sizeof(buf), "%" PRId32,
*(reinterpret_cast<const uint32_t*>(&val_)));
} else {
snprintf(buf, sizeof(buf), "%" PRIu32,
*(reinterpret_cast<const uint32_t*>(&val_)));
} }
break;
case 8:
if (signd) {
snprintf(buf, sizeof(buf), "%" PRId64,
*(reinterpret_cast<const uint64_t*>(&val_)));
} else {
snprintf(buf, sizeof(buf), "%" PRIu64,
*(reinterpret_cast<const uint64_t*>(&val_)));
}
break;
default:
LOG(FATAL) << "Incorrect type";
break;
}
} else if (std::is_floating_point<T>::value) {
if (std::is_same<T, float>::value) {
snprintf(buf, sizeof(buf), "%.10f",
*(reinterpret_cast<const float*>(&val_)));
} else if (std::is_same<T, double>::value) {
snprintf(buf, sizeof(buf), "%.10lf",
*(reinterpret_cast<const double*>(&val_)));
} else if (std::is_same<T, long double>::value) {
snprintf(buf, sizeof(buf), "%.10Lf",
*(reinterpret_cast<const long double*>(&val_)));
}
} else if (std::is_pointer<T>::value) {
snprintf(buf, sizeof(buf), "%p", *reinterpret_cast<void* const*>(&val_));
} else {
LOG(FATAL) << "Incorrect type";
}
return std::string(buf);
}
};
} // namespace sapi::v } // namespace sapi::v