bog
/
xmk
Archived
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: bog:a0b8cda00d73c53b538c0711849a1bfece1eeecb
Branches Tags
bog:main
..
compare: bog:6e94192fa942b70351b1cf58dcfd7ef9c237c294
Branches Tags
bog:main

No commits in common. "a0b8cda00d73c53b538c0711849a1bfece1eeecb" and "6e94192fa942b70351b1cf58dcfd7ef9c237c294" have entirely different histories.
a0b8cda00d ... 6e94192fa9

6 changed files with 25 additions and 279 deletions
Show Stats Expand all files Collapse all files

6
doc/grammar.bnf
View File

@ -1,8 +1,4 @@
MODULE ::= INSTR*
INSTR ::= EXPR semicolon
EXPR ::= BUILTIN
BUILTIN ::=
| bool
| float
| int
| string
BUILTIN ::= bool

207
src/ast/lexer.rs
View File

@ -1,8 +1,8 @@
use crate::ast::node::Node;
use crate::ast::node;
struct Token {
position: usize,
value: String
value: String,
}
pub struct Lexer {
@ -53,128 +53,6 @@ impl Lexer {
false
}
fn scan_string(&mut self) -> Option<Token> {
let mut value : String;
let mut length = 1;
if let Some('"') = self.text.chars().nth(self.cursor) {
value = String::from("");
} else {
return None;
}
let mut escape = false;
let mut closed = false;
for c in self.text.chars().skip(length + self.cursor) {
if !escape && c == '\\' {
escape = true;
length += 1;
continue;
}
if escape {
match c {
'"' => value.push('"'),
'\\' => value.push('\\'),
'n' => value.push('\n'),
't' => value.push('\t'),
'r' => value.push('\r'),
_ => {}
}
} else if c == '"' {
closed = true;
break;
} else {
value.push(c);
}
escape = false;
length += 1;
}
if length >= 2 && closed {
return Some(Token {
position: 1 + self.cursor + length,
value
});
}
None
}
fn scan_int(&self) -> Option<Token> {
let mut value = String::from("");
if let Some('-') = self.text.chars().nth(self.cursor) {
value.push('-');
}
for c in self.text.chars().skip(self.cursor + value.len()) {
if c.is_digit(10) {
value.push(c);
} else {
break;
}
}
if value.len() > 0 {
Some(Token {
position: self.cursor + value.len(),
value
})
} else {
None
}
}
fn scan_float(&self) -> Option<Token> {
let mut value = String::from("");
if let Some('-') = self.text.chars().nth(self.cursor) {
value.push('-');
}
for c in self.text.chars().skip(self.cursor + value.len()) {
if c.is_digit(10) {
value.push(c);
} else {
break;
}
}
if let Some('.') = self.text.chars().nth(self.cursor + value.len()) {
value.push('.');
} else {
return None;
}
for c in self.text.chars().skip(self.cursor + value.len()) {
if c.is_digit(10) {
value.push(c);
} else {
break;
}
}
if value.len() > 0 && value != "." {
if value.chars().nth(0).unwrap() == '.' {
value = format!("0{}", value);
}
if value.chars().last().unwrap() == '.' {
value = format!("{}0", value);
}
Some(Token {
position: self.cursor + value.len(),
value
})
} else {
None
}
}
fn scan_text(&self, text: &str) -> Option<Token> {
let c = self.cursor;
@ -234,43 +112,24 @@ impl Lexer {
}
impl Iterator for Lexer {
type Item = Node;
type Item = node::Node;
fn next(&mut self) -> Option<Self::Item> {
self.skip_spaces();
if let Some(token) = self.scan_keyword("true") {
self.cursor = token.position;
return Some(Node::Bool(token.value == "true"));
return Some(node::Node::Bool(token.value == "true"));
}
if let Some(token) = self.scan_keyword("false") {
self.cursor = token.position;
return Some(Node::Bool(token.value == "true"));
return Some(node::Node::Bool(token.value == "true"));
}
if let Some(token) = self.scan_text(";") {
self.cursor = token.position;
return Some(Node::Semicolon);
}
if let Some(token) = self.scan_string() {
self.cursor = token.position;
return Some(Node::String(token.value.clone()));
}
if let Some(token) = self.scan_float() {
if let Ok(val) = token.value.parse::<f64>() {
self.cursor = token.position;
return Some(Node::Float(val));
}
}
if let Some(token) = self.scan_int() {
if let Ok(val) = token.value.parse::<i32>() {
self.cursor = token.position;
return Some(Node::Int(val));
}
return Some(node::Node::Semicolon);
}
None
@ -281,9 +140,8 @@ impl Iterator for Lexer {
mod test {
use super::*;
use crate::ast::error;
use crate::ast::node::Node;
fn lexer_run(lexer: &mut Lexer, text: &str) -> Result<Vec<Node>, error::AstError> {
fn lexer_run(lexer: &mut Lexer, text: &str) -> Result<Vec<node::Node>, error::AstError> {
lexer.prepare(text);
let result = lexer.collect();
@ -310,8 +168,8 @@ mod test {
let mut lex = Lexer::new();
let res = lexer_run(&mut lex, "true false").unwrap();
assert_eq!(2, res.len());
assert_eq!(Node::Bool(true), *res.get(0).unwrap());
assert_eq!(Node::Bool(false), *res.get(1).unwrap());
assert_eq!("Bool(true)", format!("{:?}", res.get(0).unwrap()));
assert_eq!("Bool(false)", format!("{:?}", res.get(1).unwrap()));
}
#[test]
@ -319,8 +177,8 @@ mod test {
let mut lex = Lexer::new();
let res = lexer_run(&mut lex, "true;").unwrap();
assert_eq!(2, res.len());
assert_eq!(Node::Bool(true), *res.get(0).unwrap());
assert_eq!(Node::Semicolon, *res.get(1).unwrap());
assert_eq!("Bool(true)", format!("{:?}", res.get(0).unwrap()));
assert_eq!("Semicolon", format!("{:?}", res.get(1).unwrap()));
}
#[test]
@ -345,47 +203,8 @@ mod test {
let mut lex = Lexer::new();
let res = lexer_run(&mut lex, " ;; ")?;
assert_eq!(2, res.len());
assert_eq!(Node::Semicolon, *res.get(0).unwrap());
assert_eq!(Node::Semicolon, *res.get(1).unwrap());
Ok(())
}
#[test]
fn test_integers() -> Result<(), error::AstError> {
let mut lex = Lexer::new();
let res = lexer_run(&mut lex, " 4 -2 328")?;
assert_eq!(3, res.len());
assert_eq!(Node::Int(4), *res.get(0).unwrap());
assert_eq!(Node::Int(-2), *res.get(1).unwrap());
assert_eq!(Node::Int(328), *res.get(2).unwrap());
Ok(())
}
#[test]
fn test_floats() -> Result<(), error::AstError> {
let mut lex = Lexer::new();
let res = lexer_run(&mut lex, " 2.0 .7 5. -3.14 ")?;
assert_eq!(4, res.len());
assert_eq!(Node::Float(2.0), *res.get(0).unwrap());
assert_eq!(Node::Float(0.7), *res.get(1).unwrap());
assert_eq!(Node::Float(5.0), *res.get(2).unwrap());
assert_eq!(Node::Float(-3.14), *res.get(3).unwrap());
Ok(())
}
#[test]
fn test_string() -> Result<(), error::AstError> {
let mut lex = Lexer::new();
let res = lexer_run(&mut lex,
" \"s\\ta\\\"lut\\n\" ")?;
assert_eq!(1, res.len());
assert_eq!(Node::String(String::from("s\ta\"lut\n")),
*res.get(0).unwrap());
assert_eq!("Semicolon", format!("{:?}", res.get(0).unwrap()));
assert_eq!("Semicolon", format!("{:?}", res.get(1).unwrap()));
Ok(())
}
}

3
src/ast/node.rs
View File

@ -3,9 +3,6 @@
pub enum Node {
Module(String, Vec<Node>),
Bool(bool),
Int(i32),
Float(f64),
String(String),
Semicolon
}

57
src/ast/parser.rs
View File

@ -1,5 +1,5 @@
use crate::ast::{
node::Node,
node,
lexer,
error
};
@ -9,7 +9,7 @@ pub struct Parser {
lexer: lexer::Lexer
}
type ParseResult = Result<Option<Node>, error::AstError>;
type ParseResult = Result<Option<node::Node>, error::AstError>;
impl Parser {
pub fn new(module_name: &str, lex: lexer::Lexer) -> Self {
@ -24,7 +24,7 @@ impl Parser {
}
fn parse_module(&mut self) -> ParseResult {
let mut children: Vec<Node> = vec![];
let mut children: Vec<node::Node> = vec![];
loop {
match self.parse_instr() {
@ -41,7 +41,7 @@ impl Parser {
});
}
let n = Node::Module(self.module_name.clone(), children);
let n = node::Node::Module(self.module_name.clone(), children);
Ok(Some(n))
}
@ -49,7 +49,7 @@ impl Parser {
match self.parse_expr() {
Ok(Some(expr)) => {
match self.lexer.next() {
Some(Node::Semicolon) => Ok(Some(expr)),
Some(node::Node::Semicolon) => Ok(Some(expr)),
None => Ok(None),
_ => Err(error::AstError {
msg: String::from("missing semicolon"),
@ -68,17 +68,8 @@ impl Parser {
fn parse_builtin(&mut self) -> ParseResult {
match self.lexer.next() {
Some(Node::Int(value))
=> Ok(Some(Node::Int(value))),
Some(Node::Float(value))
=> Ok(Some(Node::Float(value))),
Some(Node::Bool(value))
=> Ok(Some(Node::Bool(value))),
Some(Node::String(value))
=> Ok(Some(Node::String(value))),
Some(node::Node::Bool(value))
=> Ok(Some(node::Node::Bool(value))),
Some(other) => {
Err(error::AstError {
@ -95,10 +86,11 @@ impl Parser {
#[cfg(test)]
mod test {
use super::*;
use crate::ast::node::Node;
type TestResult = Result<(), String>;
fn test_parser(oracle: Node, source: &str) -> TestResult {
fn test_parser(oracle: node::Node, source: &str) -> TestResult {
let mut lex = lexer::Lexer::new();
lex.prepare(source);
let mut parser = Parser::new("mod", lex);
@ -148,35 +140,4 @@ mod test {
Ok(())
}
#[test]
fn numbers() -> TestResult {
test_parser(
Node::Module("mod".to_owned(), vec![
Node::Float(27.3)
]),
" 27.3; "
)?;
test_parser(
Node::Module("mod".to_owned(), vec![
Node::Int(-27)
]),
" -27; "
)?;
Ok(())
}
#[test]
fn strings() -> TestResult {
test_parser(
Node::Module("mod".to_owned(), vec![
Node::String(String::from("pizza! "))
]),
" \"pizza! \"; "
)?;
Ok(())
}
}

26
src/eval/evaluator.rs
View File

@ -29,12 +29,7 @@ impl Evaluator {
Ok(res)
},
Node::Bool(value) => Ok(Some(Value::Bool(*value))),
Node::Int(value) => Ok(Some(Value::Int(*value))),
Node::Float(value) => Ok(Some(Value::Float(*value))),
Node::String(value) => Ok(Some(Value::String(value.clone()))),
_ => Ok(None)
}
}
@ -70,10 +65,7 @@ mod test {
Ok(())
}
} else {
Err(Box::new(EvalError {
msg: format!("unexpected: {:?}", value),
line: 0
}))
Ok(())
}
},
None => Ok(())
@ -87,20 +79,4 @@ mod test {
Ok(())
}
#[test]
fn numbers() -> TestResult {
test_eval_value(Value::Float(-271.4), " -271.4; ")?;
test_eval_value(Value::Int(333), " 333; ")?;
Ok(())
}
#[test]
fn strings() -> TestResult {
test_eval_value(Value::String(String::from(" pizzza!!!")),
" \" pizzza!!!\"; ")?;
Ok(())
}
}

5
src/eval/value.rs
View File

@ -1,9 +1,6 @@
#[derive(PartialEq)]
#[derive(Debug)]
pub enum Value {
Bool(bool),
Int(i32),
Float(f64),
String(String)
Bool(bool)
}