use core::cmp::Ordering;
use core::fmt;
use core::marker::PhantomData;
macro_rules! define_tables {
($( $(#[$attr:meta])* $name:ident = $value:literal ),* $(,)?) => {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[repr(u8)]
#[non_exhaustive]
pub enum TableId {
$( $(#[$attr])* $name = $value ),*
}
impl TableId {
pub const ALL: &'static [TableId] = &[ $( TableId::$name ),* ];
pub const fn from_u8(value: u8) -> Option<TableId> {
match value {
$( $value => Some(TableId::$name), )*
_ => None,
}
}
pub const fn name(self) -> &'static str {
match self {
$( TableId::$name => stringify!($name), )*
}
}
}
pub mod marker {
$(
$(#[$attr])*
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
pub enum $name {}
)*
pub trait Table: Copy + core::fmt::Debug {
const ID: super::TableId;
}
$(
impl Table for $name {
const ID: super::TableId = super::TableId::$name;
}
)*
}
};
}
define_tables! {
Module = 0x00,
TypeRef = 0x01,
TypeDef = 0x02,
FieldPtr = 0x03,
Field = 0x04,
MethodPtr = 0x05,
MethodDef = 0x06,
ParamPtr = 0x07,
Param = 0x08,
InterfaceImpl = 0x09,
MemberRef = 0x0A,
Constant = 0x0B,
CustomAttribute = 0x0C,
FieldMarshal = 0x0D,
DeclSecurity = 0x0E,
ClassLayout = 0x0F,
FieldLayout = 0x10,
StandAloneSig = 0x11,
EventMap = 0x12,
EventPtr = 0x13,
Event = 0x14,
PropertyMap = 0x15,
PropertyPtr = 0x16,
Property = 0x17,
MethodSemantics = 0x18,
MethodImpl = 0x19,
ModuleRef = 0x1A,
TypeSpec = 0x1B,
ImplMap = 0x1C,
FieldRva = 0x1D,
EncLog = 0x1E,
EncMap = 0x1F,
Assembly = 0x20,
AssemblyProcessor = 0x21,
AssemblyOs = 0x22,
AssemblyRef = 0x23,
AssemblyRefProcessor = 0x24,
AssemblyRefOs = 0x25,
File = 0x26,
ExportedType = 0x27,
ManifestResource = 0x28,
NestedClass = 0x29,
GenericParam = 0x2A,
MethodSpec = 0x2B,
GenericParamConstraint = 0x2C,
Document = 0x30,
MethodDebugInformation = 0x31,
LocalScope = 0x32,
LocalVariable = 0x33,
LocalConstant = 0x34,
ImportScope = 0x35,
StateMachineMethod = 0x36,
CustomDebugInformation = 0x37,
}
impl TableId {
pub const fn to_u8(self) -> u8 {
self as u8
}
pub const fn is_pdb(self) -> bool {
(self as u8) >= 0x30
}
pub const fn is_ptr_table(self) -> bool {
matches!(
self,
TableId::FieldPtr
| TableId::MethodPtr
| TableId::ParamPtr
| TableId::EventPtr
| TableId::PropertyPtr
)
}
pub const fn ptr_target(self) -> Option<TableId> {
match self {
TableId::FieldPtr => Some(TableId::Field),
TableId::MethodPtr => Some(TableId::MethodDef),
TableId::ParamPtr => Some(TableId::Param),
TableId::EventPtr => Some(TableId::Event),
TableId::PropertyPtr => Some(TableId::Property),
_ => None,
}
}
pub const fn ptr_source(self) -> Option<TableId> {
match self {
TableId::Field => Some(TableId::FieldPtr),
TableId::MethodDef => Some(TableId::MethodPtr),
TableId::Param => Some(TableId::ParamPtr),
TableId::Event => Some(TableId::EventPtr),
TableId::Property => Some(TableId::PropertyPtr),
_ => None,
}
}
}
impl fmt::Display for TableId {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(self.name())
}
}
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct Token(pub u32);
impl Token {
pub const RID_MASK: u32 = 0x00FF_FFFF;
pub const fn new(table: TableId, rid: u32) -> Token {
Token(((table.to_u8() as u32) << 24) | (rid & Token::RID_MASK))
}
pub const fn table(self) -> Option<TableId> {
TableId::from_u8((self.0 >> 24) as u8)
}
pub const fn table_byte(self) -> u8 {
(self.0 >> 24) as u8
}
pub const fn rid(self) -> u32 {
self.0 & Token::RID_MASK
}
pub const fn is_null(self) -> bool {
self.rid() == 0
}
pub const fn value(self) -> u32 {
self.0
}
pub fn as_rid<T: marker::Table>(self) -> Option<Rid<T>> {
if self.table() == Some(T::ID) && !self.is_null() {
Some(Rid::new(self.rid()))
} else {
None
}
}
}
impl fmt::Debug for Token {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self.table() {
Some(t) => write!(f, "Token({}[{}])", t.name(), self.rid()),
None => write!(f, "Token({:#010x})", self.0),
}
}
}
impl fmt::Display for Token {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{:#010x}", self.0)
}
}
impl<T: marker::Table> From<Rid<T>> for Token {
fn from(rid: Rid<T>) -> Token {
Token::new(T::ID, rid.get())
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[cfg_attr(feature = "serde", serde(transparent))]
pub struct Rid<T> {
value: u32,
#[cfg_attr(feature = "serde", serde(skip))]
_table: PhantomData<fn() -> T>,
}
impl<T> Rid<T> {
pub const fn new(value: u32) -> Self {
Rid { value, _table: PhantomData }
}
pub const fn get(self) -> u32 {
self.value
}
pub const fn is_null(self) -> bool {
self.value == 0
}
pub const fn index(self) -> Option<usize> {
if self.value == 0 { None } else { Some(self.value as usize - 1) }
}
}
impl<T: marker::Table> Rid<T> {
pub const fn table(self) -> TableId {
T::ID
}
pub const fn token(self) -> Token {
Token::new(T::ID, self.value)
}
}
impl<T> Clone for Rid<T> {
fn clone(&self) -> Self {
*self
}
}
impl<T> Copy for Rid<T> {}
impl<T> PartialEq for Rid<T> {
fn eq(&self, other: &Self) -> bool {
self.value == other.value
}
}
impl<T> Eq for Rid<T> {}
impl<T> PartialOrd for Rid<T> {
fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
Some(self.cmp(other))
}
}
impl<T> Ord for Rid<T> {
fn cmp(&self, other: &Self) -> Ordering {
self.value.cmp(&other.value)
}
}
impl<T> core::hash::Hash for Rid<T> {
fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
self.value.hash(state);
}
}
impl<T> Default for Rid<T> {
fn default() -> Self {
Rid::new(0)
}
}
impl<T: marker::Table> fmt::Debug for Rid<T> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}[{}]", T::ID.name(), self.value)
}
}
macro_rules! heap_index {
($(#[$attr:meta])* $name:ident, $heap:literal) => {
$(#[$attr])*
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[cfg_attr(feature = "serde", serde(transparent))]
pub struct $name(pub u32);
impl $name {
pub const fn get(self) -> u32 {
self.0
}
pub const fn is_empty(self) -> bool {
self.0 == 0
}
}
impl fmt::Debug for $name {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, concat!($heap, "[{:#x}]"), self.0)
}
}
};
}
heap_index!(
StringIndex,
"#Strings"
);
heap_index!(
BlobIndex,
"#Blob"
);
heap_index!(
GuidIndex,
"#GUID"
);
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[cfg_attr(feature = "serde", serde(transparent))]
pub struct UserStringToken(pub u32);
impl UserStringToken {
pub const fn offset(self) -> u32 {
self.0 & Token::RID_MASK
}
pub const fn value(self) -> u32 {
self.0
}
pub const fn has_us_table_byte(self) -> bool {
(self.0 >> 24) == 0x70
}
}
impl fmt::Debug for UserStringToken {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "#US[{:#x}]", self.offset())
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn token_round_trip() {
let t = Token::new(TableId::MethodDef, 42);
assert_eq!(t.0, 0x0600_002A);
assert_eq!(t.table(), Some(TableId::MethodDef));
assert_eq!(t.rid(), 42);
assert!(!t.is_null());
assert!(Token::new(TableId::MethodDef, 0).is_null());
}
#[test]
fn reserved_table_byte_has_no_table() {
assert_eq!(Token(0x2D00_0001).table(), None);
assert_eq!(Token(0x2D00_0001).table_byte(), 0x2D);
assert_eq!(Token(0x7000_0010).table(), None);
}
#[test]
fn all_ids_round_trip() {
for &id in TableId::ALL {
assert_eq!(TableId::from_u8(id.to_u8()), Some(id));
}
assert_eq!(TableId::ALL.len(), 45 + 8);
assert_eq!(TableId::from_u8(0x2D), None);
assert_eq!(TableId::from_u8(0x38), None);
}
#[test]
fn rid_is_typed_and_ordered() {
let a: Rid<marker::TypeDef> = Rid::new(1);
let b: Rid<marker::TypeDef> = Rid::new(2);
assert!(a < b);
assert_eq!(a.index(), Some(0));
assert_eq!(Rid::<marker::TypeDef>::new(0).index(), None);
assert_eq!(a.token(), Token::new(TableId::TypeDef, 1));
assert_eq!(a.token().as_rid::<marker::TypeDef>(), Some(a));
assert_eq!(a.token().as_rid::<marker::Field>(), None);
}
#[test]
fn ptr_tables_map_both_ways() {
for &id in TableId::ALL {
if let Some(target) = id.ptr_target() {
assert!(id.is_ptr_table());
assert_eq!(target.ptr_source(), Some(id));
}
}
}
}