act_lib/
act_structs.rs

1#[derive(Debug)]
2pub struct PatchAct {
3    pub byte_pos: u32,
4    pub patch: Vec<u8>,
5}
6
7#[derive(Debug)]
8pub struct FunctionAct {
9    pub name: String,
10    pub params: Vec<ParamAct>,
11    pub body_start: u32,
12}
13
14#[derive(Debug)]
15pub struct MethodAct {
16    pub function: FunctionAct,
17}
18
19#[derive(Debug)]
20pub struct ClassAct {
21    pub name: String,
22    pub methods: Vec<MethodAct>,
23}
24
25#[derive(Debug, PartialEq)]
26pub enum TypeAct {
27    Number,
28    String,
29    BigInt,
30    Boolean,
31    Symbol,
32    Float32Array,
33    Float64Array,
34    Int8Array,
35    Int16Array,
36    Int32Array,
37    Uint8Array,
38    Uint8ClampedArray,
39    Uint16Array,
40    Uint32Array,
41    BigInt64Array,
42    BigUint64Array,
43    Unknown,
44}
45#[derive(Debug)]
46pub struct ParamAct {
47    pub name: String,
48    pub act_type: TypeAct,
49}
50
51pub fn get_ts_type_from_acttype(act_type: &TypeAct) -> String {
52    match act_type {
53        TypeAct::Number => "number".to_string(),
54        TypeAct::String => "string".to_string(),
55        TypeAct::BigInt => "bigint".to_string(),
56        TypeAct::Boolean => "boolean".to_string(),
57        TypeAct::Symbol => "symbol".to_string(),
58        TypeAct::Float32Array => "Float32Array".to_string(),
59        TypeAct::Float64Array => "Float64Array".to_string(),
60        TypeAct::Int8Array => "Int8Array".to_string(),
61        TypeAct::Int16Array => "Int16Array".to_string(),
62        TypeAct::Int32Array => "Int32Array".to_string(),
63        TypeAct::Uint8Array => "Uint8Array".to_string(),
64        TypeAct::Uint8ClampedArray => "Uint8ClampedArray".to_string(),
65        TypeAct::Uint16Array => "Uint16Array".to_string(),
66        TypeAct::Uint32Array => "Uint32Array".to_string(),
67        TypeAct::BigInt64Array => "BigInt64Array".to_string(),
68        TypeAct::BigUint64Array => "BigUint64Array".to_string(),
69        TypeAct::Unknown => "unknown".to_string(),
70    }
71}
72
73pub fn get_js_constructor_from_acttype(act_type: &TypeAct) -> String {
74    match act_type {
75        TypeAct::Number => "Number".to_string(),
76        TypeAct::String => "String".to_string(),
77        TypeAct::BigInt => "BigInt".to_string(),
78        TypeAct::Boolean => "Boolean".to_string(),
79        TypeAct::Symbol => "Symbol".to_string(),
80        TypeAct::Float32Array => "new Float32Array".to_string(),
81        TypeAct::Float64Array => "new Float64Array".to_string(),
82        TypeAct::Int8Array => "new Int8Array".to_string(),
83        TypeAct::Int16Array => "new Int16Array".to_string(),
84        TypeAct::Int32Array => "new Int32Array".to_string(),
85        TypeAct::Uint8Array => "new Uint8Array".to_string(),
86        TypeAct::Uint8ClampedArray => "new Uint8ClampedArray".to_string(),
87        TypeAct::Uint16Array => "new Uint16Array".to_string(),
88        TypeAct::Uint32Array => "new Uint32Array".to_string(),
89        TypeAct::BigInt64Array => "new BigInt64Array".to_string(),
90        TypeAct::BigUint64Array => "new BigUint64Array".to_string(),
91        TypeAct::Unknown => "".to_string(),
92    }
93}
94
95pub fn get_acttype_from_string(type_str: &str) -> TypeAct {
96    match type_str {
97        "number" => TypeAct::Number,
98        "string" => TypeAct::String,
99        "bigint" => TypeAct::BigInt,
100        "boolean" => TypeAct::Boolean,
101        "symbol" => TypeAct::Symbol,
102        "object" => TypeAct::Unknown,
103        "unknown" => TypeAct::Unknown,
104        "Float32Array" => TypeAct::Float32Array,
105        "Float64Array" => TypeAct::Float64Array,
106        "Int8Array" => TypeAct::Int8Array,
107        "Int16Array" => TypeAct::Int16Array,
108        "Int32Array" => TypeAct::Int32Array,
109        "Uint8Array" => TypeAct::Uint8Array,
110        "Uint8ClampedArray" => TypeAct::Uint8ClampedArray,
111        "Uint16Array" => TypeAct::Uint16Array,
112        "Uint32Array" => TypeAct::Uint32Array,
113        "BigInt64Array" => TypeAct::BigInt64Array,
114        "BigUint64Array" => TypeAct::BigUint64Array,
115        _ => TypeAct::Unknown,
116    }
117}
118
119pub fn get_typeinfo_operator_from_acttype(act_type: &TypeAct) -> String {
120    match act_type {
121        TypeAct::Number => "typeof".to_string(),
122        TypeAct::String => "typeof".to_string(),
123        TypeAct::BigInt => "typeof".to_string(),
124        TypeAct::Boolean => "typeof".to_string(),
125        TypeAct::Symbol => "typeof".to_string(),
126        TypeAct::Float32Array => "instanceof".to_string(),
127        TypeAct::Float64Array => "instanceof".to_string(),
128        TypeAct::Int8Array => "instanceof".to_string(),
129        TypeAct::Int16Array => "instanceof".to_string(),
130        TypeAct::Int32Array => "instanceof".to_string(),
131        TypeAct::Uint8Array => "instanceof".to_string(),
132        TypeAct::Uint8ClampedArray => "instanceof".to_string(),
133        TypeAct::Uint16Array => "instanceof".to_string(),
134        TypeAct::Uint32Array => "instanceof".to_string(),
135        TypeAct::BigInt64Array => "instanceof".to_string(),
136        TypeAct::BigUint64Array => "instanceof".to_string(),
137        TypeAct::Unknown => "".to_string(),
138    }
139}