rlsl 0.1.0

data/lib/rlsl/prism/ir/nodes.rb

@@ -0,0 +1,373 @@
+# frozen_string_literal: true
+
+module RLSL
+  module Prism
+    module IR
+      class Node
+        attr_accessor :type
+
+        def accept(visitor)
+          raise NotImplementedError
+        end
+      end
+
+      class Block < Node
+        attr_reader :statements
+
+        def initialize(statements = [])
+          super()
+          @statements = statements
+        end
+
+        def accept(visitor)
+          visitor.visit_block(self)
+        end
+      end
+
+      class VarDecl < Node
+        attr_reader :name, :initializer
+
+        def initialize(name, initializer, type = nil)
+          super()
+          @name = name
+          @initializer = initializer
+          @type = type
+        end
+
+        def accept(visitor)
+          visitor.visit_var_decl(self)
+        end
+      end
+
+      class VarRef < Node
+        attr_reader :name
+
+        def initialize(name, type = nil)
+          super()
+          @name = name
+          @type = type
+        end
+
+        def accept(visitor)
+          visitor.visit_var_ref(self)
+        end
+      end
+
+      class Literal < Node
+        attr_reader :value
+
+        def initialize(value, type = nil)
+          super()
+          @value = value
+          @type = type || (value.is_a?(Float) ? :float : :int)
+        end
+
+        def accept(visitor)
+          visitor.visit_literal(self)
+        end
+      end
+
+      class BoolLiteral < Node
+        attr_reader :value
+
+        def initialize(value)
+          super()
+          @value = value
+          @type = :bool
+        end
+
+        def accept(visitor)
+          visitor.visit_bool_literal(self)
+        end
+      end
+
+      class BinaryOp < Node
+        attr_reader :operator, :left, :right
+
+        def initialize(operator, left, right, type = nil)
+          super()
+          @operator = operator
+          @left = left
+          @right = right
+          @type = type
+        end
+
+        def accept(visitor)
+          visitor.visit_binary_op(self)
+        end
+      end
+
+      class UnaryOp < Node
+        attr_reader :operator, :operand
+
+        def initialize(operator, operand, type = nil)
+          super()
+          @operator = operator
+          @operand = operand
+          @type = type
+        end
+
+        def accept(visitor)
+          visitor.visit_unary_op(self)
+        end
+      end
+
+      class FuncCall < Node
+        attr_reader :name, :args, :receiver
+
+        def initialize(name, args = [], receiver = nil, type = nil)
+          super()
+          @name = name
+          @args = args
+          @receiver = receiver
+          @type = type
+        end
+
+        def accept(visitor)
+          visitor.visit_func_call(self)
+        end
+      end
+
+      class FieldAccess < Node
+        attr_reader :receiver, :field
+
+        def initialize(receiver, field, type = nil)
+          super()
+          @receiver = receiver
+          @field = field
+          @type = type
+        end
+
+        def accept(visitor)
+          visitor.visit_field_access(self)
+        end
+      end
+
+      class Swizzle < Node
+        attr_reader :receiver, :components
+
+        def initialize(receiver, components, type = nil)
+          super()
+          @receiver = receiver
+          @components = components
+          @type = type
+        end
+
+        def accept(visitor)
+          visitor.visit_swizzle(self)
+        end
+      end
+
+      class IfStatement < Node
+        attr_reader :condition, :then_branch, :else_branch
+
+        def initialize(condition, then_branch, else_branch = nil, type = nil)
+          super()
+          @condition = condition
+          @then_branch = then_branch
+          @else_branch = else_branch
+          @type = type
+        end
+
+        def accept(visitor)
+          visitor.visit_if_statement(self)
+        end
+      end
+
+      class Return < Node
+        attr_reader :expression
+
+        def initialize(expression)
+          super()
+          @expression = expression
+          @type = expression&.type
+        end
+
+        def accept(visitor)
+          visitor.visit_return(self)
+        end
+      end
+
+      class Assignment < Node
+        attr_reader :target, :value
+
+        def initialize(target, value)
+          super()
+          @target = target
+          @value = value
+          @type = value&.type
+        end
+
+        def accept(visitor)
+          visitor.visit_assignment(self)
+        end
+      end
+
+      class ForLoop < Node
+        attr_reader :variable, :range_start, :range_end, :body
+
+        def initialize(variable, range_start, range_end, body)
+          super()
+          @variable = variable
+          @range_start = range_start
+          @range_end = range_end
+          @body = body
+          @type = nil
+        end
+
+        def accept(visitor)
+          visitor.visit_for_loop(self)
+        end
+      end
+
+      class WhileLoop < Node
+        attr_reader :condition, :body
+
+        def initialize(condition, body)
+          super()
+          @condition = condition
+          @body = body
+          @type = nil
+        end
+
+        def accept(visitor)
+          visitor.visit_while_loop(self)
+        end
+      end
+
+      class Break < Node
+        def initialize
+          super()
+          @type = nil
+        end
+
+        def accept(visitor)
+          visitor.visit_break(self)
+        end
+      end
+
+      class Constant < Node
+        attr_reader :name
+
+        def initialize(name, type = :float)
+          super()
+          @name = name
+          @type = type
+        end
+
+        def accept(visitor)
+          visitor.visit_constant(self)
+        end
+      end
+
+      class Parenthesized < Node
+        attr_reader :expression
+
+        def initialize(expression)
+          super()
+          @expression = expression
+          @type = expression&.type
+        end
+
+        def accept(visitor)
+          visitor.visit_parenthesized(self)
+        end
+      end
+
+      class ArrayLiteral < Node
+        attr_reader :elements
+
+        def initialize(elements, type = nil)
+          super()
+          @elements = elements
+          @type = type
+        end
+
+        def accept(visitor)
+          visitor.visit_array_literal(self)
+        end
+      end
+
+      class ArrayIndex < Node
+        attr_reader :array, :index
+
+        def initialize(array, index, type = nil)
+          super()
+          @array = array
+          @index = index
+          @type = type
+        end
+
+        def accept(visitor)
+          visitor.visit_array_index(self)
+        end
+      end
+
+      class GlobalDecl < Node
+        attr_reader :name, :initializer
+        attr_accessor :is_const, :is_static, :array_size, :element_type
+
+        def initialize(name, initializer, type: nil, is_const: false, is_static: true, array_size: nil, element_type: nil)
+          super()
+          @name = name
+          @initializer = initializer
+          @type = type
+          @is_const = is_const
+          @is_static = is_static
+          @array_size = array_size
+          @element_type = element_type
+        end
+
+        def accept(visitor)
+          visitor.visit_global_decl(self)
+        end
+      end
+
+      class FunctionDefinition < Node
+        attr_reader :name, :params, :body
+        attr_accessor :return_type, :param_types
+
+        def initialize(name, params, body, return_type: nil, param_types: {})
+          super()
+          @name = name
+          @params = params
+          @body = body
+          @return_type = return_type
+          @param_types = param_types
+          @type = return_type
+        end
+
+        def accept(visitor)
+          visitor.visit_function_definition(self)
+        end
+      end
+
+      class MultipleAssignment < Node
+        attr_reader :targets, :value
+
+        def initialize(targets, value)
+          super()
+          @targets = targets
+          @value = value
+          @type = nil
+        end
+
+        def accept(visitor)
+          visitor.visit_multiple_assignment(self)
+        end
+      end
+
+      class TupleType
+        attr_reader :types
+
+        def initialize(*types)
+          @types = types
+        end
+
+        def to_sym
+          :"tuple_#{types.map(&:to_s).join('_')}"
+        end
+      end
+    end
+  end
+end

