Merge pull request #385 from bjz/rename-ns

Improvements to gl_generator API

Author: brendanzab

gl/Cargo.toml

@@ -15,7 +15,6 @@ readme = "README.md"
 
 [build-dependencies]
 gl_generator = { version = "0.4.2", path = "../gl_generator" }
-khronos_api = { version = "1.0.0", path = "../khronos_api" }
 
 [dev-dependencies]
 glutin = "0.4"

gl/build.rs

@@ -13,20 +13,16 @@
 // limitations under the License.
 
 extern crate gl_generator;
-extern crate khronos_api;
 
-use gl_generator::{Fallbacks, GlobalGenerator, Ns};
+use gl_generator::{Fallbacks, GlobalGenerator, Api, Profile};
 use std::env;
 use std::fs::File;
-use std::io::BufWriter;
 use std::path::Path;
 
 fn main() {
     let out_dir = env::var("OUT_DIR").unwrap();
-    let dest = Path::new(&out_dir);
+    let mut file = File::create(&Path::new(&out_dir).join("bindings.rs")).unwrap();
 
-    let mut file = BufWriter::new(File::create(&dest.join("bindings.rs")).unwrap());
-    gl_generator::generate_bindings(GlobalGenerator, Ns::Gl, Fallbacks::All,
-                                    khronos_api::GL_XML, vec![], "4.5", "core",
-                                    &mut file).unwrap();
+    gl_generator::generate_bindings(GlobalGenerator, Api::Gl, Fallbacks::All,
+                                    vec![], "4.5", Profile::Core, &mut file).unwrap();
 }

gl_generator/README.md

@@ -20,7 +20,6 @@ Add this to your `Cargo.toml`:
 ```toml
 [build-dependencies]
 gl_generator = "0.4.2"
-khronos_api = "1.0.0"
 ```
 
 Under the `[package]` section, add:
@@ -33,22 +32,18 @@ Create a `build.rs` to pull your specific version/API:
 
 ```rust
 extern crate gl_generator;
-extern crate khronos_api;
 
-use gl_generator::{Fallbacks, GlobalGenerator, Ns};
+use gl_generator::{Fallbacks, GlobalGenerator, Api, Profile};
 use std::env;
 use std::fs::File;
-use std::io::BufWriter;
 use std::path::Path;
 
 fn main() {
-    let out_dir = env::var("OUT_DIR").unwrap();
-    let dest = Path::new(&out_dir);
+    let dest = env::var("OUT_DIR").unwrap();
+    let mut file = File::create(&Path::new(&dest).join("bindings.rs")).unwrap();
 
-    let mut file = BufWriter::new(File::create(&dest.join("bindings.rs")).unwrap());
-    gl_generator::generate_bindings(GlobalGenerator, Ns::Gl, Fallbacks::All,
-                                    khronos_api::GL_XML, vec![], "4.5", "core",
-                                    &mut file).unwrap();
+    gl_generator::generate_bindings(GlobalGenerator, Api::Gl, Fallbacks::All,
+                                    vec![], "4.5", Profile::Core, &mut file).unwrap();
 }
 ```
 
