implement #define parsing

Author: JDemler

Diff for: 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,32 @@ 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".to_string(),
+                                     value: syntax::Expr::DoubleConst(1.0)
+                                 })));
+
+        assert_eq!(preprocessor(&b"#define test123 .0\n"[..]),
+                   IResult::Done(&b""[..],
+                                 syntax::Preprocessor::Define(syntax::PreprocessorDefine {
+                                     name: "test123".to_string(),
+                                     value: syntax::Expr::DoubleConst(0.0)
+                                 })));
+
+        assert_eq!(preprocessor(&b"#define test 1\n"[..]),
+                   IResult::Done(&b""[..],
+                                 syntax::Preprocessor::Define(syntax::PreprocessorDefine {
+                                     name: "test".to_string(),
+                                     value: syntax::Expr::IntConst(1)
+                                 })));
+    }
+
+
   #[test]
   fn parse_pp_extension_name() {
     assert_eq!(pp_extension_name(&b"all"[..]), IResult::Done(&b""[..], syntax::PreprocessorExtensionName::All));

Diff for: 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 {

Diff for: 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);