data/lib/rlsl/prism/source_extractor.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module RLSL
+  module Prism
+    class SourceExtractor
+      class SourceNotAvailable < StandardError; end
+
+      def extract(block)
+        file, line_num = block.source_location
+        raise SourceNotAvailable, "Block source location not available" unless file && File.exist?(file)
+
+        lines = File.readlines(file)
+        extract_block_source(lines, line_num - 1)
+      end
+
+      def extract_from_string(source)
+        source
+      end
+
+      private
+
+      def extract_block_source(lines, start_line)
+        source = +""
+        depth = 0
+        in_block = false
+        block_start_found = false
+
+        lines[start_line..].each_with_index do |line, idx|
+          tokens = tokenize_for_blocks(line)
+
+          tokens.each do |token|
+            case token
+            when :do, :brace_open
+              if !block_start_found
+                block_start_found = true
+                in_block = true
+              end
+              depth += 1
+            when :block_start
+              depth += 1
+            when :end, :brace_close
+              depth -= 1
+            end
+          end
+
+          if block_start_found
+            if idx == 0
+              source << extract_first_line(line)
+            else
+              source << line
+            end
+          end
+
+          break if in_block && depth == 0
+        end
+
+        clean_block_source(source)
+      end
+
+      def tokenize_for_blocks(line)
+        tokens = []
+        in_string = nil
+        i = 0
+
+        while i < line.length
+          char = line[i]
+
+          if in_string
+            if char == in_string && (i == 0 || line[i - 1] != "\\")
+              in_string = nil
+            end
+            i += 1
+            next
+          end
+
+          if char == '"' || char == "'"
+            in_string = char
+            i += 1
+            next
+          end
+
+          break if char == "#"
+
+          prev_is_boundary = i == 0 || !line[i - 1].match?(/[a-zA-Z0-9_]/)
+
+          if char == "{"
+            tokens << :brace_open
+          elsif char == "}"
+            tokens << :brace_close
+          elsif prev_is_boundary && line[i..].match?(/\Ado\b/)
+            tokens << :do
+            i += 1
+          elsif prev_is_boundary && line[i..].match?(/\Aelsif\b/)
+            i += 4
+          elsif prev_is_boundary && line[i..].match?(/\Aelse\b/)
+            i += 3
+          elsif prev_is_boundary && (m = line[i..].match(/\A(if|unless|while|for|case|def|class|module)\b/))
+            tokens << :block_start
+            i += m[1].length - 1
+          elsif prev_is_boundary && line[i..].match?(/\Aend\b/)
+            tokens << :end
+            i += 2
+          end
+
+          i += 1
+        end
+
+        tokens
+      end
+
+      def extract_first_line(line)
+        if line.include?(" do")
+          match = line.match(/do\s*(\|[^|]*\|)?\s*(.*)$/)
+          if match
+            params = match[1] || ""
+            rest = match[2] || ""
+            "#{params}\n#{rest}\n"
+          else
+            "\n"
+          end
+        elsif line.include?("{")
+          match = line.match(/\{\s*(\|[^|]*\|)?\s*(.*)$/)
+          if match
+            params = match[1] || ""
+            rest = match[2] || ""
+            "#{params}\n#{rest}\n"
+          else
+            "\n"
+          end
+        else
+          line
+        end
+      end
+
+      def clean_block_source(source)
+        lines = source.lines
+        return "" if lines.empty?
+
+        last_line = lines.last.strip
+        if last_line == "end" || last_line == "}"
+          lines.pop
+        elsif last_line.end_with?("end") || last_line.end_with?("}")
+          lines[-1] = lines[-1].sub(/\s*(end|\})\s*$/, "\n")
+        end
+
+        lines.shift if lines.first&.strip&.empty?
+
+        lines.join
+      end
+    end
+  end
+end

