Merge branch 'CurrySoftware/master'.

This merge commit patches the feature branch to support the recently
added visitor feature from master.

Author: hadronized

src/parsers.rs

@@ -1486,6 +1486,7 @@ named!(pub translation_unit<&[u8], syntax::TranslationUnit>,
 /// Parse a preprocessor command.
 named!(pub preprocessor<&[u8], syntax::Preprocessor>,
   bl!(alt!(
+    map!(pp_define, syntax::Preprocessor::Define) |
     map!(pp_version, syntax::Preprocessor::Version) |
     map!(pp_extension, syntax::Preprocessor::Extension)
   ))
@@ -1514,6 +1515,23 @@ macro_rules! ppws {
   }}
 }
 
+/// Parse a #define
+named!(pub pp_define<&[u8], syntax::PreprocessorDefine>,
+  ppws!(do_parse!(
+    char!('#') >>
+      tag!("define") >>
+      name: identifier >>
+      value: primary_expr>>
+      char!('\n') >>
+
+      (syntax::PreprocessorDefine {
+        name: name,
+        value: value
+      })
+  ))
+);
+
+
 /// Parse a #version.
 named!(pub pp_version<&[u8], syntax::PreprocessorVersion>,
   ppws!(do_parse!(
@@ -3193,7 +3211,31 @@ mod tests {
                                profile: Some(syntax::PreprocessorVersionProfile::Core)
                              })));
   }
-  
+
+  #[test]
+  fn parse_define() {
+    assert_eq!(preprocessor(&b"#define test 1.0\n"[..]),
+               IResult::Done(&b""[..],
+                             syntax::Preprocessor::Define(syntax::PreprocessorDefine {
+                               name: "test".into(),
+                               value: syntax::Expr::DoubleConst(1.0)
+                             })));
+
+    assert_eq!(preprocessor(&b"#define test123 .0f\n"[..]),
+               IResult::Done(&b""[..],
+                             syntax::Preprocessor::Define(syntax::PreprocessorDefine {
+                               name: "test123".into(),
+                               value: syntax::Expr::FloatConst(0.0)
+                             })));
+
+    assert_eq!(preprocessor(&b"#define test 1\n"[..]),
+               IResult::Done(&b""[..],
+                             syntax::Preprocessor::Define(syntax::PreprocessorDefine {
+                               name: "test".into(),
+                               value: syntax::Expr::IntConst(1)
+                             })));
+  }
+
   #[test]
   fn parse_pp_extension_name() {
     assert_eq!(pp_extension_name(&b"all"[..]), IResult::Done(&b""[..], syntax::PreprocessorExtensionName::All));

src/syntax.rs

@@ -863,10 +863,19 @@ pub enum JumpStatement {
 /// > added in the future. Stay tuned.
 #[derive(Clone, Debug, PartialEq)]
 pub enum Preprocessor {
+  Define(PreprocessorDefine),
   Version(PreprocessorVersion),
   Extension(PreprocessorExtension)
 }
 
+/// A #define preprocessor command.
+/// Allows any expression but only Integer and Float literals make sense
+#[derive(Clone, Debug, PartialEq)]
+pub struct PreprocessorDefine {
+  pub name: Identifier,
+  pub value: Expr,
+}
+
 /// A #version preprocessor command.
 #[derive(Clone, Debug, PartialEq)]
 pub struct PreprocessorVersion {

src/transpiler/glsl.rs

@@ -817,11 +817,18 @@ pub fn show_jump_statement<F>(f: &mut F, j: &syntax::JumpStatement) where F: Wri
 
 pub fn show_preprocessor<F>(f: &mut F, pp: &syntax::Preprocessor) where F: Write {
   match *pp {
+    syntax::Preprocessor::Define(ref pd) => show_preprocessor_define(f, pd),
     syntax::Preprocessor::Version(ref pv) => show_preprocessor_version(f, pv),
     syntax::Preprocessor::Extension(ref pe) => show_preprocessor_extension(f, pe)
   }
 }
 
+pub fn show_preprocessor_define<F>(f: &mut F, pd: &syntax::PreprocessorDefine) where F: Write {
+  let _ = write!(f, "#define {} ", pd.name);
+  show_expr(f, &pd.value);
+  let _ = f.write_str("\n");
+}
+
 pub fn show_preprocessor_version<F>(f: &mut F, pv: &syntax::PreprocessorVersion) where F: Write {
   let _ = write!(f, "#version {}", pv.version);
 

src/visitor.rs

@@ -84,6 +84,10 @@ pub trait Visitor {
     Visit::Children
   }
 
+  fn visit_preprocessor_define(&mut self, _: &mut syntax::PreprocessorDefine) -> Visit {
+    Visit::Children
+  }
+
   fn visit_preprocessor_extension(&mut self, _: &mut syntax::PreprocessorExtension) -> Visit {
     Visit::Children
   }
@@ -306,13 +310,25 @@ impl Host for syntax::Preprocessor {
 
     if visit == Visit::Children {
       match *self {
+        syntax::Preprocessor::Define(ref mut pd) => pd.visit(visitor),
         syntax::Preprocessor::Version(ref mut pv) => pv.visit(visitor),
         syntax::Preprocessor::Extension(ref mut ext) => ext.visit(visitor)
       }
     }
   }
 }
 
+impl Host for syntax::PreprocessorDefine {
+  fn visit<V>(&mut self, visitor: &mut V) where V: Visitor {
+    let visit = visitor.visit_preprocessor_define(self);
+
+    if visit == Visit::Children {
+      self.name.visit(visitor);
+      self.value.visit(visitor);
+    }
+  }
+}
+
 impl Host for syntax::PreprocessorVersion {
   fn visit<V>(&mut self, visitor: &mut V) where V: Visitor {
     let visit = visitor.visit_preprocessor_version(self);