Line data    Source code

       1              : use lief_ffi as ffi;
       2              : 
       3              : use crate::common::FromFFI;
       4              : use super::Type;
       5              : 
       6              : use std::marker::PhantomData;
       7              : use crate::common::into_optional;
       8              : 
       9              : pub trait Parameter {
      10              :     #[doc(hidden)]
      11              :     fn get_base(&self) -> &ffi::DWARF_Parameter;
      12              : 
      13              :     /// The name of the parameter
      14            0 :     fn name(&self) -> String {
      15            0 :         self.get_base().name().to_string()
      16            0 :     }
      17              : 
      18              :     /// Return the type of the parameter
      19            0 :     fn get_type(&self) -> Option<Type> {
      20            0 :         into_optional(self.get_base().get_type())
      21            0 :     }
      22              : }
      23              : 
      24              : pub enum Parameters<'a> {
      25              :     Formal(Formal<'a>),
      26              :     TemplateValue(TemplateValue<'a>),
      27              :     TemplateType(TemplateType<'a>),
      28              : }
      29              : 
      30              : impl FromFFI<ffi::DWARF_Parameter> for Parameters<'_> {
      31            0 :     fn from_ffi(ffi_entry: cxx::UniquePtr<ffi::DWARF_Parameter>) -> Self {
      32            0 :         unsafe {
      33            0 :             let param_ref = ffi_entry.as_ref().unwrap();
      34            0 : 
      35            0 :             if ffi::DWARF_parameters_Formal::classof(param_ref) {
      36            0 :                 let raw = {
      37            0 :                     type From = cxx::UniquePtr<ffi::DWARF_Parameter>;
      38            0 :                     type To = cxx::UniquePtr<ffi::DWARF_parameters_Formal>;
      39            0 :                     std::mem::transmute::<From, To>(ffi_entry)
      40            0 :                 };
      41            0 :                 Parameters::Formal(Formal::from_ffi(raw))
      42            0 :             } else if ffi::DWARF_parameters_TemplateValue::classof(param_ref) {
      43            0 :                 let raw = {
      44            0 :                     type From = cxx::UniquePtr<ffi::DWARF_Parameter>;
      45            0 :                     type To = cxx::UniquePtr<ffi::DWARF_parameters_TemplateValue>;
      46            0 :                     std::mem::transmute::<From, To>(ffi_entry)
      47            0 :                 };
      48            0 :                 Parameters::TemplateValue(TemplateValue::from_ffi(raw))
      49            0 :             } else if ffi::DWARF_parameters_TemplateType::classof(param_ref) {
      50            0 :                 let raw = {
      51            0 :                     type From = cxx::UniquePtr<ffi::DWARF_Parameter>;
      52            0 :                     type To = cxx::UniquePtr<ffi::DWARF_parameters_TemplateType>;
      53            0 :                     std::mem::transmute::<From, To>(ffi_entry)
      54            0 :                 };
      55            0 :                 Parameters::TemplateType(TemplateType::from_ffi(raw))
      56              :             } else {
      57            0 :                 panic!("Unknown Parameter");
      58              :             }
      59              :         }
      60            0 :     }
      61              : }
      62              : 
      63              : 
      64              : impl Parameter for Parameters<'_> {
      65            0 :     fn get_base(&self) -> &ffi::DWARF_Parameter {
      66            0 :         match &self {
      67            0 :             Parameters::Formal(p) => {
      68            0 :                 p.get_base()
      69              :             }
      70            0 :             Parameters::TemplateValue(p) => {
      71            0 :                 p.get_base()
      72              :             }
      73            0 :             Parameters::TemplateType(p) => {
      74            0 :                 p.get_base()
      75              :             }
      76              :         }
      77            0 :     }
      78              : }
      79              : 
      80              : pub struct Formal<'a> {
      81              :     ptr: cxx::UniquePtr<ffi::DWARF_parameters_Formal>,
      82              :     _owner: PhantomData<&'a ()>,
      83              : }
      84              : 
      85              : impl FromFFI<ffi::DWARF_parameters_Formal> for Formal<'_> {
      86            0 :     fn from_ffi(ptr: cxx::UniquePtr<ffi::DWARF_parameters_Formal>) -> Self {
      87            0 :         Self {
      88            0 :             ptr,
      89            0 :             _owner: PhantomData,
      90            0 :         }
      91            0 :     }
      92              : }
      93              : 
      94              : impl Parameter for Formal<'_> {
      95            0 :     fn get_base(&self) -> &ffi::DWARF_Parameter {
      96            0 :         self.ptr.as_ref().unwrap().as_ref()
      97            0 :     }
      98              : }
      99              : 
     100              : pub struct TemplateValue<'a> {
     101              :     ptr: cxx::UniquePtr<ffi::DWARF_parameters_TemplateValue>,
     102              :     _owner: PhantomData<&'a ()>,
     103              : }
     104              : 
     105              : impl FromFFI<ffi::DWARF_parameters_TemplateValue> for TemplateValue<'_> {
     106            0 :     fn from_ffi(ptr: cxx::UniquePtr<ffi::DWARF_parameters_TemplateValue>) -> Self {
     107            0 :         Self {
     108            0 :             ptr,
     109            0 :             _owner: PhantomData,
     110            0 :         }
     111            0 :     }
     112              : }
     113              : 
     114              : impl Parameter for TemplateValue<'_> {
     115            0 :     fn get_base(&self) -> &ffi::DWARF_Parameter {
     116            0 :         self.ptr.as_ref().unwrap().as_ref()
     117            0 :     }
     118              : }
     119              : 
     120              : pub struct TemplateType<'a> {
     121              :     ptr: cxx::UniquePtr<ffi::DWARF_parameters_TemplateType>,
     122              :     _owner: PhantomData<&'a ()>,
     123              : }
     124              : 
     125              : impl FromFFI<ffi::DWARF_parameters_TemplateType> for TemplateType<'_> {
     126            0 :     fn from_ffi(ptr: cxx::UniquePtr<ffi::DWARF_parameters_TemplateType>) -> Self {
     127            0 :         Self {
     128            0 :             ptr,
     129            0 :             _owner: PhantomData,
     130            0 :         }
     131            0 :     }
     132              : }
     133              : 
     134              : impl Parameter for TemplateType<'_> {
     135            0 :     fn get_base(&self) -> &ffi::DWARF_Parameter {
     136            0 :         self.ptr.as_ref().unwrap().as_ref()
     137            0 :     }
     138              : }