Rotth is a stack based concatenative language highly inspired by Porth
Started working on includes
Ivan Chinenov
(Mar 10, 2022, 1:19 AM +0300)
76e74558
f25ca8ec
+35
-36
+1
-1
src/emit.rs
+1
-1
src/emit.rs
+1
-1
src/eval.rs
+1
-1
src/eval.rs
+21
-1
src/hir.rs
+21
-1
src/hir.rs
···
553
553
})
554
554
}
555
555
556
+
fn include() -> impl Parser<Token, (String, (TopLevel, Span)), Error = Simple<Token, Span>> {
557
+
just(Token::KeyWord(KeyWord::Include))
558
+
.ignore_then(
559
+
filter(|token| matches!(token, Token::Str(_))).map(|token| match token {
560
+
Token::Str(s) => s,
561
+
_ => unreachable!(),
562
+
}),
563
+
)
564
+
.map_with_span(|path, span| (String::new(), (TopLevel::Include(path), span)))
565
+
}
566
+
556
567
#[derive(Debug, Clone)]
557
568
pub enum TopLevel {
558
569
Proc(Proc),
559
570
Const(Const),
571
+
Include(String),
560
572
}
561
573
impl TopLevel {
562
574
pub fn as_proc(&self) -> Option<&Proc> {
···
574
586
None
575
587
}
576
588
}
589
+
590
+
pub fn as_include(&self) -> Option<&String> {
591
+
if let Self::Include(v) = self {
592
+
Some(v)
593
+
} else {
594
+
None
595
+
}
596
+
}
577
597
}
578
598
579
599
pub fn procs() -> impl Parser<Token, HashMap<String, (TopLevel, Span)>, Error = Simple<Token, Span>>
580
600
{
581
-
choice((proc(), constant()))
601
+
choice((proc(), constant(), include()))
582
602
.repeated()
583
603
.then_ignore(end())
584
604
.collect()
+2
src/lexer.rs
+2
src/lexer.rs
···
27
27
28
28
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
29
29
pub enum KeyWord {
30
+
Include,
30
31
If,
31
32
Else,
32
33
Proc,
···
89
90
90
91
let keyword = word_parser().try_map(|i: String, s| {
91
92
Token::KeyWord(match i.as_str() {
93
+
"include" => KeyWord::Include,
92
94
"if" => KeyWord::If,
93
95
"else" => KeyWord::Else,
94
96
"proc" => KeyWord::Proc,
+1
src/lib.rs
+1
src/lib.rs
+3
-3
src/lir.rs
+3
-3
src/lir.rs
···
148
148
Type::Bool => IConst::Bool(bytes != 0),
149
149
Type::U64 => IConst::U64(bytes),
150
150
Type::I64 => IConst::I64(bytes as i64),
151
-
Type::Ptr => todo!(),
151
+
Type::Ptr => IConst::Ptr(bytes),
152
152
},
153
153
Err(req) => {
154
154
self.compile_const(req);
···
164
164
Type::Bool => IConst::Bool(bytes != 0),
165
165
Type::U64 => IConst::U64(bytes),
166
166
Type::I64 => IConst::I64(bytes as i64),
167
-
Type::Ptr => todo!(),
167
+
Type::Ptr => IConst::Ptr(bytes),
168
168
},
169
169
Err(_) => unreachable!(),
170
170
}
···
221
221
},
222
222
AstKind::If(cond) => self.compile_cond(cond),
223
223
AstKind::While(while_) => self.compile_while(while_),
224
-
AstKind::Bind(_) => todo!(),
224
+
AstKind::Bind(_) => todo!("Bind"),
225
225
}
226
226
}
227
227
}
+6
-30
src/typecheck.rs
+6
-30
src/typecheck.rs
···
73
73
.clone();
74
74
let const_ = match const_ {
75
75
TopLevel::Const(c) => c,
76
-
TopLevel::Proc(_) => {
77
-
return error(
78
-
span,
79
-
Unexpected,
80
-
format!("Unexpected const {}, expected proc", const_name),
81
-
)
82
-
}
76
+
_ => unreachable!("This can't not be const"),
83
77
};
84
78
if typechecked {
85
79
return ().okay();
···
128
122
.clone();
129
123
let proc = match proc {
130
124
TopLevel::Proc(p) => p,
131
-
TopLevel::Const(_) => {
132
-
return error(
133
-
span,
134
-
Unexpected,
135
-
format!("Unexpected const {}, expected proc", name),
136
-
)
137
-
}
125
+
_ => unreachable!("This can't not be proc"),
138
126
};
139
127
if typechecked {
140
128
return ().okay();
···
179
167
}
180
168
181
169
fn is_proc(name: &str, items: &HashMap<String, (TopLevel, Span, bool)>) -> bool {
182
-
match items.get(name) {
183
-
Some((t, _, _)) => match t {
184
-
TopLevel::Proc(_) => true,
185
-
TopLevel::Const(_) => false,
186
-
},
187
-
None => false,
188
-
}
170
+
matches!(items.get(name), Some((TopLevel::Proc(_), _, _)))
189
171
}
190
172
fn is_const(name: &str, items: &HashMap<String, (TopLevel, Span, bool)>) -> bool {
191
-
match items.get(name) {
192
-
Some((t, _, _)) => match t {
193
-
TopLevel::Proc(_) => false,
194
-
TopLevel::Const(_) => true,
195
-
},
196
-
None => false,
197
-
}
173
+
matches!(items.get(name), Some((TopLevel::Const(_), _, _)))
198
174
}
199
175
200
176
fn typecheck_body(
···
316
292
stack.push(heap, Type::U64)
317
293
}
318
294
Intrinsic::WriteU8 => {
319
-
todo!()
295
+
todo!("Write u8")
320
296
}
321
297
Intrinsic::PtrAdd => {
322
298
let offset = stack.pop(heap).ok_or_else(|| {
···
464
440
);
465
441
}
466
442
}
467
-
AstKind::Bind(_bind) => todo!(),
443
+
AstKind::Bind(_bind) => todo!("Bind"),
468
444
}
469
445
}
470
446
().okay()