Drafting ProductStatement

mmql/engine/lexer.go

@@ -135,6 +135,54 @@ func ( this *Lexer ) ReadDecimal() ( f float64, err error ) {
     return
 }
 
+func ( this *Lexer ) ReadKeyword( Keyword string ) ( err error ) {
+
+    reader := this.reader
+    kReader := strings.NewReader( Keyword )
+
+    var b strings.Builder
+    for {
+        r, _, _err := reader.ReadRune()
+        err = _err
+        if err != nil {
+            if err == io.EOF {
+                if 0 < b.Len() {
+                    err = nil
+                } else {
+                    err = fmt.Errorf( "Nothing left to read" )
+                    return
+                }
+            }
+            break
+        }
+
+        if strings.ContainsRune( K_SPACES, r ) && b.Len() == 0 {
+            continue
+        }
+
+        k, _, _err := kReader.ReadRune()
+        if _err != nil {
+            if _err != io.EOF {
+                err = _err
+            } else {
+                err = nil
+            }
+            return
+        }
+
+        if k != r {
+            err = fmt.Errorf(
+                "Expected \"%s\", got \"%s\"",
+                Keyword,
+                this.ReadUntilNot( K_STATEMENT_CHARS, true, r ),
+            )
+            return
+        }
+        b.WriteRune( r )
+    }
+    return
+}
+
 func ( this *Lexer ) ReadAlpha() ( s string, err error ) {
     reader := this.reader
 

mmql/engine/lexer_test.go

@@ -116,4 +116,15 @@ func TestAlpha( t *testing.T ) {
             t.Errorf( "Expected error for %s, got %s", v, f )
         }
     }
+
+    lexer.SetReader( strings.NewReader( "abcd efgh" ) )
+    f, err := lexer.ReadAlpha()
+    f, err = lexer.ReadAlpha()
+    if err != nil {
+        t.Errorf( "Expected string for \"efgh\", got %s", err )
+    }
+
+    if f != "efgh" {
+        t.Errorf( "Expected \"efgh\", got %s", f )
+    }
 }