parser: error for too large frets

Fixes #9.
Has about 2% performance impact. I will allow it, because it is for
correctness.

Author: algorithmiker

src/backend/errors/backend_error.rs

@@ -81,6 +81,13 @@ impl BackendError {
             relevant_lines: line as usize..=line as usize,
         }
     }
+    pub fn large_fret(line: u32, char: u32) -> Self {
+        Self {
+            main_location: ErrorLocation::LineAndChar(line, char),
+            relevant_lines: line as usize..=line as usize,
+            kind: BackendErrorKind::FretTooLarge,
+        }
+    }
 }
 
 impl From<std::io::Error> for BackendError {

src/backend/errors/backend_error_kind.rs

@@ -11,6 +11,7 @@ pub enum BackendErrorKind {
     BendOnInvalid,
     BothSlotsMultiChar,
     MultiBothSlotsFilled,
+    FretTooLarge,
 }
 
 impl BackendErrorKind {
@@ -57,7 +58,8 @@ In this position, you may have:
  - a rest
  - a single char element aligned left or right
  - another multichar element of the same cardinality"#.into()
-            )
+            ), 
+            BackendErrorKind::FretTooLarge => ("Too large fret".to_string(), "The maximum allowed fret is 99.".to_string()),
         }
     }
 }

src/backend/fixup/mod.rs

@@ -104,6 +104,8 @@ impl Backend for FixupBackend {
                         BackendErrorKind::InvalidStringName => {}
                         BackendErrorKind::EmptyScore => {}
                         BackendErrorKind::BothSlotsMultiChar => {} // todo: fix BothSlotsMultichar errors
+                        BackendErrorKind::FretTooLarge => {} // todo: fix FretTooLarge errors (add
+                        // space between)
                         BackendErrorKind::MultiBothSlotsFilled => {
                             let Some((line_idx, char_idx)) = err
                                 .main_location

src/parser/mod.rs

@@ -21,9 +21,9 @@ pub fn string_name() -> impl Fn(&str) -> Result<(&str, char), &str> {
 fn numeric(s: &str) -> Result<(&str, u8), &str> {
     let bytes = s.as_bytes();
     let mut i = 0;
-    let mut sum = 0;
+    let mut sum: u8 = 0;
     while i < bytes.len() && bytes[i].is_ascii_digit() {
-        sum *= 10;
+        sum = sum.checked_mul(10).ok_or(s)?;
         sum += bytes[i] - b'0';
         i += 1;
     }

src/parser/parser.rs

@@ -2,7 +2,10 @@ use super::{
     string_name,
     tab_element::{self, tab_element3, TabElement3},
 };
-use crate::{backend::errors::backend_error::BackendError, debugln, traceln};
+use crate::{
+    backend::errors::backend_error::BackendError, debugln, parser::tab_element::TabElementError,
+    traceln,
+};
 use std::ops::RangeInclusive;
 
 pub fn line_is_valid(line: &str) -> bool {
@@ -136,13 +139,23 @@ pub fn parse(lines: &[String]) -> ParseResult {
                 }
 
                 let len_before = part[s].len();
-                let Ok((res, te)) = tab_element3(part[s]) else {
-                    let (line, char) =
-                        source_location_while_parsing(&r, part_first_line as u32, s as u32);
-                    let invalid_src = part[s].chars().next().unwrap_or('\0'); // TODO: do not use null byte here
-                    r.error = Some(BackendError::parse3_invalid_character(line, char, invalid_src));
-                    return r;
+                let (res, te) = match tab_element3(part[s]) {
+                    Ok(x) => x,
+                    Err((_, err)) => {
+                        let (line, char) =
+                            source_location_while_parsing(&r, part_first_line as u32, s as u32);
+                        if let Some(TabElementError::FretTooLarge) = err {
+                            r.error = Some(BackendError::large_fret(line, char));
+                        } else {
+                            let invalid_src = part[s].chars().next().unwrap_or('\0'); // TODO: do not use null byte here
+                            let err =
+                                BackendError::parse3_invalid_character(line, char, invalid_src);
+                            r.error = Some(err);
+                        }
+                        return r;
+                    }
                 };
+
                 let tab_element_len = len_before - res.len();
                 is_multichar |= tab_element_len > 1;
                 is_multi_on[s] = tab_element_len > 1;

src/parser/tab_element.rs

@@ -1,4 +1,4 @@
-use crate::parser::numeric;
+use crate::{backend::errors::backend_error::BackendError, parser::numeric, traceln};
 use std::cmp::max;
 
 #[derive(Debug, PartialEq, Clone)]
@@ -14,14 +14,18 @@ pub enum TabElement3 {
     Vibrato,
 }
 
+#[derive(Debug)]
+pub enum TabElementError {
+    FretTooLarge,
+}
 #[inline(always)]
-pub fn tab_element3(s: &str) -> Result<(&str, TabElement3), &str> {
+pub fn tab_element3(s: &str) -> Result<(&str, TabElement3), (&str, Option<TabElementError>)> {
     let bytes = s.as_bytes();
     match bytes.first() {
         Some(b'-') => Ok((&s[1..], TabElement3::Rest)),
         Some(b'x') => Ok((&s[1..], TabElement3::DeadNote)),
         Some(48..=58) => {
-            let (res, num) = numeric(s)?;
+            let (res, num) = numeric(s).map_err(|s| (s, Some(TabElementError::FretTooLarge)))?;
             Ok((res, TabElement3::Fret(num)))
         }
         Some(b'b') => Ok((&s[1..], TabElement3::Bend)),
@@ -30,7 +34,7 @@ pub fn tab_element3(s: &str) -> Result<(&str, TabElement3), &str> {
         Some(b'r') => Ok((&s[1..], TabElement3::Release)),
         Some(b'/') | Some(b'\\') => Ok((&s[1..], TabElement3::Slide)),
         Some(b'~') => Ok((&s[1..], TabElement3::Vibrato)),
-        Some(_) | None => Err(s),
+        Some(_) | None => Err((s, None)),
     }
 }
 impl TabElement3 {