Skip to content

Commit bfc6228

Browse files
brendanzabbrendanzab
committed
Rename RegistryBuilder to RegistryParser
The 'Builder' suffix doesn't make sense here - it is normally used for denoting stucts that provide Builder APIs. 'Parser' seems more appropriate here.
1 parent ffbc2f9 commit bfc6228

File tree

2 files changed

+36
-40
lines changed

2 files changed

+36
-40
lines changed

‎gl_generator/lib.rs

Lines changed: 1 addition & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -60,7 +60,6 @@
6060
//! - `NativeWindowType`
6161
//!
6262
63-
extern crate khronos_api;
6463
#[macro_use]
6564
extern crate log;
6665

@@ -120,8 +119,6 @@ pub fn generate_bindings<G, W>(generator: G, api: Api, fallbacks: Fallbacks,
120119
extensions: Vec<String>, version: &str, profile: Profile,
121120
dest: &mut W) -> io::Result<()> where G: Generator, W: io::Write
122121
{
123-
// Get generator field values, using default values if they have not been
124-
// specified
125122
let filter = Filter {
126123
api: api,
127124
fallbacks: fallbacks,
@@ -130,17 +127,6 @@ pub fn generate_bindings<G, W>(generator: G, api: Api, fallbacks: Fallbacks,
130127
profile: profile,
131128
};
132129

133-
// Generate the registry of all bindings
134-
let registry = {
135-
let src = match api {
136-
Api::Gl | Api::GlCore | Api::Gles1 | Api::Gles2 => khronos_api::GL_XML,
137-
Api::Glx => khronos_api::GLX_XML,
138-
Api::Wgl => khronos_api::WGL_XML,
139-
Api::Egl => khronos_api::EGL_XML,
140-
};
141-
142-
Registry::from_xml(src, api, filter)
143-
};
144-
130+
let registry = Registry::new(api, filter);
145131
generator.write(&registry, dest)
146132
}

‎gl_generator/registry.rs

Lines changed: 35 additions & 25 deletions
Original file line numberDiff line numberDiff line change
@@ -14,6 +14,7 @@
1414
// limitations under the License.
1515

1616
extern crate xml;
17+
extern crate khronos_api;
1718

1819
use std::collections::hash_map::Entry;
1920
use std::collections::BTreeSet;
@@ -98,11 +99,15 @@ pub struct Registry {
9899

99100
impl Registry {
100101
/// Generate a registry from the supplied XML string
101-
pub fn from_xml<R: io::Read>(data: R, api: Api, filter: Filter) -> Registry {
102-
RegistryBuilder {
103-
api: api,
104-
reader: XmlEventReader::new(data),
105-
}.consume_registry(filter)
102+
pub fn new(api: Api, filter: Filter) -> Registry {
103+
let src = match api {
104+
Api::Gl | Api::GlCore | Api::Gles1 | Api::Gles2 => khronos_api::GL_XML,
105+
Api::Glx => self::khronos_api::GLX_XML,
106+
Api::Wgl => self::khronos_api::WGL_XML,
107+
Api::Egl => self::khronos_api::EGL_XML,
108+
};
109+
110+
RegistryParser::parse(src, api, filter)
106111
}
107112

108113
/// Returns a set of all the types used in the supplied registry. This is useful
@@ -245,7 +250,7 @@ pub struct GlxOpcode {
245250
pub name: Option<String>,
246251
}
247252

248-
struct RegistryBuilder<R: io::Read> {
253+
struct RegistryParser<R: io::Read> {
249254
pub api: Api,
250255
pub reader: XmlEventReader<R>,
251256
}
@@ -259,7 +264,7 @@ pub struct Filter {
259264
}
260265

261266
/// A big, ugly, imperative impl with methods that accumulates a Registry struct
262-
impl<R: io::Read> RegistryBuilder<R> {
267+
impl<R: io::Read> RegistryParser<R> {
263268
fn next(&mut self) -> XmlEvent {
264269
loop {
265270
let event = self.reader.next();
@@ -308,8 +313,13 @@ impl<R: io::Read> RegistryBuilder<R> {
308313
}
309314
}
310315

311-
fn consume_registry(&mut self, filter: Filter) -> Registry {
312-
self.expect_start_element("registry");
316+
fn parse(src: R, api: Api, filter: Filter) -> Registry {
317+
let mut parser = RegistryParser {
318+
api: api,
319+
reader: XmlEventReader::new(src),
320+
};
321+
322+
parser.expect_start_element("registry");
313323

314324
let mut enums = Vec::new();
315325
let mut cmds = Vec::new();
@@ -318,35 +328,35 @@ impl<R: io::Read> RegistryBuilder<R> {
318328
let mut aliases = HashMap::new();
319329

320330
loop {
321-
match self.next() {
331+
match parser.next() {
322332
// ignores
323333
XmlEvent::Characters(_) | XmlEvent::Comment(_) => (),
324-
XmlEvent::StartElement { ref name, .. } if name.local_name == "comment" => self.skip_to_end("comment"),
325-
XmlEvent::StartElement { ref name, .. } if name.local_name == "types" => self.skip_to_end("types"),
326-
XmlEvent::StartElement { ref name, .. } if name.local_name == "groups" => self.skip_to_end("groups"),
334+
XmlEvent::StartElement { ref name, .. } if name.local_name == "comment" => parser.skip_to_end("comment"),
335+
XmlEvent::StartElement { ref name, .. } if name.local_name == "types" => parser.skip_to_end("types"),
336+
XmlEvent::StartElement { ref name, .. } if name.local_name == "groups" => parser.skip_to_end("groups"),
327337

328338
// add enum namespace
329339
XmlEvent::StartElement{ref name, ..} if name.local_name == "enums" => {
330-
enums.extend(self.consume_enums().into_iter());
340+
enums.extend(parser.consume_enums().into_iter());
331341
}
332342

333343
// add command namespace
334344
XmlEvent::StartElement{ref name, ..} if name.local_name == "commands" => {
335-
let (new_cmds, new_aliases) = self.consume_cmds();
345+
let (new_cmds, new_aliases) = parser.consume_cmds();
336346
cmds.extend(new_cmds.into_iter());
337347
merge_map(&mut aliases, new_aliases);
338348
}
339349

340350
XmlEvent::StartElement{ref name, ref attributes, ..} if name.local_name == "feature" => {
341351
debug!("Parsing feature: {:?}", attributes);
342-
features.push(Feature::convert(self, &attributes));
352+
features.push(Feature::convert(&mut parser, &attributes));
343353
}
344354

345355
XmlEvent::StartElement{ref name, ..} if name.local_name == "extensions" => {
346356
loop {
347-
match self.next() {
357+
match parser.next() {
348358
XmlEvent::StartElement{ref name, ref attributes, ..} if name.local_name == "extension" => {
349-
extensions.push(Extension::convert(self, &attributes));
359+
extensions.push(Extension::convert(&mut parser, &attributes));
350360
}
351361
XmlEvent::EndElement{ref name} if name.local_name == "extensions" => break,
352362
msg => panic!("Unexpected message {:?}", msg),
@@ -430,7 +440,7 @@ impl<R: io::Read> RegistryBuilder<R> {
430440
};
431441

432442
Registry {
433-
api: self.api,
443+
api: api,
434444
enums: enums.into_iter().filter(is_desired_enum).collect(),
435445
cmds: cmds.into_iter().filter(is_desired_cmd).collect(),
436446
aliases: if filter.fallbacks == Fallbacks::None { HashMap::new() } else { aliases },
@@ -625,11 +635,11 @@ fn get_attribute(a: &[OwnedAttribute], name: &str) -> Option<String> {
625635
}
626636

627637
trait FromXml {
628-
fn convert<R: io::Read>(r: &mut RegistryBuilder<R>, a: &[OwnedAttribute]) -> Self;
638+
fn convert<R: io::Read>(r: &mut RegistryParser<R>, a: &[OwnedAttribute]) -> Self;
629639
}
630640

631641
impl FromXml for Require {
632-
fn convert<R: io::Read>(r: &mut RegistryBuilder<R>, _: &[OwnedAttribute]) -> Require {
642+
fn convert<R: io::Read>(r: &mut RegistryParser<R>, _: &[OwnedAttribute]) -> Require {
633643
debug!("Doing a FromXml on Require");
634644
let (enums, commands) = r.consume_two("enum", "command", "require");
635645
Require {
@@ -640,7 +650,7 @@ impl FromXml for Require {
640650
}
641651

642652
impl FromXml for Remove {
643-
fn convert<R: io::Read>(r: &mut RegistryBuilder<R>, a: &[OwnedAttribute]) -> Remove {
653+
fn convert<R: io::Read>(r: &mut RegistryParser<R>, a: &[OwnedAttribute]) -> Remove {
644654
debug!("Doing a FromXml on Remove");
645655
let profile = get_attribute(a, "profile").unwrap();
646656
let profile = Profile::from_str(&*profile).unwrap();
@@ -655,7 +665,7 @@ impl FromXml for Remove {
655665
}
656666

657667
impl FromXml for Feature {
658-
fn convert<R: io::Read>(r: &mut RegistryBuilder<R>, a: &[OwnedAttribute]) -> Feature {
668+
fn convert<R: io::Read>(r: &mut RegistryParser<R>, a: &[OwnedAttribute]) -> Feature {
659669
debug!("Doing a FromXml on Feature");
660670
let api = get_attribute(a, "api").unwrap();
661671
let api = Api::from_str(&*api).unwrap();
@@ -677,7 +687,7 @@ impl FromXml for Feature {
677687
}
678688

679689
impl FromXml for Extension {
680-
fn convert<R: io::Read>(r: &mut RegistryBuilder<R>, a: &[OwnedAttribute]) -> Extension {
690+
fn convert<R: io::Read>(r: &mut RegistryParser<R>, a: &[OwnedAttribute]) -> Extension {
681691
debug!("Doing a FromXml on Extension");
682692
let name = get_attribute(a, "name").unwrap();
683693
let supported = get_attribute(a, "supported").unwrap()
@@ -705,7 +715,7 @@ impl FromXml for Extension {
705715
}
706716

707717
impl FromXml for String {
708-
fn convert<R: io::Read>(_: &mut RegistryBuilder<R>, a: &[OwnedAttribute]) -> String {
718+
fn convert<R: io::Read>(_: &mut RegistryParser<R>, a: &[OwnedAttribute]) -> String {
709719
get_attribute(a, "name").unwrap()
710720
}
711721
}

0 commit comments

Comments
 (0)