Run rustfmt

Author: brendanzab

gl/examples/triangle.rs

@@ -22,22 +22,16 @@ use std::str;
 use std::ffi::CString;
 
 // Vertex data
-static VERTEX_DATA: [GLfloat; 6] = [
-     0.0,  0.5,
-     0.5, -0.5,
-    -0.5, -0.5
-];
+static VERTEX_DATA: [GLfloat; 6] = [0.0, 0.5, 0.5, -0.5, -0.5, -0.5];
 
 // Shader sources
-static VS_SRC: &'static str =
-   "#version 150\n\
+static VS_SRC: &'static str = "#version 150\n\
     in vec2 position;\n\
     void main() {\n\
        gl_Position = vec4(position, 0.0, 1.0);\n\
     }";
 
-static FS_SRC: &'static str =
-   "#version 150\n\
+static FS_SRC: &'static str = "#version 150\n\
     out vec4 out_color;\n\
     void main() {\n\
        out_color = vec4(1.0, 1.0, 1.0, 1.0);\n\
@@ -62,33 +56,47 @@ fn compile_shader(src: &str, ty: GLenum) -> GLuint {
             gl::GetShaderiv(shader, gl::INFO_LOG_LENGTH, &mut len);
             let mut buf = Vec::with_capacity(len as usize);
             buf.set_len((len as usize) - 1); // subtract 1 to skip the trailing null character
-            gl::GetShaderInfoLog(shader, len, ptr::null_mut(), buf.as_mut_ptr() as *mut GLchar);
-            panic!("{}", str::from_utf8(&buf).ok().expect("ShaderInfoLog not valid utf8"));
+            gl::GetShaderInfoLog(shader,
+                                 len,
+                                 ptr::null_mut(),
+                                 buf.as_mut_ptr() as *mut GLchar);
+            panic!("{}",
+                   str::from_utf8(&buf)
+                       .ok()
+                       .expect("ShaderInfoLog not valid utf8"));
         }
     }
     shader
 }
 
