tin 0.3.0

tin: a statically structurally typed embeddable programming language
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

//! Mappings to ABI-specific types.
use std::u16;
use std::u32;
use std::u64;
use std::u8;

use crate::ir::component::ty;

use cranelift::prelude::*;

#[derive(Clone, Copy, Debug)]
pub enum AbiType {
    Scalar(Type),
    Ptr,
}

#[derive(Clone, Debug)]
pub struct AbiSignature<'a> {
    pub params: &'a [AbiType],
    pub returns: &'a [AbiType],
}

impl AbiType {
    /// Create an ABI-specific type given an IR type.
    pub fn from_ir_type(ir_type: &ty::Type) -> AbiType {
        match *ir_type {
            ty::Type::Number(ref n) => AbiType::from_ir_number_type(n),
            ty::Type::String => AbiType::Ptr,
            ty::Type::Symbol(_) => AbiType::Scalar(types::I8),
            ty::Type::Tuple(_) => AbiType::Ptr,
            ty::Type::Union(ty::Union { ref alternatives }) => {
                let n = alternatives.len();

                // Assumes unions only store symbols for now
                if n <= 2 {
                    AbiType::Scalar(types::B1)
                } else if n <= u8::MAX as usize {
                    AbiType::Scalar(types::I8)
                } else if n <= u16::MAX as usize {
                    AbiType::Scalar(types::I16)
                } else if n <= u32::MAX as usize {
                    AbiType::Scalar(types::I32)
                } else if n <= u64::MAX as usize {
                    AbiType::Scalar(types::I64)
                } else {
                    unimplemented!()
                }
            }
            ty::Type::Record(_) => AbiType::Ptr,
            ty::Type::Function(_) => AbiType::Ptr,
        }
    }

    pub fn into_specific(self, ptr_type: Type) -> Type {
        match self {
            AbiType::Scalar(ty) => ty,
            AbiType::Ptr => ptr_type,
        }
    }

    fn from_ir_number_type(ir_type: &ty::Number) -> AbiType {
        match *ir_type {
            ty::Number::U8 => AbiType::Scalar(types::I8),
            ty::Number::U16 => AbiType::Scalar(types::I16),
            ty::Number::U32 => AbiType::Scalar(types::I32),
            ty::Number::U64 => AbiType::Scalar(types::I64),
            ty::Number::I8 => AbiType::Scalar(types::I8),
            ty::Number::I16 => AbiType::Scalar(types::I16),
            ty::Number::I32 => AbiType::Scalar(types::I32),
            ty::Number::I64 => AbiType::Scalar(types::I64),
            ty::Number::F32 => AbiType::Scalar(types::F32),
            ty::Number::F64 => AbiType::Scalar(types::F64),
        }
    }
}