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:
  template<typename... Args,
           typename = typename std::
               enable_if<std::is_constructible<Type, Args&&...>::value>::type>
  Simple(Args&&... args) :
    Type(std::forward<Args>(args)...) {}

  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