@@ -71,25 +66,6 @@ fn main() {
 The `build.rs` file will generate all the OpenGL functions in a file named,
 `bindings.rs` plus all enumerations, and all types in the `types` submodule.
 
-### Arguments
-
-- The type of loader to generate. Can be
-  `gl_generator::StaticGenerator`, `gl_generator::StaticStructGenerator`,
-  `gl_generator::StructGenerator`, or `gl_generator::GlobalGenerator`.
-- The API to generate. Can be `Gl`, `Gles1`, `Gles2`
-  (GLES 2 or 3), `Wgl`, `Glx`, `Egl`.
-- The file which contains the bindings to parse. Can be `GL_XML` (for GL
-  and GL ES), `GLX_XML`, `WGL_XML`, `EGL_XML`.
-- Extra extensions to include in the bindings. These are
-  specified as a list of strings.
-- The requested API version. This is usually in the form
-  `"major.minor"`.
-- The GL profile. Can be either `"core"` or `"compatibility"`. `"core"` will
-  only include all functions supported by the
-  requested version it self, while `"compatibility"` will include all the
-  functions from previous versions as well.
-- The file to save the generated bindings to.
-
 ## Generator types
 
 ### Global generator
@@ -143,6 +119,18 @@ also attempt to load `glGenFramebuffersEXT` as a fallback.
 
 ## Changelog
 
+### vX.X.X
+
+- Rename `Ns` to `API`, and expose at the top level
+- Use `Api` for `Extension::supported` and `Filter::api` fields
+- Remove `source` argument from `generate_bindings`, removing the need for
+  clients to depend on the `khronos_api` crate
+- Add `Profile` enum for specifying the API profile, and change the `source`
+  argument to use it instead of a string
+- Remove `features` and `extensions` fields from `Registry`
+- Hide `registry::{Feature, Filter, Require, Remove, Extension}` from the public API
+- Move `registry::{Fallbacks, Api, Profile}` to top level module
+
 ### v0.4.2
 
 - Update crate metadata

gl_generator/generators/debug_struct_gen.rs

@@ -12,21 +12,21 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use registry::{Registry, Ns};
+use registry::Registry;
 use std::io;
 
 #[allow(missing_copy_implementations)]
 pub struct DebugStructGenerator;
 
 impl super::Generator for DebugStructGenerator {
-    fn write<W>(&self, registry: &Registry, ns: Ns, dest: &mut W) -> io::Result<()> where W: io::Write {
+    fn write<W>(&self, registry: &Registry, dest: &mut W) -> io::Result<()> where W: io::Write {
         try!(write_header(dest));
-        try!(write_type_aliases(&ns, dest));
+        try!(write_type_aliases(registry, dest));
         try!(write_enums(registry, dest));
         try!(write_fnptr_struct_def(dest));
-        try!(write_panicking_fns(&ns, dest));
-        try!(write_struct(registry, &ns, dest));
-        try!(write_impl(registry, &ns, dest));
+        try!(write_panicking_fns(registry, dest));
+        try!(write_struct(registry, dest));
+        try!(write_impl(registry, dest));
         Ok(())
     }
 }
@@ -46,7 +46,7 @@ fn write_header<W>(dest: &mut W) -> io::Result<()> where W: io::Write {
 /// Creates a `types` module which contains all the type aliases.
 ///
 /// See also `generators::gen_type_aliases`.
-fn write_type_aliases<W>(ns: &Ns, dest: &mut W) -> io::Result<()> where W: io::Write {
+fn write_type_aliases<W>(registry: &Registry, dest: &mut W) -> io::Result<()> where W: io::Write {
     try!(writeln!(dest, r#"
         pub mod types {{
             #![allow(non_camel_case_types)]
@@ -55,7 +55,7 @@ fn write_type_aliases<W>(ns: &Ns, dest: &mut W) -> io::Result<()> where W: io::W
             #![allow(missing_copy_implementations)]
     "#));
 
-    try!(super::gen_type_aliases(ns, dest));
+    try!(super::gen_type_aliases(registry.api, dest));
 
     writeln!(dest, "}}")
 }
@@ -111,27 +111,27 @@ fn write_fnptr_struct_def<W>(dest: &mut W) -> io::Result<()> where W: io::Write
 /// Creates a `panicking` module which contains one function per GL command.
 ///
 /// These functions are the mocks that are called if the real function could not be loaded.
-fn write_panicking_fns<W>(ns: &Ns, dest: &mut W) -> io::Result<()> where W: io::Write {
+fn write_panicking_fns<W>(registry: &Registry, dest: &mut W) -> io::Result<()> where W: io::Write {
     writeln!(dest,
         "#[inline(never)]
         fn missing_fn_panic() -> ! {{
-            panic!(\"{ns} function was not loaded\")
+            panic!(\"{api} function was not loaded\")
         }}",
-        ns = ns
+        api = registry.api
     )
 }
 
 /// Creates a structure which stores all the `FnPtr` of the bindings.
 ///
 /// The name of the struct corresponds to the namespace.
-fn write_struct<W>(registry: &Registry, ns: &Ns, dest: &mut W) -> io::Result<()> where W: io::Write {
+fn write_struct<W>(registry: &Registry, dest: &mut W) -> io::Result<()> where W: io::Write {
     try!(writeln!(dest, "
         #[allow(non_camel_case_types)]
         #[allow(non_snake_case)]
         #[allow(dead_code)]
         #[derive(Clone)]
-        pub struct {ns} {{",
-        ns = ns.fmt_struct_name()
+        pub struct {api} {{",
+        api = super::gen_struct_name(registry.api)
     ));
 
     for c in registry.cmd_iter() {
@@ -145,9 +145,9 @@ fn write_struct<W>(registry: &Registry, ns: &Ns, dest: &mut W) -> io::Result<()>
 }
 
 /// Creates the `impl` of the structure created by `write_struct`.
-fn write_impl<W>(registry: &Registry, ns: &Ns, dest: &mut W) -> io::Result<()> where W: io::Write {
+fn write_impl<W>(registry: &Registry, dest: &mut W) -> io::Result<()> where W: io::Write {
     try!(writeln!(dest,
-        "impl {ns} {{
+        "impl {api} {{
             /// Load each OpenGL symbol using a custom load function. This allows for the
             /// use of functions like `glfwGetProcAddress` or `SDL_GL_GetProcAddress`.
             ///
@@ -156,7 +156,7 @@ fn write_impl<W>(registry: &Registry, ns: &Ns, dest: &mut W) -> io::Result<()> w
             /// ~~~
             #[allow(dead_code)]
             #[allow(unused_variables)]
-            pub fn load_with<F>(mut loadfn: F) -> {ns} where F: FnMut(&str) -> *const __gl_imports::raw::c_void {{
+            pub fn load_with<F>(mut loadfn: F) -> {api} where F: FnMut(&str) -> *const __gl_imports::raw::c_void {{
                 let mut metaloadfn = |symbol: &str, symbols: &[&str]| {{
                     let mut ptr = loadfn(symbol);
                     if ptr.is_null() {{
@@ -167,19 +167,19 @@ fn write_impl<W>(registry: &Registry, ns: &Ns, dest: &mut W) -> io::Result<()> w
                     }}
                     ptr
                 }};
-                {ns} {{",
-        ns = ns.fmt_struct_name()
+                {api} {{",
+        api = super::gen_struct_name(registry.api)
     ));
 
     for c in registry.cmd_iter() {
         try!(writeln!(dest,
             "{name}: FnPtr::new(metaloadfn(\"{symbol}\", &[{fallbacks}])),",
             name = c.proto.ident,
-            symbol = super::gen_symbol_name(ns, &c.proto.ident),
+            symbol = super::gen_symbol_name(registry.api, &c.proto.ident),
             fallbacks = match registry.aliases.get(&c.proto.ident) {
                 Some(fbs) => {
                     fbs.iter()
-                       .map(|name| format!("\"{}\"", super::gen_symbol_name(ns, &name)))
+                       .map(|name| format!("\"{}\"", super::gen_symbol_name(registry.api, &name)))
                        .collect::<Vec<_>>().join(", ")
                 },
                 None => format!(""),
@@ -234,7 +234,7 @@ fn write_impl<W>(registry: &Registry, ns: &Ns, dest: &mut W) -> io::Result<()> w
     writeln!(dest,
         "}}
 
-        unsafe impl __gl_imports::Send for {ns} {{}}",
-        ns = ns.fmt_struct_name()
+        unsafe impl __gl_imports::Send for {api} {{}}",
+        api = super::gen_struct_name(registry.api)
     )
 }

gl_generator/generators/global_gen.rs

@@ -12,23 +12,23 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use registry::{Registry, Ns};
+use registry::Registry;
 use std::io;
 
 #[allow(missing_copy_implementations)]
 pub struct GlobalGenerator;
 
 impl super::Generator for GlobalGenerator {
-    fn write<W>(&self, registry: &Registry, ns: Ns, dest: &mut W) -> io::Result<()> where W: io::Write {
+    fn write<W>(&self, registry: &Registry, dest: &mut W) -> io::Result<()> where W: io::Write {
         try!(write_header(dest));
         try!(write_metaloadfn(dest));
-        try!(write_type_aliases(&ns, dest));
+        try!(write_type_aliases(registry, dest));
         try!(write_enums(registry, dest));
         try!(write_fns(registry, dest));
         try!(write_fnptr_struct_def(dest));
         try!(write_ptrs(registry, dest));
-        try!(write_fn_mods(registry, &ns, dest));
-        try!(write_panicking_fns(&ns, dest));
+        try!(write_fn_mods(registry, dest));
+        try!(write_panicking_fns(registry, dest));
         try!(write_load_fn(registry, dest));
         Ok(())
     }
@@ -67,7 +67,7 @@ fn write_metaloadfn<W>(dest: &mut W) -> io::Result<()> where W: io::Write {
 /// Creates a `types` module which contains all the type aliases.
 ///
 /// See also `generators::gen_type_aliases`.
-fn write_type_aliases<W>(ns: &Ns, dest: &mut W) -> io::Result<()> where W: io::Write {
+fn write_type_aliases<W>(registry: &Registry, dest: &mut W) -> io::Result<()> where W: io::Write {
     try!(writeln!(dest, r#"
         pub mod types {{
             #![allow(non_camel_case_types)]
@@ -76,7 +76,7 @@ fn write_type_aliases<W>(ns: &Ns, dest: &mut W) -> io::Result<()> where W: io::W
             #![allow(missing_copy_implementations)]
     "#));
 
-    try!(super::gen_type_aliases(ns, dest));
+    try!(super::gen_type_aliases(registry.api, dest));
 
     writeln!(dest, "
         }}
@@ -169,16 +169,16 @@ fn write_ptrs<W>(registry: &Registry, dest: &mut W) -> io::Result<()> where W: i
 ///
 /// Each module contains `is_loaded` and `load_with` which interact with the `storage` module
 ///  created by `write_ptrs`.
-fn write_fn_mods<W>(registry: &Registry, ns: &Ns, dest: &mut W) -> io::Result<()> where W: io::Write {
+fn write_fn_mods<W>(registry: &Registry, dest: &mut W) -> io::Result<()> where W: io::Write {
     for c in registry.cmd_iter() {
         let fallbacks = match registry.aliases.get(&c.proto.ident) {
             Some(v) => {
-                let names = v.iter().map(|name| format!("\"{}\"", super::gen_symbol_name(ns, &name[..]))).collect::<Vec<_>>();
+                let names = v.iter().map(|name| format!("\"{}\"", super::gen_symbol_name(registry.api, &name[..]))).collect::<Vec<_>>();
                 format!("&[{}]", names.join(", "))
             }, None => "&[]".to_string(),
         };
         let fnname = &c.proto.ident[..];
-        let symbol = super::gen_symbol_name(ns, &c.proto.ident[..]);
+        let symbol = super::gen_symbol_name(registry.api, &c.proto.ident[..]);
         let symbol = &symbol[..];
 
         try!(writeln!(dest, r##"
@@ -210,13 +210,13 @@ fn write_fn_mods<W>(registry: &Registry, ns: &Ns, dest: &mut W) -> io::Result<()
 /// Creates a `missing_fn_panic` function.
 ///
 /// This function is the mock that is called if the real function could not be called.
-fn write_panicking_fns<W>(ns: &Ns, dest: &mut W) -> io::Result<()> where W: io::Write {
+fn write_panicking_fns<W>(registry: &Registry, dest: &mut W) -> io::Result<()> where W: io::Write {
     writeln!(dest,
         "#[inline(never)]
         fn missing_fn_panic() -> ! {{
-            panic!(\"{ns} function was not loaded\")
+            panic!(\"{api} function was not loaded\")
         }}
-        ", ns = ns)
+        ", api = registry.api)
 }
 
 /// Creates the `load_with` function.