rlsl 0.1.1 → 1.0.0

data/lib/rlsl/prism/builtins.rb

@@ -1,195 +1,78 @@
 # frozen_string_literal: true
 
+require_relative "builtins/function_registry"
+require_relative "builtins/operator_rules"
+require_relative "builtins/swizzle_rules"
+
 module RLSL
   module Prism
     module Builtins
-      FUNCTIONS = {
-        vec2: { args: %i[any any], returns: :vec2, variadic: true, min_args: 1 },
-        vec3: { args: %i[any any any], returns: :vec3, variadic: true, min_args: 1 },
-        vec4: { args: %i[any any any any], returns: :vec4, variadic: true, min_args: 1 },
-
-        mat2: { args: %i[any any any any], returns: :mat2, variadic: true, min_args: 1 },
-        mat3: { args: %i[any any any any any any any any any], returns: :mat3, variadic: true, min_args: 1 },
-        mat4: { args: %i[any any any any any any any any any any any any any any any any], returns: :mat4, variadic: true, min_args: 1 },
-
-        sin: { args: [:float], returns: :float },
-        cos: { args: [:float], returns: :float },
-        tan: { args: [:float], returns: :float },
-        asin: { args: [:float], returns: :float },
-        acos: { args: [:float], returns: :float },
-        atan: { args: %i[float float], returns: :float, variadic: true, min_args: 1 },
-        atan2: { args: %i[float float], returns: :float },
-
-        pow: { args: %i[float float], returns: :float },
-        exp: { args: [:float], returns: :float },
-        log: { args: [:float], returns: :float },
-        sqrt: { args: [:any], returns: :same },
-
-        abs: { args: [:any], returns: :same },
-        sign: { args: [:any], returns: :same },
-        floor: { args: [:any], returns: :same },
-        ceil: { args: [:any], returns: :same },
-        fract: { args: [:any], returns: :same },
-        mod: { args: %i[any float], returns: :first },
-        min: { args: %i[any any], returns: :first },
-        max: { args: %i[any any], returns: :first },
-        clamp: { args: %i[any any any], returns: :first },
-        mix: { args: %i[any any float], returns: :first },
-        step: { args: %i[float any], returns: :second },
-        smoothstep: { args: %i[float float any], returns: :third },
-
-        length: { args: [:any], returns: :float },
-        distance: { args: %i[any any], returns: :float },
-        dot: { args: %i[any any], returns: :float },
-        cross: { args: %i[vec3 vec3], returns: :vec3 },
-        normalize: { args: [:any], returns: :same },
-        reflect: { args: %i[any any], returns: :first },
-        refract: { args: %i[any any float], returns: :first },
-
-        hash21: { args: [:vec2], returns: :float },
-        hash22: { args: [:vec2], returns: :vec2 },
-
-        lessThan: { args: %i[any any], returns: :bool },
-        lessThanEqual: { args: %i[any any], returns: :bool },
-        greaterThan: { args: %i[any any], returns: :bool },
-        greaterThanEqual: { args: %i[any any], returns: :bool },
-        equal: { args: %i[any any], returns: :bool },
-        notEqual: { args: %i[any any], returns: :bool },
-
-        inverse: { args: [:any], returns: :same },
-        transpose: { args: [:any], returns: :same },
-        determinant: { args: [:any], returns: :float },
-
-        texture2D: { args: %i[sampler2D vec2], returns: :vec4 },
-        texture: { args: %i[sampler2D vec2], returns: :vec4 },
-        textureLod: { args: %i[sampler2D vec2 float], returns: :vec4 }
-      }.freeze
-
-      BINARY_OPERATORS = {
-        "+" => :arithmetic,
-        "-" => :arithmetic,
-        "*" => :arithmetic,
-        "/" => :arithmetic,
-        "%" => :arithmetic,
-
-        "==" => :comparison,
-        "!=" => :comparison,
-        "<" => :comparison,
-        ">" => :comparison,
-        "<=" => :comparison,
-        ">=" => :comparison,
-
-        "&&" => :logical,
-        "||" => :logical
-      }.freeze
-
-      UNARY_OPERATORS = {
-        "-" => :negate,
-        "!" => :not
-      }.freeze
-
-      SWIZZLE_COMPONENTS = {
-        "x" => 0, "r" => 0, "s" => 0,
-        "y" => 1, "g" => 1, "t" => 1,
-        "z" => 2, "b" => 2, "p" => 2,
-        "w" => 3, "a" => 3, "q" => 3
-      }.freeze
-
-      SINGLE_COMPONENT_FIELDS = %w[x y z w r g b a s t p q].freeze
-
-      SWIZZLE_PATTERNS = /\A[xyzwrgba]{2,4}\z/
+      FUNCTIONS = FunctionRegistry::FUNCTIONS
+      BINARY_OPERATORS = OperatorRules::BINARY_OPERATORS
+      UNARY_OPERATORS = OperatorRules::UNARY_OPERATORS
+      SWIZZLE_COMPONENTS = SwizzleRules::SWIZZLE_COMPONENTS
+      SINGLE_COMPONENT_FIELDS = SwizzleRules::SINGLE_COMPONENT_FIELDS
+      SWIZZLE_PATTERNS = SwizzleRules::SWIZZLE_PATTERNS
 
       class << self
         def function?(name)
