Struct semantic_analyzer::semantic::State

pub struct State {
    pub global: GlobalState,
    pub context: Vec<Rc<RefCell<BlockState>>>,
    pub errors: Vec<StateErrorResult>,
}

State

Basic entity that contains Global State and Codegen tree.

• errors - State analyzing errors

Fields

global: GlobalState

context: Vec<Rc<RefCell<BlockState>>>

errors: Vec<StateErrorResult>

Implementations

impl State

pub fn new() -> Self

Init new State

pub fn run(&mut self, data: &Main<'_>)

Run semantic analyzer that covers all flow

pub const fn import(&self, _data: &ImportPath<'_>)

Import analyzer

pub fn types(&mut self, data: &StructTypes<'_>)

Types declaration analyzer. Add types to Global State. Currently only one type kind: Structs

pub fn constant(&mut self, data: &Constant<'_>)

Constant analyzer. Add it got Global State

pub fn function_declaration(&mut self, data: &FunctionStatement<'_>)

Function declaration analyze. Add it to Global State/

pub fn function_body(&mut self, data: &FunctionStatement<'_>)

Function body analyze. It is basic execution entity for program flow. It’s operate sub analyze for function elements. It’s contain Body State for current and child states.

pub fn let_binding( &mut self, data: &LetBinding<'_>, function_state: &Rc<RefCell<BlockState>> )

Let-binding statement

Analyze let-binding statement:

1. Let value bind from expression. First should be analysed expression for binding value.
2. Generate value for current state. Special field inner_name that used as name for Codegen should be unique in current state and for all parent states. For that inner_name the inner value name counter incremented.
3. Set Value parameters: inner_name, type and allocation status
4. Insert value to current values state map: value name -> Data
5. Store inner_name in current and parent states
6. Codegen

pub fn binding( &mut self, data: &Binding<'_>, function_state: &Rc<RefCell<BlockState>> )

Binding statement

Analyze binding statement for mutable variables:

1. Bind from expression. First should be analysed expression for binding value.
2. Read value for current state.
3. Update value to current values state map: value name -> Data
4. Codegen with Store action

pub fn function_call( &mut self, data: &FunctionCall<'_>, body_state: &Rc<RefCell<BlockState>> ) -> Option<Type>

Function-call

Call function with function parameters arguments. Arguments is expressions.

1. Check is current function name exists in global state of functions name.
2. Analyse expressions for function parameters
3. Inc register
4. Generate codegen Codegen store always result to register even for void result.

Errors

Return error if function name doesn’t exist in global state

pub fn condition_expression( &mut self, data: &ExpressionLogicCondition<'_>, function_body_state: &Rc<RefCell<BlockState>> )

condition-expression

Analyse condition operations.

pub fn if_condition_body( &mut self, body: &[IfBodyStatement<'_>], if_body_state: &Rc<RefCell<BlockState>> )

If-condition body

Analyze body for ant if condition:

• if, else, if-else

pub fn if_condition_loop_body( &mut self, body: &[IfLoopBodyStatement<'_>], if_body_state: &Rc<RefCell<BlockState>>, label_loop_start: &LabelName, label_loop_end: &LabelName )

If-condition loop body

Analyze body for ant if condition:

• if, else, if-else

pub fn if_condition_calculation( &mut self, condition: &IfCondition<'_>, if_body_state: &Rc<RefCell<BlockState>>, label_if_begin: &LabelName, label_if_else: &LabelName, label_if_end: &LabelName, is_else: bool )

If conditions calculations

Calculate conditions for if-condition. It can contain simple and logic conditions.

pub fn if_condition( &mut self, data: &IfStatement<'_>, function_body_state: &Rc<RefCell<BlockState>>, label_end: Option<LabelName>, label_loop: Option<(&LabelName, &LabelName)> )

If-condition

Analyzing includes all variants for if statements:

1. if
2. if-else
3. if-else-if It creates own state, with parent function-state. in that case if-state independent from parent state, but csn get access to parent state. If condition can’t contain else and if-else on the same time.

Special case for label_end - it should be set from previous context, and main goal is to end all of if-condition nodes in the same flow with same if-end label. It’s especially important for else-if condition.

pub fn loop_statement( &mut self, data: &[LoopBodyStatement<'_>], function_body_state: &Rc<RefCell<BlockState>> )

Loop

Loop statement contains logic:

• jump to loop
• loop body
• end of loop
• return, break, continue

pub fn expression( &mut self, data: &Expression<'_>, body_state: &Rc<RefCell<BlockState>> ) -> Option<ExpressionResult>

Expression

Is basic entity for state operation and state usage. State correctness verified by expressions call. Expressions folded by operations priority. For that expressions tree folded each leaf of tree by priority operation level. The most striking image is bracketing an expression with a higher priority, and build tree based on that.

Return

PrimitiveValue | TmpRegister

Possible algorithm conditions: 1. PrimitiveValue -> PrimitiveValue 2. Value -> load -> TmpRegister 3. FuncCall -> call -> TmpRegister 4. Operations 4.1. PrimitiveValue - PrimitiveValue -> tmp = OP val1, val2 -> TmpRegister - Value -> tmp1 = load -> OP val1, tmp1 -> TmpRegister - FuncCAll -> tmp1 = call -> OP val1, tmp1 -> TmpRegister 4.2. TmpRegister (with name tmp1) - PrimitiveValue -> tmp2 = OP tmp1, val1 -> TmpRegister - Value -> tmp2 = load -> tmp3 = OP tmp1, tmp2 -> TmpRegister - FuncCall -> tmp2 = call -> tmp3 = OP tmp1, tmp2 -> TmpRegister 4.3. Operations -> recursively invoke 4.2.

pub fn expression_operation( &mut self, left_value: Option<&ExpressionResult>, right_expression: &Expression<'_>, op: Option<&ExpressionOperations>, body_state: &Rc<RefCell<BlockState>> ) -> Option<ExpressionResult>

Expression operation semantic logic: OP(lhs, rhs) Left-value contains optional Exrpression result for left side of expression.

Trait Implementations

impl Debug for State

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

Formats the value using the given formatter.

impl Default for State

fn default() -> Self

Returns the “default value” for a type.