#194 define Preprocessor

crosstl/backend/DirectX/DirectxCrossGLCodeGen.py

@@ -61,6 +61,24 @@ def __init__(self):
             "SV_DEPTH7": "gl_FragDepth7",
         }
 
+    def convert(self, ast):
+
+        # Converts the provided AST to target GLSL code.
+
+        code = []
+        for node in ast.nodes:
+            if isinstance(node, IncludeNode):
+                code.append(self.handle_include_node(node))
+            # Handle other nodes with existing logic
+            else:
+                code.append(self.generate_function(node))
+        return "\n".join(code)
+
+    def handle_include_node(self, node):
+
+        # Handles `IncludeNode` specific conversion.
+        return f"// Included file: {node.path}"
+
     def generate(self, ast):
         code = "shader main {\n"
         # Generate structs

crosstl/backend/DirectX/DirectxLexer.py

@@ -1,5 +1,6 @@
 import re
 from typing import Iterator, Tuple, List
+from .DirectxPreprocessor import DirectxPreprocessor
 
 # using sets for faster lookup
 SKIP_TOKENS = {"WHITESPACE", "COMMENT_SINGLE", "COMMENT_MULTI"}
@@ -111,9 +112,12 @@
 
 class HLSLLexer:
     def __init__(self, code: str):
+        # Integrating the preprocessor
+        preprocessor = DirectxPreprocessor()
+        self.code = preprocessor.preprocess(code)
+
         self._token_patterns = [(name, re.compile(pattern)) for name, pattern in TOKENS]
-        self.code = code
-        self._length = len(code)
+        self._length = len(self.code)
 
     def tokenize(self) -> List[Tuple[str, str]]:
         # tokenize the input code and return list of tokens

crosstl/backend/DirectX/DirectxPreprocessor.py

@@ -0,0 +1,72 @@
+import os
+
+
+class DirectxPreprocessor:
+    def __init__(self):
+        self.macros = {}
+        self.condition_stack = []
+
+    def preprocess(self, code):
+        # Preprocess the input HLSL shader code.
+        lines = code.splitlines()
+        processed_lines = []
+        skip_lines = False
+
+        for line in lines:
+            stripped_line = line.strip()
+
+            if stripped_line.startswith("#include"):
+                processed_lines.append(self.handle_include(stripped_line))
+            elif stripped_line.startswith("#define"):
+                self.handle_define(stripped_line)
+            elif stripped_line.startswith("#ifdef"):
+                skip_lines = not self.handle_ifdef(stripped_line)
+            elif stripped_line.startswith("#endif"):
+                skip_lines = self.handle_endif()
+            elif stripped_line.startswith("#else"):
+                skip_lines = not skip_lines
+            elif not skip_lines:
+                processed_lines.append(self.expand_macros(line))
+
+        return "\n".join(processed_lines)
+
+    def handle_include(self, line):
+        # Handle #include directive.
+        file_path = line.split()[1].strip('"<>"')
+        if not os.path.exists(file_path):
+            raise FileNotFoundError(f"Included file '{file_path}' not found.")
+        with open(file_path, "r") as file:
+            return file.read()
+
+    def handle_define(self, line):
+        # Handle #define directive.
+        parts = line.split(maxsplit=2)
+        if len(parts) == 3:
+            self.macros[parts[1]] = parts[2]
+        else:
+            self.macros[parts[1]] = ""
+
+    def handle_ifdef(self, line):
+        # Handle #ifdef directive.
+        macro = line.split(maxsplit=1)[1]
+        is_defined = macro in self.macros
+        self.condition_stack.append(is_defined)
+        return is_defined
+
+    def handle_endif(self):
+        # Handle #endif directive.
+        if not self.condition_stack:
+            raise SyntaxError("#endif without matching #ifdef")
+        self.condition_stack.pop()
+        return False if self.condition_stack and not self.condition_stack[-1] else True
+
+    def expand_macros(self, line):
+        # Expand defined macros in the line.
+        for macro, value in self.macros.items():
+            line = line.replace(macro, value)
+
+        # Check for undefined macros.
+        if any(macro not in self.macros for macro in line.split()):
+            raise ValueError(f"Undefined macro encountered in line: {line}")
+
+        return line

crosstl/backend/DirectX/__init__.py

@@ -1,3 +1,12 @@
 from .DirectxLexer import HLSLLexer
 from .DirectxParser import HLSLParser
 from .DirectxCrossGLCodeGen import HLSLToCrossGLConverter
+
+
+def process_shader(shader_code):
+    lexer = HLSLLexer(shader_code)
+    tokens = lexer.tokenize()
+    parser = HLSLParser(tokens)
+    ast = parser.parse()
+    converter = HLSLToCrossGLConverter()
+    return converter.convert(ast)

tests/test_backend/test_directx/test_preprocessor.py

@@ -0,0 +1,112 @@
+import unittest
+from crosstl.backend.DirectX.DirectxPreprocessor import DirectxPreprocessor
+
+
+class TestDirectxPreprocessor(unittest.TestCase):
+
+    def test_preprocessor_with_defines_and_ifdef(self):
+        shader_code = """
+        #define PI 3.14159
+        #define DEBUG 1
+
+        #ifdef DEBUG
+            float debugValue = 1.0;
+        #else
+            float debugValue = 0.0;
+        #endif
+
+        float computeCircleArea(float radius) {
+            return PI * radius * radius;
+        }
+        """
+
+        expected_output = """
+            float debugValue = 1.0;
+
+            float computeCircleArea(float radius) {
+                return 3.14159 * radius * radius;
+            }
+        """
+
+        preprocessor = DirectxPreprocessor()
+        result = preprocessor.preprocess(shader_code)
+
+        # Clean up the result by stripping leading/trailing whitespace for easier comparison
+        result = result.strip()
+        expected_output = expected_output.strip()
+
+        self.assertEqual(result, expected_output)
+
+    def test_preprocessor_with_no_debug(self):
+        shader_code = """
+        #define PI 3.14159
+        #undef DEBUG
+
+        #ifdef DEBUG
+            float debugValue = 1.0;
+        #else
+            float debugValue = 0.0;
+        #endif
+
+        float computeCircleArea(float radius) {
+            return PI * radius * radius;
+        }
+        """
+
+        expected_output = """
+            float debugValue = 0.0;
+
+            float computeCircleArea(float radius) {
+                return 3.14159 * radius * radius;
+            }
+        """
+
+        preprocessor = DirectxPreprocessor()
+        result = preprocessor.preprocess(shader_code)
+
+        result = result.strip()
+        expected_output = expected_output.strip()
+
+        self.assertEqual(result, expected_output)
+
+    def test_preprocessor_without_include(self):
+        shader_code = """
+        #define PI 3.14159
+
+        float computeCircleArea(float radius) {
+            return PI * radius * radius;
+        }
+        """
+
+        expected_output = """
+            float computeCircleArea(float radius) {
+                return 3.14159 * radius * radius;
+            }
+        """
+
+        preprocessor = DirectxPreprocessor()
+        result = preprocessor.preprocess(shader_code)
+
+        result = result.strip()
+        expected_output = expected_output.strip()
+
+        self.assertEqual(result, expected_output)
+
+    def test_preprocessor_with_invalid_include(self):
+        shader_code = """
+        #include "common.h"
+        #define PI 3.14159
+
+        float computeCircleArea(float radius) {
+            return PI * radius * radius;
+        }
+        """
+
+        preprocessor = DirectxPreprocessor()
+
+        with self.assertRaises(FileNotFoundError):
+            preprocessor.preprocess(shader_code)
+
+
+if __name__ == "__main__":
+    unittest.main()