Merge pull request #32 from nivpgir/master

Implement a remainder operator through the ffi

src/compiler/lex.rs

@@ -101,6 +101,7 @@ impl Lexer {
             Box::new(Lexer::mul),
             Box::new(Lexer::div),
             Box::new(Lexer::equal),
+            Box::new(Lexer::remainder),
             Box::new(Lexer::magic),
             Box::new(Lexer::print), // remove print statements after FFI
 
@@ -269,6 +270,9 @@ impl Lexer {
         Lexer::literal(source, "==", Token::Equal)
     }
 
+    pub fn remainder(source: &str) -> Result<Bite, String> {
+        Lexer::literal(source, "%", Token::Rem)
+    }
     /// Matches a `print` expression.
     pub fn print(source: &str) -> Result<Bite, String> {
         Lexer::literal(source, "print", Token::Print)

src/compiler/parse.rs

@@ -180,6 +180,7 @@ impl Parser {
             Token::Sub => self.sub(left),
             Token::Mul => self.mul(left),
             Token::Div => self.div(left),
+            Token::Rem => self.remainder(left),
 
             Token::Equal => self.equal(left),
 
@@ -208,7 +209,8 @@ impl Parser {
             | Token::Sub => Prec::AddSub,
 
               Token::Mul
-            | Token::Div => Prec::MulDiv,
+	    | Token::Div
+            | Token::Rem => Prec::MulDiv,
 
             // postfix
               Token::End
@@ -549,6 +551,11 @@ impl Parser {
         return self.binop(Token::Equal, Prec::Logic, "equal", left);
     }
 
+    /// Parses an equality, calls out to FFI.
+    pub fn remainder(&mut self, left: Spanned<AST>) -> Result<Spanned<AST>, Syntax> {
+        return self.binop(Token::Rem, Prec::MulDiv, "remainder", left);
+    }
+
     /// Parses a function call.
     /// Function calls are a bit magical,
     /// because they're just a series of expressions.

src/compiler/token.rs

@@ -38,7 +38,7 @@ pub enum Token {
 
     // Operators
     Add, Sub,
-    Mul, Div,
+    Mul, Div, Rem,
 
     Equal,
 
@@ -72,6 +72,7 @@ impl Display for Token {
             Token::Sub          => "a subtraction",
             Token::Mul          => "a multiplication",
             Token::Div          => "a division",
+            Token::Rem          => "a remainder operator",
             Token::Equal        => "an equality test",
             Token::End          => "end of source",
             Token::Keyword(k) => { return write!(f, "the pseudokeyword '{}", k); },

src/core/math.rs

@@ -48,3 +48,17 @@ pub fn div(data: Data) -> Result<Data, String> {
 
     return Ok(result);
 }
+
+/// remainder of left operand by right operand division.
+/// Raises a runtime error if there is a division by zero.
+pub fn remainder(data: Data) -> Result<Data, String> {
+    let result = match binop(data) {
+        (Data::Real(_),   Data::Real(r)) if r == 0.0 => Err("Division by zero")?,
+        (Data::Real(l),   Data::Real(r)) => Data::Real(l.rem_euclid(r)),
+        (Data::Integer(_), Data::Integer(n)) if n == 0 => Err("Division by zero")?,
+        (Data::Integer(l), Data::Integer(r)) => Data::Integer(l.rem_euclid(r)),
+        _ => Err("Division between unsupported datatypes")?,
+    };
+
+    return Ok(result);
+}

src/core/mod.rs

@@ -21,6 +21,7 @@ pub fn ffi_core() -> FFI {
     ffi.add("sub", FFIFunction::new(Box::new(math::sub))).unwrap();
     ffi.add("mul", FFIFunction::new(Box::new(math::mul))).unwrap();
     ffi.add("div", FFIFunction::new(Box::new(math::div))).unwrap();
+    ffi.add("remainder", FFIFunction::new(Box::new(math::remainder))).unwrap();
 
     // io
     ffi.add("println", FFIFunction::new(Box::new(io::println))).unwrap();

tests/snippets/remainder.pn

@@ -0,0 +1,5 @@
+-- action: run
+-- outcome: success
+-- expect: 1.0
+
+print(3.0 % 2.0)