use alloc::vec::Vec;
use core::ops::Range;
use crate::error::{Error, ErrorKind, Result};
use crate::tables::coded::CodedIndex;
use crate::tables::{ClassLayoutRow, ConstantRow, ImplMapRow, Tables};
use crate::token::{Rid, TableId, Token, marker};
pub const fn sort_key_column(table: TableId) -> Option<usize> {
Some(match table {
TableId::InterfaceImpl => 0, TableId::Constant => 1, TableId::CustomAttribute => 0, TableId::FieldMarshal => 0, TableId::DeclSecurity => 1, TableId::ClassLayout => 2, TableId::FieldLayout => 1, TableId::EventMap => 0, TableId::PropertyMap => 0, TableId::MethodSemantics => 2, TableId::MethodImpl => 0, TableId::ImplMap => 1, TableId::FieldRva => 1, TableId::NestedClass => 0, TableId::GenericParam => 2, TableId::GenericParamConstraint => 0, TableId::LocalScope => 0, TableId::StateMachineMethod => 0, TableId::CustomDebugInformation => 0, _ => return None,
})
}
const fn sort_key_coded(table: TableId) -> Option<CodedIndex> {
Some(match table {
TableId::Constant => CodedIndex::HasConstant,
TableId::CustomAttribute => CodedIndex::HasCustomAttribute,
TableId::FieldMarshal => CodedIndex::HasFieldMarshal,
TableId::DeclSecurity => CodedIndex::HasDeclSecurity,
TableId::MethodSemantics => CodedIndex::HasSemantics,
TableId::ImplMap => CodedIndex::MemberForwarded,
TableId::GenericParam => CodedIndex::TypeOrMethodDef,
TableId::CustomDebugInformation => CodedIndex::HasCustomDebugInformation,
_ => return None,
})
}
impl<'a> Tables<'a> {
pub const fn sort_key_column(&self, table: TableId) -> Option<usize> {
sort_key_column(table)
}
pub fn rows_with_key(&self, table: TableId, key: u32) -> Result<Vec<u32>> {
let column = sort_key_column(table)
.ok_or(Error::detached(ErrorKind::Unsupported, "sorted lookup"))?;
let count = self.row_count(table);
let mut out = Vec::new();
if count == 0 {
return Ok(out);
}
if self.is_sorted(table) {
let mut lo = 1u32;
let mut hi = count + 1;
while lo < hi {
let mid = lo + (hi - lo) / 2;
if self.raw_column(table, mid, column)? < key {
lo = mid + 1;
} else {
hi = mid;
}
}
let mut rid = lo;
while rid <= count && self.raw_column(table, rid, column)? == key {
out.push(rid);
rid += 1;
}
} else {
for rid in 1..=count {
if self.raw_column(table, rid, column)? == key {
out.push(rid);
}
}
}
Ok(out)
}
pub fn first_row_with_key(&self, table: TableId, key: u32) -> Result<Option<u32>> {
Ok(self.rows_with_key(table, key)?.first().copied())
}
pub fn sort_key_for(&self, table: TableId, parent: Token) -> Option<u32> {
match sort_key_coded(table) {
Some(kind) => kind.encode(parent),
None => Some(parent.rid()),
}
}
pub fn rows_for_parent(&self, table: TableId, parent: Token) -> Result<Vec<u32>> {
match self.sort_key_for(table, parent) {
Some(key) => self.rows_with_key(table, key),
None => Ok(Vec::new()),
}
}
pub fn list_range(
&self,
owner_table: TableId,
owner_rid: u32,
column: usize,
target: TableId,
) -> Result<Range<u32>> {
let count = self.row_count(owner_table);
if owner_rid == 0 || owner_rid > count {
return Err(Error::detached(ErrorKind::OutOfRange, owner_table.name()));
}
let limit = self.logical_row_count(target).saturating_add(1);
let start = self.raw_column(owner_table, owner_rid, column)?.clamp(1, limit);
let end = if owner_rid == count {
limit
} else {
self.raw_column(owner_table, owner_rid + 1, column)?.clamp(1, limit)
};
Ok(start..end.max(start))
}
fn owner_of_list(
&self,
owner_table: TableId,
column: usize,
target: TableId,
member_rid: u32,
) -> Result<Option<u32>> {
let count = self.row_count(owner_table);
if count == 0 || member_rid == 0 {
return Ok(None);
}
let mut lo = 1u32;
let mut hi = count;
let mut candidate = 0u32;
while lo <= hi {
let mid = lo + (hi - lo) / 2;
if self.raw_column(owner_table, mid, column)? <= member_rid {
candidate = mid;
lo = mid + 1;
} else if mid == 1 {
break;
} else {
hi = mid - 1;
}
}
if candidate != 0 {
let range = self.list_range(owner_table, candidate, column, target)?;
if range.contains(&member_rid) {
return Ok(Some(candidate));
}
}
for rid in 1..=count {
if self.list_range(owner_table, rid, column, target)?.contains(&member_rid) {
return Ok(Some(rid));
}
}
Ok(None)
}
pub fn field_range(&self, type_def: Rid<marker::TypeDef>) -> Result<Range<u32>> {
self.list_range(TableId::TypeDef, type_def.get(), 4, TableId::Field)
}
pub fn method_range(&self, type_def: Rid<marker::TypeDef>) -> Result<Range<u32>> {
self.list_range(TableId::TypeDef, type_def.get(), 5, TableId::MethodDef)
}
pub fn param_range(&self, method: Rid<marker::MethodDef>) -> Result<Range<u32>> {
self.list_range(TableId::MethodDef, method.get(), 5, TableId::Param)
}
pub fn event_range(&self, event_map: Rid<marker::EventMap>) -> Result<Range<u32>> {
self.list_range(TableId::EventMap, event_map.get(), 1, TableId::Event)
}
pub fn property_range(&self, property_map: Rid<marker::PropertyMap>) -> Result<Range<u32>> {
self.list_range(TableId::PropertyMap, property_map.get(), 1, TableId::Property)
}
pub fn type_of_field(&self, field: Rid<marker::Field>) -> Result<Option<Rid<marker::TypeDef>>> {
Ok(self.owner_of_list(TableId::TypeDef, 4, TableId::Field, field.get())?.map(Rid::new))
}
pub fn type_of_method(
&self,
method: Rid<marker::MethodDef>,
) -> Result<Option<Rid<marker::TypeDef>>> {
Ok(self.owner_of_list(TableId::TypeDef, 5, TableId::MethodDef, method.get())?.map(Rid::new))
}
pub fn method_of_param(
&self,
param: Rid<marker::Param>,
) -> Result<Option<Rid<marker::MethodDef>>> {
Ok(self.owner_of_list(TableId::MethodDef, 5, TableId::Param, param.get())?.map(Rid::new))
}
pub fn event_map_of(
&self,
type_def: Rid<marker::TypeDef>,
) -> Result<Option<Rid<marker::EventMap>>> {
Ok(self.first_row_with_key(TableId::EventMap, type_def.get())?.map(Rid::new))
}
pub fn property_map_of(
&self,
type_def: Rid<marker::TypeDef>,
) -> Result<Option<Rid<marker::PropertyMap>>> {
Ok(self.first_row_with_key(TableId::PropertyMap, type_def.get())?.map(Rid::new))
}
pub fn generic_params(&self, owner: Token) -> Result<Vec<u32>> {
let mut rids = self.rows_for_parent(TableId::GenericParam, owner)?;
let mut keyed = Vec::with_capacity(rids.len());
for rid in rids.drain(..) {
keyed.push((self.raw_column(TableId::GenericParam, rid, 0)?, rid));
}
keyed.sort_unstable();
Ok(keyed.into_iter().map(|(_, rid)| rid).collect())
}
pub fn generic_param_constraints(
&self,
generic_param: Rid<marker::GenericParam>,
) -> Result<Vec<u32>> {
self.rows_with_key(TableId::GenericParamConstraint, generic_param.get())
}
pub fn enclosing_type(
&self,
type_def: Rid<marker::TypeDef>,
) -> Result<Option<Rid<marker::TypeDef>>> {
match self.first_row_with_key(TableId::NestedClass, type_def.get())? {
Some(rid) => Ok(Some(Rid::new(self.raw_column(TableId::NestedClass, rid, 1)?))),
None => Ok(None),
}
}
pub fn nested_types(&self, type_def: Rid<marker::TypeDef>) -> Result<Vec<u32>> {
let mut out = Vec::new();
for rid in 1..=self.row_count(TableId::NestedClass) {
if self.raw_column(TableId::NestedClass, rid, 1)? == type_def.get() {
out.push(self.raw_column(TableId::NestedClass, rid, 0)?);
}
}
Ok(out)
}
pub fn custom_attributes(&self, parent: Token) -> Result<Vec<u32>> {
self.rows_for_parent(TableId::CustomAttribute, parent)
}
pub fn interface_impls(&self, type_def: Rid<marker::TypeDef>) -> Result<Vec<u32>> {
self.rows_with_key(TableId::InterfaceImpl, type_def.get())
}
pub fn method_impls(&self, type_def: Rid<marker::TypeDef>) -> Result<Vec<u32>> {
self.rows_with_key(TableId::MethodImpl, type_def.get())
}
pub fn semantics_for(&self, association: Token) -> Result<Vec<u32>> {
self.rows_for_parent(TableId::MethodSemantics, association)
}
pub fn decl_security_for(&self, parent: Token) -> Result<Vec<u32>> {
self.rows_for_parent(TableId::DeclSecurity, parent)
}
pub fn constant_of(&self, parent: Token) -> Result<Option<ConstantRow>> {
match self.sort_key_for(TableId::Constant, parent) {
Some(key) => match self.first_row_with_key(TableId::Constant, key)? {
Some(rid) => Ok(Some(self.constant_row(rid)?)),
None => Ok(None),
},
None => Ok(None),
}
}
pub fn field_marshal_of(&self, parent: Token) -> Result<Option<u32>> {
match self.sort_key_for(TableId::FieldMarshal, parent) {
Some(key) => match self.first_row_with_key(TableId::FieldMarshal, key)? {
Some(rid) => Ok(Some(self.raw_column(TableId::FieldMarshal, rid, 1)?)),
None => Ok(None),
},
None => Ok(None),
}
}
pub fn field_rva_of(&self, field: Rid<marker::Field>) -> Result<Option<u32>> {
match self.first_row_with_key(TableId::FieldRva, field.get())? {
Some(rid) => Ok(Some(self.raw_column(TableId::FieldRva, rid, 0)?)),
None => Ok(None),
}
}
pub fn field_layout_of(&self, field: Rid<marker::Field>) -> Result<Option<u32>> {
match self.first_row_with_key(TableId::FieldLayout, field.get())? {
Some(rid) => Ok(Some(self.raw_column(TableId::FieldLayout, rid, 0)?)),
None => Ok(None),
}
}
pub fn class_layout_of(
&self,
type_def: Rid<marker::TypeDef>,
) -> Result<Option<ClassLayoutRow>> {
match self.first_row_with_key(TableId::ClassLayout, type_def.get())? {
Some(rid) => Ok(Some(self.class_layout_row(rid)?)),
None => Ok(None),
}
}
pub fn impl_map_of(&self, member: Token) -> Result<Option<ImplMapRow>> {
match self.sort_key_for(TableId::ImplMap, member) {
Some(key) => match self.first_row_with_key(TableId::ImplMap, key)? {
Some(rid) => Ok(Some(self.impl_map_row(rid)?)),
None => Ok(None),
},
None => Ok(None),
}
}
fn constant_row(&self, rid: u32) -> Result<ConstantRow> {
self.row::<ConstantRow>(rid)
}
fn class_layout_row(&self, rid: u32) -> Result<ClassLayoutRow> {
self.row::<ClassLayoutRow>(rid)
}
fn impl_map_row(&self, rid: u32) -> Result<ImplMapRow> {
self.row::<ImplMapRow>(rid)
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::tables::TableRow;
#[test]
fn sort_key_columns_are_within_the_table() {
for &id in TableId::ALL {
if let Some(column) = sort_key_column(id) {
assert!(
column < crate::tables::columns_of(id).len(),
"{} key column {} is out of range",
id.name(),
column
);
}
}
}
#[test]
fn coded_sort_keys_match_the_declared_column() {
for &id in TableId::ALL {
let (Some(column), Some(kind)) = (sort_key_column(id), sort_key_coded(id)) else {
continue;
};
assert_eq!(
crate::tables::columns_of(id)[column],
crate::tables::ColumnKind::Coded(kind),
"{} key column kind mismatch",
id.name()
);
}
}
#[test]
fn non_coded_sort_keys_are_simple_indices() {
for &id in TableId::ALL {
let Some(column) = sort_key_column(id) else { continue };
if sort_key_coded(id).is_some() {
continue;
}
assert!(
matches!(crate::tables::columns_of(id)[column], crate::tables::ColumnKind::Rid(_)),
"{} key column is neither coded nor a RID",
id.name()
);
}
}
#[test]
fn list_column_indices_match_the_row_layout() {
use crate::tables::ColumnKind::Rid as R;
let type_def = <crate::tables::TypeDefRow as TableRow>::COLUMNS;
assert_eq!(type_def[4], R(TableId::Field));
assert_eq!(type_def[5], R(TableId::MethodDef));
let method = <crate::tables::MethodDefRow as TableRow>::COLUMNS;
assert_eq!(method[5], R(TableId::Param));
let event_map = <crate::tables::EventMapRow as TableRow>::COLUMNS;
assert_eq!(event_map[1], R(TableId::Event));
let property_map = <crate::tables::PropertyMapRow as TableRow>::COLUMNS;
assert_eq!(property_map[1], R(TableId::Property));
}
}