1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
|
package main
import (
"encoding/json"
"fmt"
"io/ioutil"
"os"
"runtime/debug"
mldriver "github.com/nihei9/maleeni/driver"
"github.com/nihei9/vartan/driver"
"github.com/nihei9/vartan/spec"
"github.com/spf13/cobra"
)
func Execute() error {
err := generateCmd.Execute()
if err != nil {
fmt.Fprintf(os.Stderr, "%v\n", err)
return err
}
return nil
}
var generateFlags = struct {
pkgName *string
}{}
var generateCmd = &cobra.Command{
Use: "vartan-go",
Short: "Generate a parser for Go",
Long: `vartan-go generates a parser for Go.`,
Example: ` vartan-go grammar.json`,
Args: cobra.ExactArgs(1),
RunE: runGenerate,
SilenceErrors: true,
SilenceUsage: true,
}
func init() {
generateFlags.pkgName = generateCmd.Flags().StringP("package", "p", "main", "package name")
}
func runGenerate(cmd *cobra.Command, args []string) (retErr error) {
defer func() {
panicked := false
v := recover()
if v != nil {
err, ok := v.(error)
if !ok {
retErr = fmt.Errorf("an unexpected error occurred: %v", v)
fmt.Fprintf(os.Stderr, "%v:\n%v", retErr, string(debug.Stack()))
return
}
retErr = err
panicked = true
}
if retErr != nil {
if panicked {
fmt.Fprintf(os.Stderr, "%v:\n%v", retErr, string(debug.Stack()))
} else {
fmt.Fprintf(os.Stderr, "%v\n", retErr)
}
}
}()
cgram, err := readCompiledGrammar(args[0])
if err != nil {
return fmt.Errorf("Cannot read a compiled grammar: %w", err)
}
{
b, err := mldriver.GenLexer(cgram.LexicalSpecification.Maleeni.Spec, *generateFlags.pkgName)
if err != nil {
return fmt.Errorf("Failed to generate a lexer: %w", err)
}
filePath := fmt.Sprintf("%v_lexer.go", cgram.Name)
f, err := os.OpenFile(filePath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0644)
if err != nil {
return fmt.Errorf("Failed to create an output file: %v", err)
}
defer f.Close()
_, err = f.Write(b)
if err != nil {
return fmt.Errorf("Failed to write lexer source code: %v", err)
}
}
{
b, err := driver.GenParser(cgram, *generateFlags.pkgName)
if err != nil {
return fmt.Errorf("Failed to generate a parser: %w", err)
}
filePath := fmt.Sprintf("%v_parser.go", cgram.Name)
f, err := os.OpenFile(filePath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0644)
if err != nil {
return fmt.Errorf("Failed to create an output file: %v", err)
}
defer f.Close()
_, err = f.Write(b)
if err != nil {
return fmt.Errorf("Failed to write parser source code: %v", err)
}
}
{
b, err := driver.GenSemanticAction(*generateFlags.pkgName)
if err != nil {
return fmt.Errorf("Failed to generate a semantic action set: %w", err)
}
filePath := fmt.Sprintf("%v_semantic_action.go", cgram.Name)
f, err := os.OpenFile(filePath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0644)
if err != nil {
return fmt.Errorf("Failed to create an output file: %v", err)
}
defer f.Close()
_, err = f.Write(b)
if err != nil {
return fmt.Errorf("Failed to write semantic action source code: %v", err)
}
}
return nil
}
func readCompiledGrammar(path string) (*spec.CompiledGrammar, error) {
f, err := os.Open(path)
if err != nil {
return nil, err
}
data, err := ioutil.ReadAll(f)
if err != nil {
return nil, err
}
cgram := &spec.CompiledGrammar{}
err = json.Unmarshal(data, cgram)
if err != nil {
return nil, err
}
return cgram, nil
}
|
