Struct Variable

pub struct Variable {
    pub parent_key: ObjectRef,
    pub name: VariableName,
    pub source_location: Option<SourceLocation>,
    pub language: DwLang,
    pub type_name: VariableType,
    pub variable_node_type: VariableNodeType,
    pub memory_location: VariableLocation,
    pub byte_size: Option<u64>,
    pub role: VariantRole,
    /* private fields */
}

Available on crate feature debug only.

The Variable struct is used in conjunction with VariableCache to cache data about variables.

Any modifications to the Variable value will be transient (lost when it goes out of scope), unless it is updated through one of the available methods on VariableCache.

Fields

parent_key: ObjectRef

Every variable must have a unique parent assigned to it when stored in the VariableCache.

name: VariableName

The variable name refers to the name of any of the types of values described in the VariableCache

source_location: Option<SourceLocation>

The source location of the declaration of this variable, if available.

language: DwLang

Programming language of the defining compilation unit.

type_name: VariableType

The name of the type of this variable.

variable_node_type: VariableNodeType

For ‘lazy loading’ of certain variable types we have to determine if the variable recursion should be deferred, and if so, how to resolve it when the request for further recursion happens. See VariableNodeType for more information.

memory_location: VariableLocation

The starting location/address in memory where this Variable’s value is stored.

byte_size: Option<u64>

The size of this variable in bytes.

role: VariantRole

The role of this variable.

Implementations

impl Variable

pub fn new(unit_info: Option<&UnitInfo>) -> Variable

In most cases, Variables will be initialized with their ELF references so that we resolve their data types and values on demand.

pub fn type_name(&self) -> String

Returns the readable name of the variable type.

pub fn variable_key(&self) -> ObjectRef

Get a unique key for this variable.

pub fn set_value(&mut self, new_value: VariableValue)

This ensures debug frontends can see the errors, but doesn’t fail because of a single variable not being able to decode correctly.

pub fn update_value( &self, memory: &mut impl MemoryInterface, variable_cache: &mut VariableCache, new_value: String, ) -> Result<(), DebugError>

Convert the String value into the appropriate memory format and update the target memory with the new value. Currently this only works for base data types. There is no provision in the MS DAP API to catch this client side, so we can only respond with a ‘gentle’ error message if the user attempts unsupported data types.

pub fn to_string(&self, variable_cache: &VariableCache) -> String

Implementing get_value(), because Variable.value has to be private (a requirement of updating the value without overriding earlier values … see set_value()).

pub fn extract_value( &mut self, memory: &mut dyn MemoryInterface, variable_cache: &VariableCache, )

Evaluate the variable’s result if possible and set self.value, or else set self.value as the error String.

pub fn is_indexed(&self) -> bool

The variable is considered to be an ‘indexed’ variable if the name starts with two underscores followed by a number. e.g. “__1”.

pub fn is_named(&self) -> bool

Returns true if the variable has a name, false otherwise.

pub fn is_valid(&self) -> bool

true if the Variable has a valid value, or an empty value. false if the Variable has a VariableValue::Error(_) value

pub fn memory_range(&self) -> Option<Range<u64>>

Calculate the memory range that contains the value of this variable.

If the location and/or byte size is not known, then return None. Note: We don’t do any validation of the memory range here and leave it up to the caller to validate the memory ranges before attempting to read them.

Trait Implementations

impl Clone for Variable

fn clone(&self) -> Variable

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Variable

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for Variable

fn eq(&self, other: &Variable) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for Variable

impl StructuralPartialEq for Variable