Simple.hpp

Go to the documentation of this file.

/* Copyright 2022 - 2026 R. Thomas
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#ifndef LIEF_PDB_TYPE_SIMPLE_H
#define LIEF_PDB_TYPE_SIMPLE_H
 
#include "LIEF/visibility.h"
#include "LIEF/PDB/Type.hpp"
 
namespace LIEF {
namespace pdb {
namespace types {

class LIEF_API Simple : public Type {
  public:
  using Type::Type;

  enum class TYPES {
    UNKNOWN = 0,
    VOID_ = 0x0003,
 
    // --- Characters ---
    SCHAR = 0x0010, 
    UCHAR = 0x0020, 
    RCHAR = 0x0070, 
 
    // --- Unicode / Wide Characters ---
    WCHAR  = 0x0071, 
    CHAR16 = 0x007a, 
    CHAR32 = 0x007b, 
    CHAR8  = 0x007c, 
 
    // --- Bytes ---
    SBYTE = 0x0068, 
    UBYTE = 0x0069, 
 
    // --- Short (16-bit) ---
    SSHORT = 0x0011, 
    USHORT = 0x0021, 
 
    SINT16 = 0x0072, 
    UINT16 = 0x0073, 
 
    // --- Long (32-bit) ---
    SLONG = 0x0012, 
    ULONG = 0x0022, 
 
    SINT32 = 0x0074, 
    UINT32 = 0x0075, 
 
    // --- Quad (64-bit) ---
    SQUAD = 0x0013, 
    UQUAD = 0x0023, 
 
    SINT64 = 0x0076, 
    UINT64 = 0x0077, 
 
    // --- Octa (128-bit) ---
    SOCTA = 0x0014, 
    UOCTA = 0x0024, 
 
    SINT128 = 0x0078, 
    UINT128 = 0x0079, 
 
    // --- Floating Point ---
    FLOAT16 = 0x0046, 
    FLOAT32 = 0x0040, 
    FLOAT32_PARTIAL_PRECISION = 0x45,
 
    FLOAT48 = 0x0044, 
    FLOAT64 = 0x0041, 
    FLOAT80 = 0x0042, 
    FLOAT128 = 0x0043, 
 
    // --- Complex Numbers ---
    COMPLEX16 = 0x0056,
    COMPLEX32 = 0x0050,
    COMPLEX32_PARTIAL_PRECISION = 0x0055,
    COMPLEX48 = 0x0054,
    COMPLEX64 = 0x0051,
    COMPLEX80 = 0x0052,
    COMPLEX128 = 0x0053,
 
    // --- Booleans ---
    BOOL8   = 0x0030, 
    BOOL16  = 0x0031, 
    BOOL32  = 0x0032, 
    BOOL64  = 0x0033, 
    BOOL128 = 0x0034, 
  };

  enum class MODES : uint32_t {
    DIRECT          = 0x00000000, 
    FAR_POINTER     = 0x00000200, 
    HUGE_POINTER    = 0x00000300, 
    NEAR_POINTER32  = 0x00000400, 
    FAR_POINTER32   = 0x00000500, 
    NEAR_POINTER64  = 0x00000600, 
    NEAR_POINTER128 = 0x00000700  
  };

  TYPES type() const;

  MODES modes() const;

  bool is_pointer() const {
    return modes() != MODES::DIRECT;
  }

  bool is_signed() const {
    const TYPES ty = type();
    return ty == TYPES::SCHAR  || ty == TYPES::SBYTE  ||
           ty == TYPES::SSHORT || ty == TYPES::SINT16 ||
           ty == TYPES::SLONG  || ty == TYPES::SINT32 ||
           ty == TYPES::SQUAD  || ty == TYPES::SINT64 ||
           ty == TYPES::SOCTA  || ty == TYPES::SINT128;
  }
 
  static bool classof(const Type* type) {
    return type->kind() == Type::KIND::SIMPLE;
  }
 
  ~Simple() override;
};
 
}
}
}
#endif