-          FUNCTIONS.key?(name.to_sym)
+          FunctionRegistry.function?(name)
         end
 
         def function_signature(name)
-          FUNCTIONS[name.to_sym]
+          FunctionRegistry.function_signature(name)
+        end
+
+        def supported_on_target?(name, target)
+          FunctionRegistry.supported_on_target?(name, target)
+        end
+
+        def explicit_types(name)
+          FunctionRegistry.explicit_types(name)
         end
 
         def binary_operator?(op)
-          BINARY_OPERATORS.key?(op.to_s)
+          OperatorRules.binary_operator?(op)
         end
 
         def unary_operator?(op)
-          UNARY_OPERATORS.key?(op.to_s)
+          OperatorRules.unary_operator?(op)
         end
 
         def single_component_field?(name)
-          SINGLE_COMPONENT_FIELDS.include?(name.to_s)
+          SwizzleRules.single_component_field?(name)
         end
 
         def swizzle?(name)
-          name.to_s.match?(SWIZZLE_PATTERNS)
+          SwizzleRules.swizzle?(name)
         end
 
         def swizzle_type(components)
-          case components.length
-          when 2 then :vec2
-          when 3 then :vec3
-          when 4 then :vec4
-          else :float
-          end
+          SwizzleRules.swizzle_type(components)
         end
 
         def resolve_return_type(rule, arg_types)
-          case rule
-          when :same then arg_types.first
-          when :first then arg_types.first
-          when :second then arg_types[1]
-          when :third then arg_types[2]
-          when Symbol then rule
-          end
+          FunctionRegistry.resolve_return_type(rule, arg_types)
         end
 
         def binary_op_result_type(op, left_type, right_type)
-          op_kind = BINARY_OPERATORS[op.to_s]
-
-          case op_kind
-          when :comparison, :logical
-            :bool
-          when :arithmetic
-            if matrix_type?(left_type) && vector_type?(right_type)
-              matrix_vector_result(left_type)
-            elsif vector_type?(left_type) && matrix_type?(right_type)
-              matrix_vector_result(right_type)
-            elsif matrix_type?(left_type) && matrix_type?(right_type)
-              left_type
-            elsif matrix_type?(left_type) && scalar_type?(right_type)
-              left_type
-            elsif scalar_type?(left_type) && matrix_type?(right_type)
-              right_type
-            elsif vector_type?(left_type) && vector_type?(right_type)
-              left_type
-            elsif vector_type?(left_type) && scalar_type?(right_type)
-              left_type
-            elsif scalar_type?(left_type) && vector_type?(right_type)
-              right_type
-            else
-              :float
-            end
-          end
+          OperatorRules.binary_op_result_type(op, left_type, right_type)
         end
 
         def vector_type?(type)
-          %i[vec2 vec3 vec4].include?(type)
+          OperatorRules.vector_type?(type)
         end
 
         def matrix_type?(type)
