Worked on msg reader.

Author: mkrueger

crates/icy_board_engine/src/icy_board/state/functions.rs

@@ -181,11 +181,11 @@ impl IcyBoardState {
                         self.run_ppe(&file, None).await?;
                     }
                     PPECallType::Menu => {
-                        self.display_menu(&call.file).await?;
+                        let _ = self.display_menu(&call.file).await?;
                     }
                     PPECallType::File => {
                         let file = self.get_board().await.resolve_file(&call.file);
-                        self.display_file(&file).await?;
+                        let _ = self.display_file(&file).await?;
                     }
                 }
                 return Ok(());

crates/icy_board_engine/src/icy_board/state/mod.rs

@@ -241,6 +241,8 @@ pub struct Session {
     /// The current default answer on last input_string
     pub default_answer: Option<String>,
     pub last_answer: Option<String>,
+
+    pub memorized_msg: Option<(usize, u32)>,
 }
 
 impl Session {
@@ -301,6 +303,7 @@ impl Session {
             search_pattern: None,
             default_answer: None,
             last_answer: None,
+            memorized_msg: None,
         }
     }
 

crates/icy_board_engine/src/icy_board/state/user_commands/mods/messagereader/mod.rs

@@ -286,6 +286,12 @@ impl IcyBoardState {
             opt.high_read_msg = opt.high_read_msg.max(number);
             message_base.write_last_read(opt)?;
         }
+        let mut flag = ReadLoopType::InsideReadLoop;
+        let mut first = number;
+        let mut last = number;
+        let mut since = false;
+        let mut keep_going = false;
+
         loop {
             match message_base.read_header(number) {
                 Ok(header) => {
@@ -325,20 +331,116 @@ impl IcyBoardState {
                 .await?;
 
             if text.is_empty() {
-                break;
-            }
-            self.session.push_tokens(&text);
+                if !keep_going {
+                    break;
+                }
+            } else {
+                self.session.push_tokens(&text);
+                let token = self.session.tokens.pop_front().unwrap_or_default();
+                match token.as_str() {
+                    "-" | "L" => {
+                        if token == "L" {
+                            flag = ReadLoopType::OutsideReadLoop;
+                        }
+                        first = if flag == ReadLoopType::InsideReadLoop { number - 1 } else { number };
+                        last = 1;
+                    }
+                    "+" => {
+                        if flag == ReadLoopType::InsideReadLoop {
+                            first = 1;
+                            last = i32::MAX as u32;
+                        } else {
+                            since = true;
+                        }
+
+                        keep_going = true;
+                    }
+                    // "A" => {}  // Abandon
+                    "Z" | "D" | "C" => {
+                        let zip_msg = token == "Z";
+                        let cap_ask = token != "D";
+                        // todo capture!
+                    }
+                    "*" | "S" => {
+                        // Read new messages
+                        since = true;
+                        keep_going = true;
+                        // todo
+                    }
+                    "E" => {
+                        self.edit_header(message_base, number).await?;
+                    }
+                    "F" => {
+                        // TODO
+                    }
+                    "G" => {
+                        self.goodbye().await?;
+                    }
+                    "M" => {
+                        // memorize msg
+                        self.session.memorized_msg = Some((self.session.current_message_area, number));
+                        self.display_text(IceText::MessageNumberMemorized, display_flags::LFBEFORE).await?;
+                    }
+                    "N" => {
+                        // STOP
+                        break;
+                    }
+                    "P" => { // Make cur msg private
+                        // TODO
+                    }
+                    "Q" => { // Quickscan
+                        // TODO
+                    }
+                    "T" => { // Threading
+                        // TODO
+                    }
 
-            match self.session.tokens.pop_front().unwrap_or_default() {
-                text => {
-                    if let Ok(new_number) = text.parse::<u32>() {
-                        number = new_number;
+                    "U" => { // Unprotect
+                        // TODO
+                    }
+
+                    "V" => { // View File
+                        // TODO
+                    }
+
+                    "X" => { // export
+                        // TODO
+                    }
+
+                    "Y" => { // YourMessages
+                        // TODO
+                    }
+                    "/" => {
+                        // Redisplay
                         continue;
                     }
+                    text => {
+                        if let Ok(new_number) = text.parse::<u32>() {
+                            number = new_number;
+                            continue;
+                        }
+                    }
+                }
+            }
+            if keep_going {
+                if last < number {
+                    number -= 1;
+                } else if number > first {
+                    number += 1;
                 }
             }
         }
 
         Ok(())
     }
+
+    async fn edit_header(&self, message_base: &mut jamjam::jam::JamMessageBase, number: u32) -> Res<()> {
+        Ok(())
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+enum ReadLoopType {
+    InsideReadLoop,
+    OutsideReadLoop,
 }

crates/icy_board_engine/src/semantic/mod.rs

@@ -1564,7 +1564,10 @@ impl AstVisitor<VariableType> for SemanticVisitor {
             if matches!(self.references[idx].0, ReferenceType::Function(_)) {
                 let f = self.function_containers.iter().find(|p| p.name == call.get_identifier()).unwrap();
                 if let FunctionDeclaration::Function(f) = &f.functions.clone() {
-                    self.check_arg_count(f.get_parameters().len(), call.get_arguments().len(), call.get_identifier_token());
+                    let param_count = f.get_parameters().len();
+                    let arg_count = call.get_arguments().len();
+                    let identifier_token = call.get_identifier_token();
+                    self.check_arg_count(param_count, arg_count, identifier_token);
                     self.check_arg_types(f.get_parameters(), call.get_arguments());
                 }