rlsl 0.1.1 → 1.0.1

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

@@ -0,0 +1,108 @@
+# 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)
+            return "#{type} #{node.name}" unless node.initializer
+
+            if node.initializer.is_a?(IR::ArrayLiteral)
+              value = emit(node.initializer)
+              element_type = type_name(TypeShapes.element_type(node.type) || :float)
+              return "#{element_type} #{node.name}[#{node.initializer.elements.length}] = #{value}"
+            end
+
+            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, type: node.type)
+          end
+
+          def emit_bool_literal(node)
+            node.value.to_s
+          end
+
+          def emit_binary_op(node)
+            left = emit_with_precedence(node.left, node.operator, side: :left)
+            right = emit_with_precedence(node.right, node.operator, side: :right)
+            "#{left} #{node.operator} #{right}"
+          end
+
+          def emit_unary_op(node)
+            operand = emit(node.operand)
+            operand = "(#{operand})" if node.operand.is_a?(IR::BinaryOp) ||
+                                        node.operand.is_a?(IR::Ternary) ||
+                                        node.operand.is_a?(IR::UnaryOp)
+            "#{node.operator}#{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
+
+          def emit_typed_argument(node, _expected_type)
+            emit(node)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,95 @@
+# 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)
+            if node.is_a?(IR::VarDecl)
+              return "#{emit_statement(node)}#{indent}return #{node.name};\n"
+            end
+            if node.is_a?(IR::Assignment)
+              return "#{emit_statement(node)}#{indent}return #{emit(node.target)};\n"
+            end
+            return emit_statement(node) if terminal_passthrough_node?(node)
+            return emit_tuple_return(node) if node.is_a?(IR::ArrayLiteral)
+
+            "#{indent}return #{emit_return_expression(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