-          %i[mat2 mat3 mat4].include?(type)
+          OperatorRules.matrix_type?(type)
         end
 
         def scalar_type?(type)
-          %i[float int].include?(type)
+          OperatorRules.scalar_type?(type)
         end
 
         def matrix_vector_result(matrix_type)
-          case matrix_type
-          when :mat2 then :vec2
-          when :mat3 then :vec3
-          when :mat4 then :vec4
-          end
+          OperatorRules.matrix_vector_result(matrix_type)
         end
       end
     end

data/lib/rlsl/prism/compilation_unit.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module RLSL
+  module Prism
+    CompilationUnit = Struct.new(:source_unit, :ir, keyword_init: true)
+  end
+end

data/lib/rlsl/prism/emitters/base_emitter/control_flow_emission.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module RLSL
+  module Prism
+    module Emitters
+      class BaseEmitter
+        module ControlFlowEmission
+          def emit_tuple_return(node)
+            elements = node.elements.map { |elem| emit(elem) }.join(", ")
+            "#{indent}return (#{current_return_struct_name}){#{elements}};\n"
+          end
+
+          def emit_if_statement(node)
+            emit_conditional(node, needs_return: return_context?)
+          end
+
+          def emit_conditional(node, needs_return:)
+            condition = emit(node.condition)
+            then_code = emit_branch(node.then_branch, needs_return: needs_return)
+
+            return "#{indent}if (#{condition}) {\n#{then_code}#{indent}}#{needs_return ? "\n" : ""}" unless node.else_branch
+
+            if elsif_node?(node.else_branch)
+              elsif_code = emit_elsif(node.else_branch, needs_return: needs_return)
+              "#{indent}if (#{condition}) {\n#{then_code}#{indent}} #{elsif_code}#{needs_return ? "\n" : ""}"
+            else
+              else_code = emit_branch(node.else_branch, needs_return: needs_return)
+              "#{indent}if (#{condition}) {\n#{then_code}#{indent}} else {\n#{else_code}#{indent}}#{needs_return ? "\n" : ""}"
+            end
+          end
+
+          def emit_elsif(node, needs_return: false)
+            if_node = node.is_a?(IR::Block) ? node.statements.first : node
+            condition = emit(if_node.condition)
+            then_code = emit_branch(if_node.then_branch, needs_return: needs_return)
+
+            return "else if (#{condition}) {\n#{then_code}#{indent}}" unless if_node.else_branch
+
+            if elsif_node?(if_node.else_branch)
+              elsif_code = emit_elsif(if_node.else_branch, needs_return: needs_return)
+              "else if (#{condition}) {\n#{then_code}#{indent}} #{elsif_code}"
+            else
+              else_code = emit_branch(if_node.else_branch, needs_return: needs_return)
+              "else if (#{condition}) {\n#{then_code}#{indent}} else {\n#{else_code}#{indent}}"
+            end
+          end
+
+          def elsif_node?(node)
+            return true if node.is_a?(IR::IfStatement)
+            return false unless node.is_a?(IR::Block)
+
+            node.statements.length == 1 && node.statements.first.is_a?(IR::IfStatement)
+          end
+
+          def emit_return(node)
+            node.expression ? "return #{emit(node.expression)}" : "return"
+          end
+
+          def emit_for_loop(node)
+            var = node.variable
+            start_val = emit(node.range_start)
+            end_val = emit(node.range_end)
+            body = emit_indented_block(node.body)
+
+            "for (int #{var} = #{start_val}; #{var} < #{end_val}; #{var}++) {\n#{body}#{indent}}"
+          end
+
+          def emit_while_loop(node)
+            condition = emit(node.condition)
+            body = emit_indented_block(node.body)
+
+            "while (#{condition}) {\n#{body}#{indent}}"
+          end
+
+          def emit_break(_node)
+            "break"
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/rlsl/prism/emitters/base_emitter/definition_emission.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module RLSL
+  module Prism
+    module Emitters
+      class BaseEmitter
+        module DefinitionEmission
+          def emit_function_definition(node)
+            name = node.name
+            params = node.params.map do |param|
+              "#{type_name(node.param_types[param] || :float)} #{param}"
+            end.join(", ")
+
+            if node.return_type.is_a?(Array)
+              @current_return_struct_name = "#{name}_result"
+              struct_def = emit_result_struct(name, node.return_type)
+              body = emit_indented_block(node.body, needs_return: true)
+              @current_return_struct_name = nil
+              "#{struct_def}static inline #{name}_result #{name}(#{params}) {\n#{body}\n#{indent}}\n"
+            else
+              body = emit_indented_block(node.body, needs_return: true)
+              "static inline #{type_name(node.return_type || :float)} #{name}(#{params}) {\n#{body}\n#{indent}}\n"
+            end
+          end
+
+          def emit_result_struct(func_name, types)
+            fields = types.each_with_index.map { |type, index| "#{type_name(type)} v#{index};" }.join(" ")
+            "typedef struct { #{fields} } #{func_name}_result;\n"
+          end
+
+          def current_return_struct_name
+            @current_return_struct_name || "result"
+          end
+
+          def emit_array_literal(node, for_static_init: false)
+            elements = node.elements.map { |elem| emit_for_static_init(elem, for_static_init) }.join(", ")
+            "{#{elements}}"
+          end
+
+          def emit_for_static_init(node, for_static_init)
+            return emit(node) unless for_static_init
+
+            case node
+            when IR::FuncCall
+              if %i[vec2 vec3 vec4].include?(node.name)
+                args = node.args.map { |arg| emit_for_static_init(arg, true) }.join(", ")
+                "{#{args}}"
+              else
+                emit(node)
+              end
+            when IR::ArrayLiteral
+              emit_array_literal(node, for_static_init: true)
+            else
+              emit(node)
+            end
+          end
+
+          def emit_global_decl(node)
+            prefix = ""
+            prefix += "static " if node.is_static
+            prefix += "const " if node.is_const
+
+            if node.initializer.is_a?(IR::ArrayLiteral)
+              elem_type = type_name(node.element_type || :float)
+              size = node.array_size || node.initializer.elements.length
+              elements = emit_array_literal(node.initializer, for_static_init: true)
+              "#{prefix}#{elem_type} #{node.name}[#{size}] = #{elements}"
+            else
+              value = node.is_const ? emit_for_static_init(node.initializer, true) : emit(node.initializer)
+              "#{prefix}#{type_name(node.type || :float)} #{node.name} = #{value}"
+            end
+          end
+
+          def emit_multiple_assignment(node)
+            value_code = emit(node.value)
+
+            if node.value.is_a?(IR::FuncCall)
+              emit_multi_return_assignment(node, value_code)
+            else
+              emit_indexed_assignment(node, value_code)
+            end
+          end
+
+          private
+
+          def emit_multi_return_assignment(node, value_code)
+            func_name = node.value.name
+            lines = ["#{func_name}_result _tmp_#{func_name} = #{value_code}"]
+            node.targets.each_with_index do |target, index|
+              lines << "#{type_name(target.type || :float)} #{target.name} = _tmp_#{func_name}.v#{index}"
+            end
+            lines.join(";\n#{indent}")
+          end
+
+          def emit_indexed_assignment(node, value_code)
+            node.targets.each_with_index.map do |target, index|
+              "#{type_name(target.type || :float)} #{target.name} = #{value_code}[#{index}]"
+            end.join(";\n#{indent}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rlsl/prism/emitters/base_emitter/expression_emission.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module RLSL
+  module Prism
+    module Emitters
+      class BaseEmitter
+        module ExpressionEmission
+          def emit_var_decl(node)
+            type = type_name(node.type || :float)
+            value = emit(node.initializer)
+            "#{type} #{node.name} = #{value}"
+          end
+
+          def emit_var_ref(node)
+            node.name.to_s
+          end
+
+          def emit_literal(node)
+            format_number(node.value)
+          end
+
+          def emit_bool_literal(node)
+            node.value.to_s
+          end
+
+          def emit_binary_op(node)
+            left = emit_with_precedence(node.left, node.operator)
+            right = emit_with_precedence(node.right, node.operator)
+            "#{left} #{node.operator} #{right}"
+          end
+
+          def emit_unary_op(node)
+            "#{node.operator}#{emit(node.operand)}"
+          end
+
+          def emit_func_call(node)
+            func_name = function_name(node.name)
+            args = node.args.map { |arg| emit(arg) }.join(", ")
+
+            if node.receiver
+              receiver = emit(node.receiver)
+              "#{func_name}(#{receiver}, #{args})"
+            else
+              "#{func_name}(#{args})"
+            end
+          end
+
+          def emit_field_access(node)
+            "#{emit(node.receiver)}.#{node.field}"
+          end
+
+          def emit_swizzle(node)
+            "#{emit(node.receiver)}.#{node.components}"
+          end
+
+          def emit_ternary(node)
+            "(#{emit(node.condition)} ? #{emit(node.then_expr)} : #{emit(node.else_expr)})"
+          end
+
+          def emit_assignment(node)
+            "#{emit(node.target)} = #{emit(node.value)}"
+          end
+
+          def emit_constant(node)
+            case node.name
+            when :PI
+              "3.14159265358979323846"
+            when :TAU
+              "6.28318530717958647692"
+            else
+              node.name.to_s
+            end
+          end
+
+          def emit_parenthesized(node)
+            "(#{emit(node.expression)})"
+          end
+
+          def emit_array_index(node)
+            array = emit(node.array)
+            index = if node.index.is_a?(IR::Literal) && node.index.value.to_i == node.index.value
+                      node.index.value.to_i.to_s
+                    else
+                      emit(node.index)
+                    end
+            "#{array}[#{index}]"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rlsl/prism/emitters/base_emitter/statement_emission.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module RLSL
+  module Prism
+    module Emitters
+      class BaseEmitter
+        module StatementEmission
+          def emit_block(node, needs_return = nil)
+            statements = node.statements
+            return "" if statements.empty?
+
+            emit_statements(statements, returning: needs_return.nil? ? return_context? : needs_return)
+          end
+
+          def emit_statements(statements, returning:)
+            return statements.map { |statement| emit_statement(statement) }.join unless returning
+
+            leading = statements[0...-1].map { |statement| emit_statement(statement) }.join
+            leading + emit_terminal_statement(statements.last)
+          end
+
+          def emit_statement(node, needs_return: false)
+            return emit_terminal_statement(node) if needs_return
+
+            "#{indent}#{emit(node)}#{statement_terminator(node)}"
+          end
+
+          def emit_terminal_statement(node)
+            return emit(node, needs_return: true) if node.is_a?(IR::IfStatement)
+            return emit_statement(node) if terminal_passthrough_node?(node)
+            return emit_tuple_return(node) if node.is_a?(IR::ArrayLiteral)
+
+            "#{indent}return #{emit(node)};\n"
+          end
+
+          def emit_branch(node, needs_return:)
+            with_indent do
+              if node.is_a?(IR::Block)
+                emit(node, needs_return: needs_return)
+              else
+                emit_statement(node, needs_return: needs_return)
+              end
+            end
+          end
+
+          def emit_indented_block(node, needs_return: false)
+            with_indent do
+              if node.is_a?(IR::Block)
+                emit(node, needs_return: needs_return)
+              else
+                emit_statement(node, needs_return: needs_return)
+              end
+            end
+          end
+
+          private
+
+          def statement_terminator(node)
+            multiline_node?(node) ? "\n" : ";\n"
+          end
+
+          def multiline_node?(node)
+            MULTILINE_NODES.any? { |klass| node.is_a?(klass) }
+          end
+
+          def terminal_passthrough_node?(node)
+            [
+              IR::Return,
+              IR::VarDecl,
+              IR::Assignment,
+              IR::ForLoop,
+              IR::WhileLoop,
+              IR::FunctionDefinition,
+              IR::GlobalDecl,
+              IR::MultipleAssignment
+            ].any? { |klass| node.is_a?(klass) }
+          end
+
+          def with_indent
+            @indent_level += 1
+            yield
+          ensure
+            @indent_level -= 1
+          end
+        end
+      end
+    end
+  end
+end