#30 Hayat parametresi eklendi

erhanbaris · Jul 21, 2021 · 9384150 · 9384150
1 parent d4e6319
commit 9384150
Show file tree

Hide file tree

Showing 10 changed files with 57 additions and 54 deletions.
diff --git a/karamellib/src/syntax/loop_item.rs b/karamellib/src/syntax/loop_item.rs
@@ -5,8 +5,8 @@ use crate::error::KaramelErrorType;
 
 pub struct LoopItemParser;
 
-impl SyntaxParserTrait for LoopItemParser {
-    fn parse(parser: &SyntaxParser) -> AstResult {
+impl<'a> SyntaxParserTrait<'a> for LoopItemParser {
+    fn parse(parser: &SyntaxParser<'a>) -> AstResult<'a> {
         let index_backup = parser.get_index();
         parser.cleanup_whitespaces();
 

diff --git a/karamellib/src/syntax/loops.rs b/karamellib/src/syntax/loops.rs
@@ -12,20 +12,20 @@ use super::util::{map_parser_with_flag, with_flag};
 #[derive(Debug)]
 #[derive(Clone)]
 #[derive(PartialEq)]
-pub enum LoopType {
-    Simple(Rc<KaramelAstType>),
+pub enum LoopType<'a> {
+    Simple(Rc<KaramelAstType<'a>>),
     Scalar { 
-        variable: Rc<KaramelAstType>, 
-        control: Rc<KaramelAstType>,
-        increment: Rc<KaramelAstType>
+        variable: Rc<KaramelAstType<'a>>, 
+        control: Rc<KaramelAstType<'a>>,
+        increment: Rc<KaramelAstType<'a>>
     },
     Endless
 }
 
 pub struct WhileLoopParser;
 
-impl SyntaxParserTrait for WhileLoopParser {
-    fn parse(parser: &SyntaxParser) -> AstResult {
+impl<'a> SyntaxParserTrait<'a> for WhileLoopParser {
+    fn parse(parser: &SyntaxParser<'a>) -> AstResult<'a> {
         parser.indentation_check()?;
 
         let indentation = parser.get_indentation();

diff --git a/karamellib/src/syntax/mod.rs b/karamellib/src/syntax/mod.rs
@@ -17,6 +17,7 @@ pub mod expression;
 pub mod load_module;
 
 use std::borrow::Borrow;
+use std::marker::PhantomData;
 use std::rc::Rc;
 use std::vec::Vec;
 use std::cell::Cell;
@@ -28,13 +29,14 @@ use crate::error::*;
 
 use bitflags::bitflags;
 
-pub type ParseType = fn(parser: &SyntaxParser) -> AstResult;
+pub type ParseType<'a> = fn(parser: &SyntaxParser<'a>) -> AstResult<'a>;
 
-pub struct SyntaxParser {
+pub struct SyntaxParser<'a> {
     pub tokens: Vec<Token>,
     pub index: Cell<usize>,
     pub indentation: Cell<usize>,
-    pub flags: Cell<SyntaxFlag>
+    pub flags: Cell<SyntaxFlag>,
+    _marker: PhantomData<&'a bool>
 }
 
 bitflags! {
@@ -50,26 +52,27 @@ bitflags! {
     }
 }
 
-pub trait SyntaxParserTrait {
-    fn parse(parser: &SyntaxParser) -> AstResult;
+pub trait SyntaxParserTrait<'a> {
+    fn parse(parser: &SyntaxParser<'a>) -> AstResult<'a>;
 }
 
-pub trait ExtensionSyntaxParser: Sized {
-    fn parsable    (parser: &SyntaxParser) -> bool;
-    fn parse_suffix(ast: &mut KaramelAstType, parser: &SyntaxParser) -> AstResult;
+pub trait ExtensionSyntaxParser<'a>: Sized {
+    fn parsable    (parser: &SyntaxParser<'a>) -> bool;
+    fn parse_suffix(ast: &mut KaramelAstType<'a>, parser: &SyntaxParser<'a>) -> AstResult<'a>;
 }
 
-impl SyntaxParser {
-    pub fn new(tokens: Vec<Token>) -> SyntaxParser {
+impl<'a> SyntaxParser<'a> {
+    pub fn new(tokens: Vec<Token>) -> Self {
         SyntaxParser {
             tokens,
             index: Cell::new(0),
             indentation: Cell::new(0),
-            flags: Cell::new(SyntaxFlag::NONE)
+            flags: Cell::new(SyntaxFlag::NONE),
+            _marker: PhantomData
         }
     }
 
-    pub fn parse(&self) -> Result<Rc<KaramelAstType>, KaramelError> {
+    pub fn parse(&self) -> Result<Rc<KaramelAstType<'a>>, KaramelError> {
         return match MultiLineBlockParser::parse(&self) {
             Ok(ast) => {
                 self.cleanup();
@@ -279,7 +282,7 @@ impl SyntaxParser {
         }
     }
 
-    fn indentation_check(&self) -> AstResult {
+    fn indentation_check(&self) -> AstResult<'a> {
         if self.next_token().is_err() {
             return Ok(KaramelAstType::None);
         }
@@ -314,7 +317,7 @@ impl SyntaxParser {
         Ok(KaramelAstType::None)
     }
 
-    fn in_indication(&self) -> AstResult {
+    fn in_indication(&self) -> AstResult<'a> {
         if self.next_token().is_err() {
             return Ok(KaramelAstType::None);
         }

diff --git a/karamellib/src/syntax/newline.rs b/karamellib/src/syntax/newline.rs
@@ -4,8 +4,8 @@ use crate::compiler::ast::KaramelAstType;
 
 pub struct NewlineParser;
 
-impl SyntaxParserTrait for NewlineParser {
-    fn parse(parser: &SyntaxParser) -> AstResult {
+impl<'a> SyntaxParserTrait<'a> for NewlineParser {
+    fn parse(parser: &SyntaxParser<'a>) -> AstResult<'a> {
         let mut result = KaramelAstType::None;
         loop {
             if let Ok(token) = parser.peek_token() {

diff --git a/karamellib/src/syntax/primative.rs b/karamellib/src/syntax/primative.rs
@@ -11,7 +11,7 @@ use crate::error::KaramelErrorType;
 pub struct PrimativeParser;
 
 impl PrimativeParser {
-    pub fn parse_basic_primatives(parser: &SyntaxParser) -> AstResult {
+    pub fn parse_basic_primatives<'a>(parser: &SyntaxParser<'a>) -> AstResult<'a> {
         let index_backup = parser.get_index();
         parser.cleanup_whitespaces();
 
@@ -48,7 +48,7 @@ impl PrimativeParser {
         }
     }
 
-    pub fn parse_list(parser: &SyntaxParser) -> AstResult {
+    pub fn parse_list<'a>(parser: &SyntaxParser<'a>) -> AstResult<'a> {
         let index_backup = parser.get_index();
         if parser.match_operator(&[KaramelOperatorType::SquareBracketStart]).is_some() {
             let mut ast_vec   = Vec::new();
@@ -85,7 +85,7 @@ impl PrimativeParser {
         return Ok(KaramelAstType::None);
     }
 
-    pub fn parse_dict(parser: &SyntaxParser) -> AstResult {
+    pub fn parse_dict<'a>(parser: &SyntaxParser<'a>) -> AstResult<'a> {
         let index_backup = parser.get_index();
         if parser.match_operator(&[KaramelOperatorType::CurveBracketStart]).is_some() {
             let mut dict_items   = Vec::new();
@@ -150,7 +150,7 @@ impl PrimativeParser {
         return Ok(KaramelAstType::None);
     }
 
-    pub fn parse_symbol(parser: &SyntaxParser) -> AstResult {
+    pub fn parse_symbol<'a>(parser: &SyntaxParser<'a>) -> AstResult<'a> {
         let index_backup = parser.get_index();
         parser.cleanup_whitespaces();
         let token = parser.peek_token();
@@ -166,7 +166,7 @@ impl PrimativeParser {
         return Ok(KaramelAstType::None);
     }
 
-    pub fn parse_module_path(parser: &SyntaxParser) -> AstResult {
+    pub fn parse_module_path<'a>(parser: &SyntaxParser<'a>) -> AstResult<'a> {
         let index_backup = parser.get_index();
         parser.cleanup_whitespaces();
         let token = parser.peek_token();
@@ -209,7 +209,7 @@ impl PrimativeParser {
         return Ok(KaramelAstType::None);
     }
 
-    pub fn parse_parenthesis(parser: &SyntaxParser) -> AstResult {
+    pub fn parse_parenthesis<'a>(parser: &SyntaxParser<'a>) -> AstResult<'a> {
         let index_backup = parser.get_index();
         if parser.match_operator(&[KaramelOperatorType::LeftParentheses]).is_some() {
 
@@ -230,8 +230,8 @@ impl PrimativeParser {
     }
 }
 
-impl SyntaxParserTrait for PrimativeParser {
-    fn parse(parser: &SyntaxParser) -> AstResult {
+impl<'a> SyntaxParserTrait<'a> for PrimativeParser {
+    fn parse(parser: &SyntaxParser<'a>) -> AstResult<'a> {
         return map_parser(parser, &[Self::parse_dict, Self::parse_list, Self::parse_parenthesis, Self::parse_module_path, Self::parse_symbol, Self::parse_basic_primatives]);
     }
 }
diff --git a/karamellib/src/syntax/statement.rs b/karamellib/src/syntax/statement.rs
@@ -10,8 +10,8 @@ use crate::syntax::loops::WhileLoopParser;
 
 pub struct StatementParser;
 
-impl SyntaxParserTrait for StatementParser {
-    fn parse(parser: &SyntaxParser) -> AstResult {
+impl<'a> SyntaxParserTrait<'a> for StatementParser {
+    fn parse(parser: &SyntaxParser<'a>) -> AstResult<'a> {
         return map_parser(parser, &[LoadModuleParser::parse, LoopItemParser::parse, WhileLoopParser::parse, FunctionReturnParser::parse, AssignmentParser::parse, IfConditiontParser::parse]);
     }
 }
diff --git a/karamellib/src/syntax/unary.rs b/karamellib/src/syntax/unary.rs
@@ -15,8 +15,8 @@ use std::rc::Rc;
 
 pub struct UnaryParser;
 
-impl SyntaxParserTrait for UnaryParser {
-    fn parse(parser: &SyntaxParser) -> AstResult {
+impl<'a> SyntaxParserTrait<'a> for UnaryParser {
+    fn parse(parser: &SyntaxParser<'a>) -> AstResult<'a> {
         let ast = map_parser(parser, &[Self::parse_prefix_unary, Self::parse_suffix_unary, FuncCallParser::parse, PrimativeParser::parse])?;
 
         let index_backup = parser.get_index();
@@ -39,7 +39,7 @@ impl SyntaxParserTrait for UnaryParser {
 }
 
 impl UnaryParser {
-    fn parse_suffix_unary(parser: &SyntaxParser) -> AstResult {
+    fn parse_suffix_unary<'a>(parser: &SyntaxParser<'a>) -> AstResult<'a> {
         let index_backup = parser.get_index();
         match &parser.peek_token() {
             Ok(token) => {
@@ -61,7 +61,7 @@ impl UnaryParser {
         return Ok(KaramelAstType::None);
     }
 
-    pub fn parse_indexer(ast: Rc<KaramelAstType>, parser: &SyntaxParser) -> AstResult {
+    pub fn parse_indexer<'a>(ast: Rc<KaramelAstType<'a>>, parser: &SyntaxParser<'a>) -> AstResult<'a> {
         let index_backup = parser.get_index();
         if parser.match_operator(&[KaramelOperatorType::SquareBracketStart]).is_some() {
             parser.cleanup_whitespaces();
@@ -78,7 +78,7 @@ impl UnaryParser {
         return Ok(KaramelAstType::None);
     }
 
-    fn parse_prefix_unary(parser: &SyntaxParser) -> AstResult {
+    fn parse_prefix_unary<'a>(parser: &SyntaxParser<'a>) -> AstResult<'a> {
         let index_backup = parser.get_index();
 
         if let Some(operator) = parser.match_operator(&[KaramelOperatorType::Addition,

diff --git a/karamellib/src/syntax/util.rs b/karamellib/src/syntax/util.rs
@@ -7,7 +7,7 @@ use crate::syntax::SyntaxFlag;
 
 // https://github.com/rust-lang/rust/issues/75429
 
-pub fn map_parser(parser: &SyntaxParser, parser_funcs: &[ParseType]) -> AstResult {
+pub fn map_parser<'a>(parser: &SyntaxParser<'a>, parser_funcs: &[ParseType::<'a>]) -> AstResult<'a> {
     for parser_func in parser_funcs {
         match parser_func(parser) {
             Ok(KaramelAstType::None) => (),
@@ -19,7 +19,7 @@ pub fn map_parser(parser: &SyntaxParser, parser_funcs: &[ParseType]) -> AstResul
     Ok(KaramelAstType::None)
 }
 
-pub fn map_parser_with_flag(flag: SyntaxFlag, parser: &SyntaxParser, parser_funcs: &[ParseType]) -> AstResult {
+pub fn map_parser_with_flag<'a>(flag: SyntaxFlag, parser: &SyntaxParser<'a>, parser_funcs: &[ParseType::<'a>]) -> AstResult<'a> {
     for parser_func in parser_funcs {
         match with_flag(flag, parser, || parser_func(parser)) {
             Ok(KaramelAstType::None) => (),
@@ -31,23 +31,23 @@ pub fn map_parser_with_flag(flag: SyntaxFlag, parser: &SyntaxParser, parser_func
     Ok(KaramelAstType::None)
 }
 
-pub fn is_ast_empty(ast: &AstResult) -> bool {
+pub fn is_ast_empty<'a>(ast: &AstResult<'a>) -> bool {
     match ast {
         Ok(KaramelAstType::None) => true,
         Ok(_) => false,
         Err(_) => true
     }
 }
 
-pub fn err_or_message(ast: AstResult, none_error: KaramelErrorType) -> AstResult {
+pub fn err_or_message<'a>(ast: AstResult<'a>, none_error: KaramelErrorType) -> AstResult<'a> {
     match ast {
         Ok(KaramelAstType::None) => Err(none_error),
         Ok(_) => Ok(KaramelAstType::None),
         Err(error) => Err(error)
     }
 }
 
-pub fn update_functions_for_temp_return(ast: &KaramelAstType) {
+pub fn update_functions_for_temp_return<'a>(ast: &KaramelAstType<'a>) {
     match ast {
         KaramelAstType::FuncCall { func_name_expression: _, arguments: _, assign_to_temp } => {
             assign_to_temp.set(true);
@@ -70,15 +70,15 @@ pub fn update_functions_for_temp_return(ast: &KaramelAstType) {
     };
 }
 
-pub fn with_flag<F: Fn() -> AstResult>(flag: SyntaxFlag, parser: &SyntaxParser, func: F) -> AstResult {
+pub fn with_flag<'a, F: Fn() -> AstResult<'a>>(flag: SyntaxFlag, parser: &SyntaxParser<'a>, func: F) -> AstResult<'a> {
     let parser_flags  = parser.flags.get();
     parser.flags.set(parser_flags | flag);
     let loop_control = func()?;
     parser.flags.set(parser_flags);
     Ok(loop_control)
 }
 
-pub fn mut_with_flag<F: FnMut() -> AstResult>(flag: SyntaxFlag, parser: &SyntaxParser, mut func: F) -> AstResult {
+pub fn mut_with_flag<'a, F: FnMut() -> AstResult<'a>>(flag: SyntaxFlag, parser: &SyntaxParser<'a>, mut func: F) -> AstResult<'a> {
     let parser_flags  = parser.flags.get();
     parser.flags.set(parser_flags | flag);
     let loop_control = func()?;

diff --git a/karamellib/src/vm/executer.rs b/karamellib/src/vm/executer.rs
@@ -100,7 +100,7 @@ pub fn code_executer(parameters: ExecutionParameters) -> ExecutionStatus {
         }
     };
 
-    let opcode_compiler = InterpreterCompiler {};
+    let opcode_compiler = InterpreterCompiler::new();
     if parameters.return_output {
         context.stdout = Some(RefCell::new(String::new()));
         context.stderr = Some(RefCell::new(String::new()));

diff --git a/karamellib/src/vm/interpreter.rs b/karamellib/src/vm/interpreter.rs
@@ -40,7 +40,7 @@ pub unsafe fn dump_opcode<W: Write>(index: usize, context: &mut KaramelCompilerC
     }
 }
 
-pub unsafe fn run_vm(context: &mut KaramelCompilerContext) -> Result<Vec<VmObject>, KaramelErrorType>
+pub unsafe fn run_vm<'a>(context: &mut KaramelCompilerContext<'a>) -> Result<Vec<VmObject>, KaramelErrorType>
 {
     #[cfg(any(feature = "liveOpcodeView", feature = "dumpOpcodes"))]
     let mut log_update = LogUpdate::new(stdout()).unwrap();
@@ -243,7 +243,7 @@ pub unsafe fn run_vm(context: &mut KaramelCompilerContext) -> Result<Vec<VmObjec
                         reference.execute(context, None)?;
                     }
                     else {
-                        return Err(KaramelErrorType::NotCallable(value.clone()));
+                        return Err(KaramelErrorType::NotCallable(VmObject::convert(value.clone())));
                     }
                 },
 
@@ -254,7 +254,7 @@ pub unsafe fn run_vm(context: &mut KaramelCompilerContext) -> Result<Vec<VmObjec
                         KaramelPrimative::Function(reference, base) => reference.execute(context, *base)?,
                         _ => {
                             log::debug!("{:?} not callable", &*function.deref());
-                        return Err(KaramelErrorType::NotCallable(value.clone()));
+                        return Err(KaramelErrorType::NotCallable(VmObject::convert(value.clone())));
                         }
                     };
                 },
@@ -361,23 +361,23 @@ pub unsafe fn run_vm(context: &mut KaramelCompilerContext) -> Result<Vec<VmObjec
                         KaramelPrimative::List(value) => {
                             let indexer_value = match &*indexer {
                                 KaramelPrimative::Number(number) => *number as usize,
-                                _ => return Err(KaramelErrorType::IndexerMustBeNumber(indexer.clone()))
+                                _ => return Err(KaramelErrorType::IndexerMustBeNumber(VmObject::convert(indexer.clone())))
                             };
 
                             value.borrow_mut()[indexer_value] = assign_item;
                         },
                         KaramelPrimative::Dict(value) => {
                             let indexer_value = match &*indexer {
                                 KaramelPrimative::Text(text) => &*text,
-                                _ => return Err(KaramelErrorType::IndexerMustBeString(indexer.clone()))
+                                _ => return Err(KaramelErrorType::IndexerMustBeString(VmObject::convert(indexer.clone())))
                             };
 
                             value.borrow_mut().insert(indexer_value.to_string(), assign_item);
                         },
                         KaramelPrimative::Text(_) => {
                             let indexer_value = match &*indexer {
                                 KaramelPrimative::Number(number) => *number,
-                                _ => return Err(KaramelErrorType::IndexerMustBeNumber(indexer.clone()))
+                                _ => return Err(KaramelErrorType::IndexerMustBeNumber(VmObject::convert(indexer.clone())))
                             };
 
                             match context.get_class(&object).get_setter() {