Add --compression-level option to compile command

--compression-level specifies a compression level. The default value is 2.

2 files changed, 43 insertions, 25 deletions

diff --git a/driver/lexer.go b/driver/lexer.go
index bac478f..278a104 100644
--- a/driver/lexer.go
+++ b/driver/lexer.go
@@ -319,13 +319,29 @@ func (l *Lexer) next() (*Token, error) {
 }
 
 func (l *Lexer) lookupNextState(mode spec.LexModeNum, state int, v int) (int, bool) {
-	tab := l.clspec.Specs[mode].DFA.Transition
-	rowNum := tab.RowNums[state]
-	d := tab.UniqueEntries.RowDisplacement[rowNum]
-	if tab.UniqueEntries.Bounds[d+v] != rowNum {
-		return tab.UniqueEntries.EmptyValue, false
+	switch l.clspec.CompressionLevel {
+	case 2:
+		tab := l.clspec.Specs[mode].DFA.Transition
+		rowNum := tab.RowNums[state]
+		d := tab.UniqueEntries.RowDisplacement[rowNum]
+		if tab.UniqueEntries.Bounds[d+v] != rowNum {
+			return tab.UniqueEntries.EmptyValue, false
+		}
+		return tab.UniqueEntries.Entries[d+v], true
+	case 1:
+		tab := l.clspec.Specs[mode].DFA.Transition
+		next := tab.UncompressedUniqueEntries[tab.RowNums[state]*tab.OriginalColCount+v]
+		if next == 0 {
+			return 0, false
+		}
+		return next, true
+	}
+	spec := l.clspec.Specs[mode]
+	next := spec.DFA.UncompressedTransition[state*spec.DFA.ColCount+v]
+	if next == 0 {
+		return 0, false
 	}
-	return tab.UniqueEntries.Entries[d+v], true
+	return next, true
 }
 
 func (l *Lexer) mode() spec.LexModeNum {
diff --git a/driver/lexer_test.go b/driver/lexer_test.go
index f11a9c0..0156ef8 100644
--- a/driver/lexer_test.go
+++ b/driver/lexer_test.go
@@ -526,28 +526,30 @@ func TestLexer_Next(t *testing.T) {
 		},
 	}
 	for i, tt := range test {
-		t.Run(fmt.Sprintf("#%v", i), func(t *testing.T) {
-			clspec, err := compiler.Compile(tt.lspec)
-			if err != nil {
-				t.Fatalf("unexpected error occurred: %v", err)
-			}
-			lexer, err := NewLexer(clspec, strings.NewReader(tt.src))
-			if err != nil {
-				t.Fatalf("unexpecated error occurred; %v", err)
-			}
-			for _, eTok := range tt.tokens {
-				tok, err := lexer.Next()
+		for compLv := compiler.CompressionLevelMin; compLv <= compiler.CompressionLevelMax; compLv++ {
+			t.Run(fmt.Sprintf("#%v-%v", i, compLv), func(t *testing.T) {
+				clspec, err := compiler.Compile(tt.lspec, compiler.CompressionLevel(compLv))
 				if err != nil {
-					t.Log(err)
-					break
+					t.Fatalf("unexpected error occurred: %v", err)
 				}
-				testToken(t, eTok, tok)
-				// t.Logf("token: ID: %v, Match: %+v Text: \"%v\", EOF: %v, Invalid: %v", tok.ID, tok.Match(), tok.Text(), tok.EOF, tok.Invalid)
-				if tok.EOF {
-					break
+				lexer, err := NewLexer(clspec, strings.NewReader(tt.src))
+				if err != nil {
+					t.Fatalf("unexpecated error occurred; %v", err)
+				}
+				for _, eTok := range tt.tokens {
+					tok, err := lexer.Next()
+					if err != nil {
+						t.Log(err)
+						break
+					}
+					testToken(t, eTok, tok)
+					// t.Logf("token: ID: %v, Match: %+v Text: \"%v\", EOF: %v, Invalid: %v", tok.ID, tok.Match(), tok.Text(), tok.EOF, tok.Invalid)
+					if tok.EOF {
+						break
+					}
 				}
-			}
-		})
+			})
+		}
 	}
 }