py_ir/
value.rs

1use std::fmt::Write;
2
3use py_lex::ops::Operators;
4
5use crate::types::{PrimitiveType, TypeDefine};
6
7#[derive(serde::Serialize, serde::Deserialize, Debug, Clone)]
8pub enum Value {
9    Variable(String),
10    Literal(Literal, PrimitiveType),
11}
12
13/// [`Operate::Unary`] and [`Operate::Binary`] are normal operations aroud primitives
14///
15/// computes around non-primitive types are turned into [FnCall]
16#[derive(serde::Serialize, serde::Deserialize, Debug, Clone)]
17pub enum Operate {
18    Unary(Operators, Value),
19    Binary(Operators, Value, Value),
20}
21
22#[derive(serde::Serialize, serde::Deserialize, Debug, Clone)]
23pub enum AssignValue {
24    Value(Value),
25    FnCall(FnCall<Value>),
26    Operate(Operate, PrimitiveType),
27}
28
29impl From<Value> for AssignValue {
30    fn from(v: Value) -> Self {
31        Self::Value(v)
32    }
33}
34
35impl From<FnCall<Value>> for AssignValue {
36    fn from(v: FnCall<Value>) -> Self {
37        Self::FnCall(v)
38    }
39}
40
41impl From<(Operate, PrimitiveType)> for AssignValue {
42    fn from(value: (Operate, PrimitiveType)) -> Self {
43        Self::Operate(value.0, value.1)
44    }
45}
46
47impl super::IRValue for Value {
48    type AssignValue = AssignValue;
49    type VarDefineType = TypeDefine;
50    type FnDefineType = TypeDefine;
51    type ParameterType = TypeDefine;
52}
53
54#[derive(serde::Serialize, serde::Deserialize, Debug, Clone)]
55pub struct FnCall<Var> {
56    #[serde(rename = "fn")]
57    pub fn_name: String,
58    pub args: Vec<Var>,
59}
60
61/// [`Literal::Char`], [`Literal::Integer`] and [`Literal::Float`]
62/// mean literals
63///
64/// althogn [`String`] is also [`Literal`], it will be replaced with [`VarDefine`] statement
65/// so that the type of [`Literal`] can be represented by [`PrimitiveType`]
66///
67/// [`VarDefine`]: super
68#[derive(serde::Serialize, serde::Deserialize, Debug, Clone)]
69pub enum Literal {
70    Char(char),
71    Integer(usize),
72    Float(f64),
73}
74
75impl std::fmt::Display for Literal {
76    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
77        match self {
78            Literal::Char(ch) => f.write_char(*ch),
79            Literal::Integer(nu) => f.write_fmt(format_args!("{nu}")),
80            Literal::Float(fl) => f.write_fmt(format_args!("{fl}")),
81        }
82    }
83}