Struct BlockState

pub struct BlockState<I: SemanticContextInstruction> {
    pub values: HashMap<ValueName, Value>,
    pub inner_values_name: HashSet<InnerValueName>,
    pub labels: HashSet<LabelName>,
    pub last_register_number: u64,
    pub manual_return: bool,
    pub parent: Option<Rc<RefCell<BlockState<I>>>>,
    pub children: Vec<Rc<RefCell<BlockState<I>>>>,
    /* private fields */
}

Block state

• values - contains unique values map for current state but not unique for parent states. The map contains key-value: value_name (unique only for current state); and Value itself - value parameters.
• inner_values_name - is entity that represent inner value name - it can be different from Value name because it should be unique for all parent states. For example, of 3 values with name x, inner value name will be: [x, x.0, x.1]. It mean, inner value name can contain value counter as end of the name.
• labels - labels set, for conditional operation. Unique for current and all paren states.
• last_register_number - represent register counter for current and all parent states for Codegen. Register represented as u64 and should be linearly incremented.
• manual_return - flag indicated, that return was invoked from other state, for example: if-flow, loop-flow
• parent - represent parent states.

Fields

values: HashMap<ValueName, Value>

State values

inner_values_name: HashSet<InnerValueName>

Used to keep all names in the block state (and parent) as unique

labels: HashSet<LabelName>

State labels for conditional operations

last_register_number: u64

Last register for unique register representation

manual_return: bool

Manual return from other states

parent: Option<Rc<RefCell<BlockState<I>>>>

Parent state

children: Vec<Rc<RefCell<BlockState<I>>>>

children states

Implementations

impl<I: SemanticContextInstruction> BlockState<I>

pub fn new(parent: Option<Rc<RefCell<Self>>>) -> Self

Init block state with optional parent state

pub fn get_context(&self) -> SemanticStack<I>

pub fn inc_register(&mut self)

Increment register

pub fn set_child(&mut self, child: Rc<RefCell<Self>>)

Get child Block state

pub fn set_inner_value_name(&mut self, name: &InnerValueName)

Set value inner name to current state and parent states

pub fn is_inner_value_name_exist(&self, name: &InnerValueName) -> bool

Check is inner_value_name exist in current and parent states

pub fn get_value_name(&self, name: &ValueName) -> Option<Value>

Get Value by value name from current state. If not found on current state - recursively find in parent states.

pub fn is_label_name_exist(&self, name: &LabelName) -> bool

Check is label name exist in current and parent states

pub fn set_label_name(&mut self, name: &LabelName)

Set label name to current and all parent states

pub fn set_attr_counter(val: &str) -> String

Set attribute counter - increment, if counter exist.

pub fn get_and_set_next_label(&mut self, label: &LabelName) -> LabelName

Get and set next label for condition operations

• If label doesn’t exist in State - just insert to State and self return
• if label exists, get label counter

pub fn get_next_inner_name(&self, val: &InnerValueName) -> InnerValueName

Get next inner_value_name by name counter for current and parent states. The inner_value_name should always be unique.

pub fn set_return(&mut self)

Set return status flag for current and parent states

Trait Implementations

impl<I: Debug + SemanticContextInstruction> Debug for BlockState<I>

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

Formats the value using the given formatter.

impl<I: SemanticContextInstruction> ExtendedSemanticContext<I> for BlockState<I>

fn extended_expression(&mut self, expr: &I)

impl<I: SemanticContextInstruction> SemanticContext for BlockState<I>

fn expression_value(&mut self, expression: Value, register_number: u64)

fn expression_const(&mut self, expression: Constant, register_number: u64)

fn expression_struct_value( &mut self, expression: Value, index: u32, register_number: u64, )

fn expression_operation( &mut self, operation: ExpressionOperations, left_value: ExpressionResult, right_value: ExpressionResult, register_number: u64, )

fn call( &mut self, call: Function, params: Vec<ExpressionResult>, register_number: u64, )

fn let_binding(&mut self, let_decl: Value, expr_result: ExpressionResult)

fn binding(&mut self, val: Value, expr_result: ExpressionResult)

fn expression_function_return(&mut self, expr_result: ExpressionResult)

fn expression_function_return_with_label( &mut self, expr_result: ExpressionResult, )

fn set_label(&mut self, label: LabelName)

fn jump_to(&mut self, label: LabelName)

fn if_condition_expression( &mut self, expr_result: ExpressionResult, label_if_begin: LabelName, label_if_end: LabelName, )

fn condition_expression( &mut self, left_result: ExpressionResult, right_result: ExpressionResult, condition: Condition, register_number: u64, )

fn jump_function_return(&mut self, expr_result: ExpressionResult)

fn logic_condition( &mut self, logic_condition: LogicCondition, left_register_result: u64, right_register_result: u64, register_number: u64, )

fn if_condition_logic( &mut self, label_if_begin: LabelName, label_if_end: LabelName, result_register: u64, )

fn function_arg(&mut self, value: Value, func_arg: FunctionParameter)