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
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
|
package bjc.rgens.newparser;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;
/**
* Represents a set of grammars that can share rules via exports.
*
* @author EVE
*
*/
public class RGrammarSet {
private Map<String, RGrammar> grammars;
private Map<String, RGrammar> exportedRules;
/**
* Create a new set of randomized grammars.
*/
public RGrammarSet() {
grammars = new HashMap<>();
exportedRules = new HashMap<>();
}
/**
* Add a grammar to this grammar set.
*
* @param grammarName
* The name of the grammar to add.
*
* @param gram
* The grammar to add.
*
* @throws IllegalArgumentException
* If the grammar name is invalid.
*/
public void addGrammar(String grammarName, RGrammar gram) {
if(grammarName == null) {
throw new NullPointerException("Grammar name must not be null");
} else if(gram == null) {
throw new NullPointerException("Grammar must not be null");
} else if(grammarName.equals("")) {
throw new IllegalArgumentException("The empty string is not a valid grammar name");
}
grammars.put(grammarName, gram);
for(Rule export : gram.getExportedRules()) {
exportedRules.put(export.ruleName, gram);
}
gram.setImportedRules(exportedRules);
}
/**
* Get a grammar from this grammar set.
*
* @param grammarName
* The name of the grammar to get.
*
* @return The grammar with that name.
*
* @throws IllegalArgumentException
* If the grammar name is invalid or not present in this
* set.
*/
public RGrammar getGrammar(String grammarName) {
if(grammarName == null) {
throw new NullPointerException("Grammar name must not be null");
} else if(grammarName.equals("")) {
throw new IllegalArgumentException("The empty string is not a valid grammar name");
} else if(!grammars.containsKey("")) {
throw new IllegalArgumentException(
String.format("No grammar with name '%s' found", grammarName));
}
return grammars.get(grammarName);
}
/**
* Get the grammar a rule was exported from.
*
* @param exportName
* The name of the exported rule.
*
* @return The grammar the exported rule came from.
*
* @throws IllegalArgumentException
* If the export name is invalid or not present in this
* set.
*/
public RGrammar getExportSource(String exportName) {
if(exportName == null) {
throw new NullPointerException("Export name must not be null");
} else if(exportName.equals("")) {
throw new IllegalArgumentException("The empty string is not a valid rule name");
} else if(!exportedRules.containsKey(exportName)) {
throw new IllegalArgumentException(String.format("No export with name '%s' found", exportName));
}
return exportedRules.get(exportName);
}
/**
* Get the names of all the grammars in this set.
*
* @return The names of all the grammars in this set.
*/
public Set<String> getGrammars() {
return grammars.keySet();
}
/**
* Get the names of all the exported rules in this set.
*
* @return The names of all the exported rules in this set.
*/
public Set<String> getExportedRules() {
return exportedRules.keySet();
}
/**
* Load a grammar set from a configuration file.
*
* @param cfgFile
* The configuration file to load from.
*
* @return The grammar set created by the configuration file.
*
* @throws IOException
* If something goes wrong during configuration loading.
*/
public static RGrammarSet fromConfigFile(Path cfgFile) throws IOException {
RGrammarSet set = new RGrammarSet();
RGrammarParser parser = new RGrammarParser();
Path cfgParent = cfgFile.getParent();
try(Scanner scn = new Scanner(cfgFile)) {
/*
* Execute lines from the configuration file.
*/
while(scn.hasNextLine()) {
String ln = scn.nextLine().trim();
/*
* Ignore blank/comment lines.
*/
if(ln.equals("")) continue;
if(ln.startsWith("#")) continue;
/*
* Handle mixed whitespace
*/
ln = ln.replaceAll("\\s+", " ");
int nameIdx = ln.indexOf(" ");
if(nameIdx == -1) {
throw new GrammarException("Must specify a name for a loaded grammar");
}
/*
* Name and path of grammar.
*/
String name = ln.substring(0, nameIdx);
Path path = Paths.get(ln.substring(nameIdx).trim());
/*
* Convert from configuration relative path.
*/
Path convPath = cfgParent.resolve(path);
File fle = convPath.toFile();
if(fle.isDirectory()) {
/*
* TODO implement subset grammars
*/
throw new GrammarException("Sub-grammar sets aren't implemented yet");
} else if(fle.getName().endsWith(".gram")) {
/*
* Load grammar files.
*/
try {
RGrammar gram = parser.readGrammar(new FileInputStream(fle));
set.addGrammar(name, gram);
} catch(GrammarException gex) {
throw new GrammarException(
String.format("Error loading file '%s'", path), gex);
}
} else {
throw new GrammarException(String.format("Unrecognized file '%s'"));
}
}
}
return set;
}
}
|
