added web UI

src/automata/npda.rs

@@ -353,10 +353,12 @@ impl TransitionTable {
                             Some(symbol)
                         }).collect();
                         
-                        transitions_map
+                        if !transitions_map
                             .entry((state, char, stack_symbol))
-                            .or_insert(Vec::new())
-                            .push((next_state, stack))
+                            .or_insert(HashSet::new())
+                            .insert((next_state, stack)) {
+                                logs.emit_warning("duplicate transition", item.1);
+                            }
                     }
                 }
                 TL::Assignment(S(Dest::Function(S(name, _), _), dest_s), _) => {
@@ -403,7 +405,7 @@ impl TransitionTable {
         let initial_state = match initial_state {
             Some(some) => some,
             None => {
-                if let Some(initial) = states.get("z0") {
+                if let Some(initial) = states.get("q0") {
                     logs.emit_warning_locless("initial state not defined, defaulting to 'q0'");
                     *initial
                 } else {

src/loader/log.rs

@@ -72,6 +72,18 @@ impl<'a> Logs<'a> {
             entry,
         })
     }
+
+    pub fn entries(&self) -> &[LogEntry]{
+        &self.logs
+    }
+
+    pub fn into_entries(self) -> impl Iterator<Item = LogEntry>{
+        self.logs.into_iter()
+    }
+
+    pub fn src(&self) -> &str{
+        &self.src
+    }
 }
 
 pub enum LogLevel {

src/loader/parser.rs

@@ -44,7 +44,7 @@ impl<'a> Parser<'a> {
     }
 
     fn expect_token(&mut self, expected: Token<'a>) -> (bool, Span) {
-        if let Some(Spanned(token, span)) = self.next_token() {
+        if let Some(Spanned(token, span)) = self.peek_token() {
             if token != expected {
                 self.logs.emit_error(
                     format!("unexpected token {:#}, expected {:}", token, expected),
@@ -52,6 +52,7 @@ impl<'a> Parser<'a> {
                 );
                 (false, span)
             } else {
+                self.next_token();
                 (true, span)
             }
         } else {
@@ -212,27 +213,26 @@ impl<'a> Parser<'a> {
     pub fn parse_elements(mut self) -> (Vec<Spanned<TopLevel<'a>>>, Logs<'a>) {
         let mut result = Vec::new();
 
-        loop {
-            let Some(next) = self.next_token() else { break };
+        while let Some(next) = self.next_token() {
             match (next, self.peek_token()) {
                 (Spanned(Token::Ident(ident), start), Some(Spanned(Token::LPar, _))) => {
                     let tuple = self.parse_tupple();
                     let span = start.join(tuple.1);
                     let dest = Spanned(Dest::Function(Spanned(ident, start), tuple), span);
-                    self.expect_token(Token::Eq);
+                    if !self.expect_token(Token::Eq).0{continue;}
                     let item = self.parse_item();
                     let span = start.join(item.1);
                     result.push(Spanned(TopLevel::Assignment(dest, item), span));
                 }
                 (
-                    Spanned(Token::Ident(_), _),
-                    Some(Spanned(Token::LSmallArrow | Token::Ident(_), _)),
+                    Spanned(Token::Ident(_), start),
+                    Some(Spanned(Token::LSmallArrow, end)),
                 ) => {
-                    todo!()
+                    self.logs.emit_error("Production rules are not yet supported", start.join(end));
                 }
                 (Spanned(Token::Ident(ident), start), _) => {
                     let dest = Spanned(Dest::Ident(ident), start);
-                    self.expect_token(Token::Eq);
+                    if !self.expect_token(Token::Eq).0{continue;}
                     let item = self.parse_item();
                     let span = start.join(item.1);
                     result.push(Spanned(TopLevel::Assignment(dest, item), span));