pr47 0.0.3

A semi-experimental programming language. Still working in progress.
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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166

use crate::syntax::id::Identifier;
use crate::util::location::{SingleLineRange, SourceLocation};
use crate::syntax::ty::CSTType;

#[derive(Debug)]
pub enum CSTExpr {
    LiteralExpr(CSTLiteralExpr),
    StringLiteralExpr(CSTStringLiteralExpr),
    IdRefExpr(CSTIdRefExpr),
    UnaryExpr(CSTUnaryExpr),
    BinaryExpr(CSTBinaryExpr),
    AssignExpr(CSTAssignExpr),
    FuncCallExpr(CSTFuncCallExpr),
    SubscriptExpr(CSTSubscriptExpr),
    FieldRefExpr(CSTFieldRefExpr),
    MethodCallExpr(CSTMethodCallExpr),
    AsExpr(CSTAsExpr)
}

#[derive(Debug)]
pub struct CSTLiteralExpr {
    pub content: LiteralExprContent,
    pub range: SingleLineRange
}

#[derive(Debug)]
pub enum LiteralExprContent {
    Byte(u8),
    Int(i64),
    Float(f64),
    Char(char),
    Boolean(bool)
}

#[derive(Debug)]
pub struct CSTIdRefExpr {
    pub id: Identifier
}

#[derive(Debug)]
pub struct CSTStringLiteralExpr {
    pub value: String,
    pub range: SingleLineRange
}

#[derive(Debug)]
pub enum UnaryOp {
    BitNot,
    Not,
    Negate
}

impl UnaryOp {
    pub fn as_str(&self) -> &'static str {
        use UnaryOp::*;
        match self {
            BitNot => "~",
            Not => "!",
            Negate => "-"
        }
    }
}

#[derive(Debug)]
pub struct CSTUnaryExpr {
    pub op: UnaryOp,
    pub operand: Box<CSTExpr>,

    pub op_loc: SourceLocation
}

#[derive(Debug)]
pub enum BinaryOp {
    BitAnd, BitOr, BitXor,
    Add, Sub,
    Mul, Div, Mod,
    Lt, Gt, Eq, LEq, GEq, NEq,
    And, Or, Xor
}

impl BinaryOp {
    pub fn as_str(&self) -> &'static str {
        use BinaryOp::*;
        match self {
            BitAnd => "&",
            BitOr => "|",
            BitXor => "^",
            Add => "+",
            Sub => "-",
            Mul => "*",
            Div => "/",
            Mod => "%",
            Lt => "<",
            Gt => ">",
            Eq => "==",
            LEq => "<=",
            GEq => ">=",
            NEq => "!=",
            And => "&&",
            Or => "||",
            Xor => "^^"
        }
    }
}

#[derive(Debug)]
pub struct CSTBinaryExpr {
    pub op: BinaryOp,
    pub lhs: Box<CSTExpr>,
    pub rhs: Box<CSTExpr>,

    pub op_loc: SingleLineRange
}

#[derive(Debug)]
pub struct CSTAssignExpr {
    pub lhs: Box<CSTExpr>,
    pub rhs: Box<CSTExpr>,

    pub op_loc: SourceLocation
}

#[derive(Debug)]
pub struct CSTFuncCallExpr {
    pub func: Box<CSTExpr>,
    pub args: Vec<Box<CSTExpr>>,

    pub left_paren: SourceLocation,
    pub right_paren: SourceLocation
}

#[derive(Debug)]
pub struct CSTSubscriptExpr {
    pub base: Box<CSTExpr>,
    pub idx: Box<CSTExpr>,

    pub left_bracket: SourceLocation,
    pub right_bracket: SourceLocation
}

#[derive(Debug)]
pub struct CSTFieldRefExpr {
    pub base: Box<CSTExpr>,
    pub id: Identifier,

    pub dot_loc: SourceLocation
}

#[derive(Debug)]
pub struct CSTMethodCallExpr {
    pub base: Box<CSTExpr>,
    pub func_id: Identifier,
    pub args: Vec<Box<CSTExpr>>,

    pub dot_loc: SourceLocation,
    pub left_paren: SourceLocation,
    pub right_paren: SourceLocation
}

#[derive(Debug)]
pub struct CSTAsExpr {
    pub operand: Box<CSTExpr>,
    pub dest_type: CSTType,

    pub as_range: SingleLineRange
}