Merge branch 'development'

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rascal"
-version = "1.0.0"
+version = "1.1.0"
 authors = ["tylerlaberge <[email protected]>"]
 
 [dependencies]

LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 tylerlaberge
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

src/parser/ast.rs

@@ -1,12 +1,8 @@
 #[derive(Debug, Clone, PartialEq)]
-pub enum Program {
-    Program(Variable, Block)
-}
+pub struct Program(pub Variable, pub Block);
 
 #[derive(Debug, Clone, PartialEq)]
-pub enum Block {
-    Block(Vec<Declarations>, Compound)
-}
+pub struct Block(pub Vec<Declarations>, pub Compound);
 
 #[derive(Debug, Clone, PartialEq)]
 pub enum Declarations {
@@ -17,29 +13,19 @@ pub enum Declarations {
 }
 
 #[derive(Debug, Clone, PartialEq)]
-pub enum ProcedureDeclaration {
-    Procedure(String, FormalParameterList, Block)
-}
+pub struct ProcedureDeclaration(pub String, pub FormalParameterList, pub Block);
 
 #[derive(Debug, Clone, PartialEq)]
-pub enum FunctionDeclaration {
-    Function(String, FormalParameterList, Block, TypeSpec)
-}
+pub struct FunctionDeclaration(pub String, pub FormalParameterList, pub Block, pub TypeSpec);
 
 #[derive(Debug, Clone, PartialEq)]
-pub enum FormalParameterList {
-    FormalParameters(Vec<FormalParameters>)
-}
+pub struct FormalParameterList(pub Vec<FormalParameters>);
 
 #[derive(Debug, Clone, PartialEq)]
-pub enum FormalParameters {
-    Parameters(Vec<String>, TypeSpec)
-}
+pub struct FormalParameters(pub Vec<String>, pub TypeSpec);
 
 #[derive(Debug, Clone, PartialEq)]
-pub enum VariableDeclaration {
-    Variables(Vec<String>, TypeSpec)
-}
+pub struct VariableDeclaration(pub Vec<String>, pub TypeSpec);
 
 #[derive(Debug, Clone, PartialEq)]
 pub enum TypeSpec {
@@ -51,9 +37,7 @@ pub enum TypeSpec {
 }
 
 #[derive(Debug, Clone, PartialEq)]
-pub enum Compound {
-    Statements(Vec<Statement>)
-}
+pub struct Compound(pub Vec<Statement>);
 
 #[derive(Debug, Clone, PartialEq)]
 pub enum Statement {
@@ -64,9 +48,7 @@ pub enum Statement {
 }
 
 #[derive(Debug, Clone, PartialEq)]
-pub enum Assignment {
-    Assign(Variable, Expr)
-}
+pub struct Assignment(pub Variable, pub Expr);
 
 #[derive(Debug, Clone, PartialEq)]
 pub enum IfStatement {
@@ -76,19 +58,13 @@ pub enum IfStatement {
 }
 
 #[derive(Debug, Clone, PartialEq)]
-pub enum Variable {
-    Var(String)
-}
+pub struct Variable(pub String);
 
 #[derive(Debug, Clone, PartialEq)]
-pub enum FunctionCall {
-    Call(Variable, CallParameters)
-}
+pub struct FunctionCall(pub Variable, pub CallParameters);
 
 #[derive(Debug, Clone, PartialEq)]
-pub enum CallParameters {
-    Parameters(Vec<Expr>)
-}
+pub struct CallParameters(pub Vec<Expr>);
 
 #[derive(Debug, Clone, PartialEq)]
 pub enum Expr {
@@ -101,9 +77,7 @@ pub enum Expr {
 }
 
 #[derive(Debug, Clone, PartialEq)]
-pub enum UnaryOpExpr {
-    UnaryOp(UnaryOperator, Expr)
-}
+pub struct UnaryOpExpr(pub UnaryOperator, pub Expr);
 
 #[derive(Debug, Clone, PartialEq)]
 pub enum UnaryOperator {
@@ -113,9 +87,7 @@ pub enum UnaryOperator {
 }
 
 #[derive(Debug, Clone, PartialEq)]
-pub enum BinaryOpExpr {
-    BinaryOp(Expr, BinaryOperator, Expr)
-}
+pub struct BinaryOpExpr(pub Expr, pub BinaryOperator, pub Expr);
 
 #[derive(Debug, Clone, PartialEq)]
 pub enum BinaryOperator {
@@ -135,9 +107,7 @@ pub enum BinaryOperator {
 }
 
 #[derive(Debug, Clone, PartialEq)]
-pub enum GroupedExpr {
-    Group(Expr)
-}
+pub struct GroupedExpr(pub Expr);
 
 #[derive(Debug, Clone, PartialEq)]
 pub enum Literal {

src/parser/parselet.rs

@@ -55,7 +55,7 @@ impl PrefixParselet {
     fn grouping(&self, parser: &mut Parser, token: &Token) -> Result<GroupedExpr, String> {
         return match token {
             &Token::LPAREN => match (parser.expr(None)?, parser.lexer.next()) {
-                (expr, Some(Token::RPAREN)) => Ok(GroupedExpr::Group(expr)),
+                (expr, Some(Token::RPAREN)) => Ok(GroupedExpr(expr)),
                 (expr, _)                   => Err(String::from(format!("Grouping Parse Error: Expected token {:?} after {:?}", Token::RPAREN, expr)))
             },
             _              => Err(String::from(format!("Grouping Parse Error: Expected token {:?}", Token::LPAREN)))
@@ -64,7 +64,7 @@ impl PrefixParselet {
 
     fn variable(&self, parser: &mut Parser, token: &Token) -> Result<Variable, String> {
         return match token {
-            &Token::ID(ref name) => Ok(Variable::Var(name.clone())),
+            &Token::ID(ref name) => Ok(Variable(name.clone())),
             _                    => Err(String::from("Variable Parse Error: Expected token id"))
         };
     }
@@ -77,7 +77,7 @@ impl PrefixParselet {
             _                => Err(String::from(format!("Unary Op Parse Error: Expected one of {:?}", vec![Token::PLUS, Token::MINUS, Token::NOT])))
         }?;
 
-        return Ok(UnaryOpExpr::UnaryOp(operator, parser.expr(Some(self.get_precedence()))?));
+        return Ok(UnaryOpExpr(operator, parser.expr(Some(self.get_precedence()))?));
     }
 }
 
@@ -121,13 +121,13 @@ impl InfixParselet {
             )
         }?;
 
-        return Ok(BinaryOpExpr::BinaryOp(left.clone(), operator, parser.expr(Some(self.get_precedence()))?));
+        return Ok(BinaryOpExpr(left.clone(), operator, parser.expr(Some(self.get_precedence()))?));
     }
 
     fn function_call(&self, parser: &mut Parser, left: &Expr, token: &Token) -> Result<FunctionCall, String> {
         return match (left, token) {
             (&Expr::Variable(ref name), &Token::LPAREN) => match (parser.call_parameters()?, parser.lexer.next()) {
-                (parameters, Some(Token::RPAREN)) => Ok(FunctionCall::Call(name.clone(), parameters)),
+                (parameters, Some(Token::RPAREN)) => Ok(FunctionCall(name.clone(), parameters)),
                 (parameters, _)                   => Err(String::from(format!("Function Call Parse Error: Expected token {:?} after {:?}", Token::RPAREN, parameters)))
             },
             (_, _)                                      => Err(String::from(format!("Function Call Parse Error: Expected variable token and {:?}", Token::LPAREN)))