Skip to content

Support infix rules #134

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
msujew wants to merge 7 commits into
base: main
Choose a base branch
from
Open

Support infix rules #134

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
7 commits
Select commit Hold shift + click to select a range
0d6b775
Support infix rules
msujew Jul 25, 2026
14b2a0b
Update API
msujew Jul 27, 2026
1bcb85e
Review comments
msujew Aug 10, 2026
38ef83a
Optimize binary expression building in O(n)
msujew Aug 10, 2026
efe4301
Rebase
msujew Aug 12, 2026
9d34ba2
Update docs
msujew Aug 20, 2026
eb2bbc4
Improve docs
msujew Aug 25, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
33 changes: 19 additions & 14 deletions cmd/fastbelt/generate.go
View file
Open in desktop

@sailingKieler sailingKieler Aug 28, 2026

Copy link
Copy Markdown
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Why the renaming here? Will cause merge conflict with changes of #130.

Original file line number Diff line number Diff line change
Expand Up @@ -97,14 +97,19 @@ func runGenerateCLI(opts generateOptions) error {
return fmt.Errorf("aborting code generation due to %d errors", errCount)
}

grammar, ok := document.Root.(grammar.Grammar)
gram, ok := document.Root.(grammar.Grammar)
if !ok {
return fmt.Errorf("parser result is not a Grammar")
}
entryRule, err := validateEntryRule(grammar)
entryRule, err := validateEntryRule(gram)
if err != nil {
return err
}
// Desugar infix rules once, so every generator below sees the synthesized
// operator token groups and flat rule bodies.
if err := grammar.ExpandInfixRules(gram); err != nil {
return err
}

writeFile := func(name, path, content string) error {
if err := os.WriteFile(path, []byte(content), 0644); err != nil {
Expand All @@ -117,46 +122,46 @@ func runGenerateCLI(opts generateOptions) error {
}

if err := writeFile("linker", filepath.Join(outputPath, "linker_gen.go"),
generator.GenerateLinker(grammar, packageName)); err != nil {
generator.GenerateLinker(gram, packageName)); err != nil {
return err
}
if err := writeFile("types", filepath.Join(outputPath, "types_gen.go"),
generator.GenerateTypes(grammar, packageName)); err != nil {
generator.GenerateTypes(gram, packageName)); err != nil {
return err
}
tokenTypes := generator.GenerateTokenTypes(grammar)
atnData := generator.BuildParserATNData(grammar, tokenTypes)
tokenTypes := generator.GenerateTokenTypes(gram)
atnData := generator.BuildParserATNData(gram, tokenTypes)
if err := writeFile("parser", filepath.Join(outputPath, "parser_gen.go"),
generator.GenerateParser(grammar, entryRule, packageName, tokenTypes, atnData)); err != nil {
generator.GenerateParser(gram, entryRule, packageName, tokenTypes, atnData)); err != nil {
return err
}
if err := writeFile("completion-parser", filepath.Join(outputPath, "completion_parser_gen.go"),
generator.GenerateCompletionParser(grammar, entryRule, packageName, tokenTypes, atnData)); err != nil {
generator.GenerateCompletionParser(gram, entryRule, packageName, tokenTypes, atnData)); err != nil {
return err
}
if err := writeFile("parser-lookahead", filepath.Join(outputPath, "parser_lookahead_gen.go"),
generator.GenerateParserLookahead(grammar, packageName, tokenTypes, atnData)); err != nil {
generator.GenerateParserLookahead(gram, packageName, tokenTypes, atnData)); err != nil {
return err
}
if err := writeFile("completion", filepath.Join(outputPath, "completion_gen.go"),
generator.GenerateCompletion(grammar, packageName)); err != nil {
generator.GenerateCompletion(gram, packageName)); err != nil {
return err
}
if err := writeFile("lexer", filepath.Join(outputPath, "lexer_gen.go"),
generator.GenerateLexer(grammar, packageName, tokenTypes)); err != nil {
generator.GenerateLexer(gram, packageName, tokenTypes)); err != nil {
return err
}
if err := writeFile("services", filepath.Join(outputPath, "services_gen.go"),
generator.GenerateServices(grammar, packageName)); err != nil {
generator.GenerateServices(gram, packageName)); err != nil {
return err
}
if err := writeFile("atn", filepath.Join(outputPath, "atn_gen.go"),
generator.GenerateATN(grammar, packageName, tokenTypes)); err != nil {
generator.GenerateATN(gram, packageName, tokenTypes)); err != nil {
return err
}
if opts.atn {
if err := writeFile("atn-md", filepath.Join(outputPath, "atn.md"),
generator.GenerateATNMarkdown(grammar, packageName, tokenTypes)); err != nil {
generator.GenerateATNMarkdown(gram, packageName, tokenTypes)); err != nil {
return err
}
}
Expand Down
29 changes: 17 additions & 12 deletions examples/arithmetics/arithmetics.fb
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -58,19 +58,24 @@ Evaluation:
Expression=Expression ";"

Expression:
Addition

Addition returns Expression:
Multiplication ({BinaryExpression.Left=current} Operator=("+" | "-") Right=Multiplication)*

Multiplication returns Expression:
Exponentiation ({BinaryExpression.Left=current} Operator=("*" | "/") Right=Exponentiation)*

Exponentiation returns Expression:
Modulo ({BinaryExpression.Left=current} Operator="^" Right=Modulo)*
BinaryExpression

infix BinaryExpression on PrimaryExpression:
"%"
> right "^"
> MultiplicationOp
> AdditionOp

// Tests that Fastbelt can handle operators nested in token groups
token group MultiplicationOp {
"*"
"/"
}

Modulo returns Expression:
PrimaryExpression ({BinaryExpression.Left=current} Operator="%" Right=PrimaryExpression)*
token group AdditionOp {
"+"
"-"
}

PrimaryExpression returns Expression:
"(" Expression ")" |
Expand Down
Loading