-fn link_program(vs: GLuint, fs: GLuint) -> GLuint { unsafe {
-    let program = gl::CreateProgram();
-    gl::AttachShader(program, vs);
-    gl::AttachShader(program, fs);
-    gl::LinkProgram(program);
-    // Get the link status
-    let mut status = gl::FALSE as GLint;
-    gl::GetProgramiv(program, gl::LINK_STATUS, &mut status);
-
-    // Fail on error
-    if status != (gl::TRUE as GLint) {
-        let mut len: GLint = 0;
-        gl::GetProgramiv(program, gl::INFO_LOG_LENGTH, &mut len);
-        let mut buf = Vec::with_capacity(len as usize);
-        buf.set_len((len as usize) - 1); // subtract 1 to skip the trailing null character
-        gl::GetProgramInfoLog(program, len, ptr::null_mut(), buf.as_mut_ptr() as *mut GLchar);
-        panic!("{}", str::from_utf8(&buf).ok().expect("ProgramInfoLog not valid utf8"));
+fn link_program(vs: GLuint, fs: GLuint) -> GLuint {
+    unsafe {
+        let program = gl::CreateProgram();
+        gl::AttachShader(program, vs);
+        gl::AttachShader(program, fs);
+        gl::LinkProgram(program);
+        // Get the link status
+        let mut status = gl::FALSE as GLint;
+        gl::GetProgramiv(program, gl::LINK_STATUS, &mut status);
+
+        // Fail on error
+        if status != (gl::TRUE as GLint) {
+            let mut len: GLint = 0;
+            gl::GetProgramiv(program, gl::INFO_LOG_LENGTH, &mut len);
+            let mut buf = Vec::with_capacity(len as usize);
+            buf.set_len((len as usize) - 1); // subtract 1 to skip the trailing null character
+            gl::GetProgramInfoLog(program,
+                                  len,
+                                  ptr::null_mut(),
+                                  buf.as_mut_ptr() as *mut GLchar);
+            panic!("{}",
+                   str::from_utf8(&buf)
+                       .ok()
+                       .expect("ProgramInfoLog not valid utf8"));
+        }
+        program
     }
-    program
-} }
+}
 
 fn main() {
     let window = glutin::Window::new().unwrap();
@@ -123,15 +131,17 @@ fn main() {
 
         // Use shader program
         gl::UseProgram(program);
-        gl::BindFragDataLocation(program, 0,
-                                 CString::new("out_color").unwrap().as_ptr());
+        gl::BindFragDataLocation(program, 0, CString::new("out_color").unwrap().as_ptr());
 
         // Specify the layout of the vertex data
-        let pos_attr = gl::GetAttribLocation(program,
-                                             CString::new("position").unwrap().as_ptr());
+        let pos_attr = gl::GetAttribLocation(program, CString::new("position").unwrap().as_ptr());
         gl::EnableVertexAttribArray(pos_attr as GLuint);
-        gl::VertexAttribPointer(pos_attr as GLuint, 2, gl::FLOAT,
-                                gl::FALSE as GLboolean, 0, ptr::null());
+        gl::VertexAttribPointer(pos_attr as GLuint,
+                                2,
+                                gl::FLOAT,
+                                gl::FALSE as GLboolean,
+                                0,
+                                ptr::null());
     }
 
     for event in window.wait_events() {

gl_generator/generators/debug_struct_gen.rs

@@ -19,7 +19,9 @@ use std::io;
 pub struct DebugStructGenerator;
 
 impl super::Generator for DebugStructGenerator {
-    fn write<W>(&self, registry: &Registry, 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(registry, dest));
         try!(write_enums(registry, dest));
@@ -33,8 +35,11 @@ impl super::Generator for DebugStructGenerator {
 
 /// Creates a `__gl_imports` module which contains all the external symbols that we need for the
 ///  bindings.
-fn write_header<W>(dest: &mut W) -> io::Result<()> where W: io::Write {
-    writeln!(dest, r#"
+fn write_header<W>(dest: &mut W) -> io::Result<()>
+    where W: io::Write
+{
+    writeln!(dest,
+             r#"
         mod __gl_imports {{
             pub use std::mem;
             pub use std::marker::Send;
@@ -46,8 +51,11 @@ 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_types`.
-fn write_type_aliases<W>(registry: &Registry, dest: &mut W) -> io::Result<()> where W: io::Write {
-    try!(writeln!(dest, r#"
+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, non_snake_case, dead_code, missing_copy_implementations)]
     "#));
@@ -58,7 +66,9 @@ fn write_type_aliases<W>(registry: &Registry, dest: &mut W) -> io::Result<()> wh
 }
 
 /// Creates all the `<enum>` elements at the root of the bindings.
-fn write_enums<W>(registry: &Registry, dest: &mut W) -> io::Result<()> where W: io::Write {
+fn write_enums<W>(registry: &Registry, dest: &mut W) -> io::Result<()>
+    where W: io::Write
+{
     for enm in &registry.enums {
         try!(super::gen_enum_item(enm, "types::", dest));
     }
@@ -67,8 +77,11 @@ fn write_enums<W>(registry: &Registry, dest: &mut W) -> io::Result<()> where W:
 }
 
 /// Creates a `FnPtr` structure which contains the store for a single binding.
-fn write_fnptr_struct_def<W>(dest: &mut W) -> io::Result<()> where W: io::Write {
-    writeln!(dest, "
+fn write_fnptr_struct_def<W>(dest: &mut W) -> io::Result<()>
+    where W: io::Write
+{
+    writeln!(dest,
+             "
         #[allow(dead_code, missing_copy_implementations)]
         #[derive(Clone)]
         pub struct FnPtr {{
@@ -106,26 +119,29 @@ 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>(registry: &Registry, 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)]
+             "#[inline(never)]
         fn missing_fn_panic() -> ! {{
             panic!(\"{api} function was not loaded\")
         }}",
-        api = registry.api
-    )
+             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, dest: &mut W) -> io::Result<()> where W: io::Write {
-    try!(writeln!(dest, "
+fn write_struct<W>(registry: &Registry, dest: &mut W) -> io::Result<()>
+    where W: io::Write
+{
+    try!(writeln!(dest,
+                  "
         #[allow(non_camel_case_types, non_snake_case, dead_code)]
         #[derive(Clone)]
         pub struct {api} {{",
-        api = super::gen_struct_name(registry.api)
-    ));
+                  api = super::gen_struct_name(registry.api)));
 
     for cmd in &registry.cmds {
         if let Some(v) = registry.aliases.get(&cmd.proto.ident) {
@@ -138,9 +154,11 @@ fn write_struct<W>(registry: &Registry, dest: &mut W) -> io::Result<()> where W:
 }
 
 /// Creates the `impl` of the structure created by `write_struct`.
-fn write_impl<W>(registry: &Registry, 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 {api} {{
+                  "impl {api} {{
             /// Load each OpenGL symbol using a custom load function. This allows for the
             /// use of functions like `glfwGetProcAddress` or `SDL_GL_GetProcAddress`.
             ///
@@ -167,8 +185,7 @@ fn write_impl<W>(registry: &Registry, dest: &mut W) -> io::Result<()> where W: i
                     do_metaloadfn(&mut loadfn, symbol, symbols)
                 }};
                 {api} {{",
-        api = super::gen_struct_name(registry.api)
-    ));
+                  api = super::gen_struct_name(registry.api)));
 
     for cmd in &registry.cmds {
         try!(writeln!(dest,
@@ -187,53 +204,60 @@ fn write_impl<W>(registry: &Registry, dest: &mut W) -> io::Result<()> where W: i
     }
 
     try!(writeln!(dest,
-            "}}
-        }}"
-    ));
+                  "}}
+        }}"));
 
     for cmd in &registry.cmds {
         let idents = super::gen_parameters(cmd, true, false);
         let typed_params = super::gen_parameters(cmd, false, true);
         let println = format!("println!(\"[OpenGL] {}({})\" {});",
-                                cmd.proto.ident,
-                                (0 .. idents.len()).map(|_| "{:?}".to_string()).collect::<Vec<_>>().join(", "),
-                                idents.iter().zip(typed_params.iter())
-                                      .map(|(name, ty)| {
-                                          if ty.contains("GLDEBUGPROC") {
-                                              format!(", \"<callback>\"")
-                                          } else {
-                                              format!(", {}", name)
-                                          }
-                                      }).collect::<Vec<_>>().concat());
+                              cmd.proto.ident,
+                              (0..idents.len())
+                                  .map(|_| "{:?}".to_string())
+                                  .collect::<Vec<_>>()
+                                  .join(", "),
+                              idents
+                                  .iter()
+                                  .zip(typed_params.iter())
+                                  .map(|(name, ty)| if ty.contains("GLDEBUGPROC") {
+                                           format!(", \"<callback>\"")
+                                       } else {
+                                           format!(", {}", name)
+                                       })
+                                  .collect::<Vec<_>>()
+                                  .concat());
 
         try!(writeln!(dest,
-            "#[allow(non_snake_case, unused_variables, dead_code)]
+                      "#[allow(non_snake_case, unused_variables, dead_code)]
             #[inline] pub unsafe fn {name}(&self, {params}) -> {return_suffix} {{ \
                 {println}
                 let r = __gl_imports::mem::transmute::<_, extern \"system\" fn({typed_params}) -> {return_suffix}>\
                     (self.{name}.f)({idents});
                 {print_err}
                 r
             }}",
-            name = cmd.proto.ident,
-            params = super::gen_parameters(cmd, true, true).join(", "),
-            typed_params = typed_params.join(", "),
-            return_suffix = cmd.proto.ty,
-            idents = idents.join(", "),
-            println = println,
-            print_err = if cmd.proto.ident != "GetError" && registry.cmds.iter().find(|cmd| cmd.proto.ident == "GetError").is_some() {
-                format!(r#"match __gl_imports::mem::transmute::<_, extern "system" fn() -> u32>
+                      name = cmd.proto.ident,
+                      params = super::gen_parameters(cmd, true, true).join(", "),
+                      typed_params = typed_params.join(", "),
+                      return_suffix = cmd.proto.ty,
+                      idents = idents.join(", "),
+                      println = println,
+                      print_err = if cmd.proto.ident != "GetError" &&
+                                     registry
+                                         .cmds
+                                         .iter()
+                                         .find(|cmd| cmd.proto.ident == "GetError")
+                                         .is_some() {
+                          format!(r#"match __gl_imports::mem::transmute::<_, extern "system" fn() -> u32>
                     (self.GetError.f)() {{ 0 => (), r => println!("[OpenGL] ^ GL error triggered: {{}}", r) }}"#)
-            } else {
-                format!("")
-            }
-        ))
+                      } else {
+                          format!("")
+                      }))
     }
 
     writeln!(dest,
-        "}}
+             "}}
 
         unsafe impl __gl_imports::Send for {api} {{}}",
-        api = super::gen_struct_name(registry.api)
-    )
+             api = super::gen_struct_name(registry.api))
 }