data/lib/rlsl/prism/transpiler.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "ir/nodes"
+require_relative "source_extractor"
+require_relative "builtins"
+require_relative "ast_visitor"
+require_relative "type_inference"
+require_relative "emitters/base_emitter"
+require_relative "emitters/c_emitter"
+require_relative "emitters/msl_emitter"
+require_relative "emitters/wgsl_emitter"
+require_relative "emitters/glsl_emitter"
+
+module RLSL
+  module Prism
+    class Transpiler
+      TARGETS = {
+        c: Emitters::CEmitter,
+        msl: Emitters::MSLEmitter,
+        wgsl: Emitters::WGSLEmitter,
+        glsl: Emitters::GLSLEmitter
+      }.freeze
+
+      attr_reader :ir, :uniforms, :custom_functions
+
+      def initialize(uniforms = {}, custom_functions = {})
+        @uniforms = uniforms
+        @custom_functions = custom_functions
+        @source_extractor = SourceExtractor.new
+        @ir = nil
+      end
+
+      def parse_block(block)
+        source = @source_extractor.extract(block)
+        parse_source(source)
+      end
+
+      def parse_source(source)
+        params, body = extract_block_body(source)
+
+        visitor = ASTVisitor.new(uniforms: @uniforms, params: params)
+        @ir = visitor.parse(body)
+
+        inference = TypeInference.new(@uniforms, @custom_functions)
+        inference.register(:frag_coord, :vec2)
+        inference.register(:resolution, :vec2)
+        inference.infer(@ir)
+
+        @ir
+      end
+
+      def emit(target, needs_return: true)
+        raise "No IR parsed yet. Call parse_block or parse_source first." unless @ir
+
+        emitter_class = TARGETS[target.to_sym]
+        raise "Unknown target: #{target}" unless emitter_class
+
+        emitter = emitter_class.new
+        emitter.emit(@ir, needs_return: needs_return)
+      end
+
+      def transpile(block, target)
+        parse_block(block)
+        emit(target)
+      end
+
+      def transpile_source(source, target)
+        parse_source(source)
+        emit(target)
+      end
+
+      def transpile_helpers(block, target, function_signatures = {})
+        source = @source_extractor.extract(block)
+        _, body = extract_block_body(source)
+
+        visitor = ASTVisitor.new(uniforms: @uniforms)
+        @ir = visitor.parse(body)
+
+        apply_function_signatures(@ir, function_signatures)
+
+        inference = TypeInference.new(@uniforms, @custom_functions)
+        inference.infer(@ir)
+
+        emit(target, needs_return: false)
+      end
+
+      private
+
+      def apply_function_signatures(ir, signatures)
+        return unless ir.is_a?(IR::Block)
+
+        ir.statements.each do |stmt|
+          next unless stmt.is_a?(IR::FunctionDefinition)
+
+          sig = signatures[stmt.name]
+          next unless sig
+
+          stmt.return_type = sig[:returns]
+          stmt.param_types = sig[:params] || {}
+        end
+      end
+
+      def extract_block_body(source)
+        lines = source.strip.lines
+        params = []
+
+        first_line = lines.first&.strip || ""
+
+        if first_line.start_with?("|")
+          param_end = first_line.index("|", 1)
+          if param_end
+            param_str = first_line[1...param_end]
+            params = param_str.split(",").map { |p| p.strip.to_sym }
+            lines[0] = first_line[(param_end + 1)..]
+          end
+        end
+
+        lines.shift while lines.first&.strip&.empty?
+        lines.pop while lines.last&.strip&.empty?
+
+        body = lines.join.strip
+        [params, body]
+      end
+    end
+  end
+end