From bd67b3f387dab3de8741fd6523d720d9767b1077 Mon Sep 17 00:00:00 2001
From: pca006132 <jl@m-labs.hk>
Date: Thu, 31 Dec 2020 11:27:18 +0800
Subject: [PATCH] added primitives

---
 nac3core/src/lib.rs        |   1 +
 nac3core/src/primitives.rs | 181 +++++++++++++++++++++++++++++++++++++
 2 files changed, 182 insertions(+)
 create mode 100644 nac3core/src/primitives.rs

diff --git a/nac3core/src/lib.rs b/nac3core/src/lib.rs
index 25654b5537..801fcc466a 100644
--- a/nac3core/src/lib.rs
+++ b/nac3core/src/lib.rs
@@ -2,6 +2,7 @@ extern crate num_bigint;
 extern crate inkwell;
 extern crate rustpython_parser;
 
+pub mod primitives;
 pub mod typedef;
 
 use std::error::Error;
diff --git a/nac3core/src/primitives.rs b/nac3core/src/primitives.rs
new file mode 100644
index 0000000000..25b5cc3d84
--- /dev/null
+++ b/nac3core/src/primitives.rs
@@ -0,0 +1,181 @@
+use super::typedef::{Type::*, *};
+use std::collections::HashMap;
+use std::rc::Rc;
+
+pub const TUPLE_TYPE: ParamId = ParamId(0);
+pub const LIST_TYPE: ParamId = ParamId(1);
+
+pub const BOOL_TYPE: PrimitiveId = PrimitiveId(0);
+pub const INT32_TYPE: PrimitiveId = PrimitiveId(1);
+pub const INT64_TYPE: PrimitiveId = PrimitiveId(2);
+pub const FLOAT_TYPE: PrimitiveId = PrimitiveId(3);
+
+fn impl_math(def: &mut TypeDef, ty: &Rc<Type>) {
+    let result = Some(ty.clone());
+    let fun = FnDef {
+        args: vec![ty.clone()],
+        result: result.clone(),
+    };
+    def.methods.insert("__add__", fun.clone());
+    def.methods.insert("__sub__", fun.clone());
+    def.methods.insert("__mul__", fun.clone());
+    def.methods.insert("__neg__", FnDef {
+        args: vec![],
+        result
+    });
+    def.methods.insert(
+        "__truediv__",
+        FnDef {
+            args: vec![ty.clone()],
+            result: Some(PrimitiveType(FLOAT_TYPE).into()),
+        },
+    );
+    def.methods.insert("__floordiv__", fun.clone());
+    def.methods.insert("__mod__", fun.clone());
+    def.methods.insert("__pow__", fun.clone());
+}
+
+fn impl_bits(def: &mut TypeDef, ty: &Rc<Type>) {
+    let result = Some(ty.clone());
+    let fun = FnDef {
+        args: vec![PrimitiveType(INT32_TYPE).into()],
+        result,
+    };
+
+    def.methods.insert("__lshift__", fun.clone());
+    def.methods.insert("__rshift__", fun.clone());
+    def.methods.insert(
+        "__xor__",
+        FnDef {
+            args: vec![ty.clone()],
+            result: Some(ty.clone()),
+        },
+    );
+}
+
+fn impl_eq(def: &mut TypeDef, ty: &Rc<Type>) {
+    let fun = FnDef {
+        args: vec![ty.clone()],
+        result: Some(PrimitiveType(BOOL_TYPE).into()),
+    };
+
+    def.methods.insert("__eq__", fun.clone());
+    def.methods.insert("__ne__", fun.clone());
+}
+
+fn impl_order(def: &mut TypeDef, ty: &Rc<Type>) {
+    let fun = FnDef {
+        args: vec![ty.clone()],
+        result: Some(PrimitiveType(BOOL_TYPE).into()),
+    };
+
+    def.methods.insert("__lt__", fun.clone());
+    def.methods.insert("__gt__", fun.clone());
+    def.methods.insert("__le__", fun.clone());
+    def.methods.insert("__ge__", fun.clone());
+}
+
+pub fn basic_ctx() -> GlobalContext<'static> {
+    let primitives = [
+        TypeDef {
+            name: "bool",
+            fields: HashMap::new(),
+            methods: HashMap::new(),
+        },
+        TypeDef {
+            name: "int32",
+            fields: HashMap::new(),
+            methods: HashMap::new(),
+        },
+        TypeDef {
+            name: "int64",
+            fields: HashMap::new(),
+            methods: HashMap::new(),
+        },
+        TypeDef {
+            name: "float",
+            fields: HashMap::new(),
+            methods: HashMap::new(),
+        },
+    ]
+    .to_vec();
+    let mut ctx = GlobalContext::new(primitives);
+
+    let b_def = ctx.get_primitive_mut(BOOL_TYPE);
+    let b = PrimitiveType(BOOL_TYPE).into();
+    impl_eq(b_def, &b);
+    let int32_def = ctx.get_primitive_mut(INT32_TYPE);
+    let int32 = PrimitiveType(INT32_TYPE).into();
+    impl_math(int32_def, &int32);
+    impl_bits(int32_def, &int32);
+    impl_order(int32_def, &int32);
+    impl_eq(int32_def, &int32);
+    let int64_def = ctx.get_primitive_mut(INT64_TYPE);
+    let int64 = PrimitiveType(INT64_TYPE).into();
+    impl_math(int64_def, &int64);
+    impl_bits(int64_def, &int64);
+    impl_order(int64_def, &int64);
+    impl_eq(int64_def, &int64);
+    let float_def = ctx.get_primitive_mut(FLOAT_TYPE);
+    let float = PrimitiveType(FLOAT_TYPE).into();
+    impl_math(float_def, &float);
+    impl_order(float_def, &float);
+    impl_eq(float_def, &float);
+
+    let t = ctx.add_variable_private(VarDef {
+        name: "T",
+        bound: vec![],
+    });
+
+    ctx.add_parametric(ParametricDef {
+        base: TypeDef {
+            name: "tuple",
+            fields: HashMap::new(),
+            methods: HashMap::new(),
+        },
+        // we have nothing for tuple, so no param def
+        params: vec![],
+    });
+
+    ctx.add_parametric(ParametricDef {
+        base: TypeDef {
+            name: "list",
+            fields: HashMap::new(),
+            methods: HashMap::new(),
+        },
+        params: vec![t],
+    });
+
+    let i = ctx.add_variable_private(VarDef {
+        name: "I",
+        bound: vec![
+            PrimitiveType(INT32_TYPE).into(),
+            PrimitiveType(INT64_TYPE).into(),
+            PrimitiveType(FLOAT_TYPE).into(),
+        ],
+    });
+    let args = vec![TypeVariable(i).into()];
+    ctx.add_fn(
+        "int32",
+        FnDef {
+            args: args.clone(),
+            result: Some(PrimitiveType(INT32_TYPE).into()),
+        },
+    );
+    ctx.add_fn(
+        "int64",
+        FnDef {
+            args: args.clone(),
+            result: Some(PrimitiveType(INT64_TYPE).into()),
+        },
+    );
+    ctx.add_fn(
+        "float",
+        FnDef {
+            args: args.clone(),
+            result: Some(PrimitiveType(FLOAT_TYPE).into()),
+        },
+    );
+
+    ctx
+}