ruby2basic 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b030c504db662d7f49036a6041dee51f0d13aa2404217dc559f2e00aa5c4e580
-  data.tar.gz: d68f421809b736f303eb80f478991f8754bca61b6494c5d7d726d9b36c1ded3e
+  metadata.gz: 8036de50cb43b2151d011b88570f88351dd0b23fd2d939a799896d35ef23cf03
+  data.tar.gz: 34ce4e930b6c931387e1c48f7a27a871bf20f1d7063e228ff93085c969bb7f10
 SHA512:
-  metadata.gz: 58376b89c2ad1dcef8612629933ec57755fc8c6403731e62758907cde5b84ce55e113697ccb9efaba51ab860c7a9e2a2463142ca6648d7dfa8afe0313b3f164c
-  data.tar.gz: 0b237718755c33c28366d744c13b04e9e38a6fee1205fcd7d7e0cc97b2f9dc0e2a07576fdf4a492cd3a66aec7f39b75cd3ef1b9a4b006d8de886c1e238a738d7
+  metadata.gz: 278917f446cfeb862b08a6673bb9c3540f8b56365b2afec893c66213a81769007402d2a67b79da4c5be07eb95fc24d2ac84a856d27339651ab4ca4e9d45a45eb
+  data.tar.gz: 7ac28e6042fb3a5e480cb753203ff2a5f5850cf08fb44a4953cd50a52e418134952dd8ed0fcb242ad18cd4fc137f710f9892d507c2b8cb7d2a1f79e922aac99e

data/README.md

@@ -12,6 +12,7 @@ Este es un proyecto que hago sólo por diversión para generar programas BASIC p
 ## Instalación
 
 * Instalar Ruby.
+* Se requiren los siguientes paquetes: `gcc`, `make` y `ruby-dev` para compilar el parser.
 * Instalar la gema `gem install ruby2basic`
 
 ## Usage
@@ -42,13 +43,49 @@ $ ./ruby2basic examples/03-bucle.rb
 
 > Más [ejemplos](./examples/)
 
+También se puede invocar a modo de biblioteca. 
+
+```ruby
+require "ruby2basic"
+
+source = <<-CODE
+  puts "Hello, World!"
+CODE
+
+r2b = Ruby2Basic::ZXSpectrum::Transpiler.new
+puts r2b.call(source)
+
+#=> 10 PRINT "Hello, World!"
+#=> 20 STOP
+```
+
 ## Features
 
-* Lee la estructura secuencial.
-* Los comentarios a `REM`.
-* Definir variables `String` e `Integer`.
-* Método `puts` a `PRINT`. Se aceptan los String embebidos.
+Ruby:
+
+* Lińeas de comentarios.
+* Estructura secuencial.
+* Variables con tipo `String` e `Integer`.
+* Método `puts`. Se aceptan los String embebidos.
+* Estructura repetitiva.
 * Método `times` a `FOR`.
+* Estructura condicional.
+
+BASIC ZX Spectrum:
+
+* REM: Líneas de comentarios.
+* LET: Asigna valores a variables.
+* PRINT: Muestra texto o números en pantalla.
+* STOP: Detiene la ejecución (vital para separar el cuerpo principal de las subrutinas).
+
+* FOR: Inicia un bucle con una variable de control.
+* TO: Define el límite superior del bucle FOR.
+* NEXT: Cierra el bucle FOR.
+* IF: Evalúa una condición lógica.
+* THEN: Indica la acción a seguir si el IF es verdadero.
+* GOTO: Salto incondicional a una línea específica.
+
+* STR$: Convierte un número en una cadena de texto.
 
 ## Contributing
 

data/docs/1-pcbasic.md

@@ -67,3 +67,48 @@ Ejemplo:
 ```
 
 > **NOTA**: Para acceder a los archivos del sistema Linux, ejecutar como: `pcbasic --mount=C:/home/username/mis_programas`
+
+---
+# TODO
+
+3. Ejemplo comparativo
+
+Estilo "Retro" (Gritando):
+Fragmento de código
+
+10 BORDER 1: PAPER 7: INK 0: CLS
+20 LET X = 10
+30 PRINT AT 10, X; "HOLA"
+
+
+Notarás que la mayor diferencia es cómo manejamos la recursividad, ya que el BASIC antiguo no la soportaba de forma nativa.
+1. Hola Mundo
+En PC-BASIC (Estilo GW-BASIC)
+Basic
+
+10 CLS
+20 PRINT "HOLA MUNDO DESDE PC-BASIC"
+30 END
+
+
+2. Factorial Iterativo (Bucle FOR)
+En PC-BASIC
+
+Aquí usamos una variable global F para el resultado y N para el número.
+Basic
+
+10 CLS
+20 INPUT "Introduce un numero: ", N
+30 F = 1
+40 FOR I = 1 TO N
+50 F = F * I
+60 NEXT I
+70 PRINT "El factorial es:"; F
+80 END
+
+Aquí es donde está el gran cambio tecnológico.
+En PC-BASIC (Simulación con GOSUB)
+
+PC-BASIC no permite que una función se llame a sí misma. Para simularlo, los programadores antiguos usaban una "pila" manual o, más comúnmente, simplemente no lo hacían porque el GOSUB no crea variables nuevas cada vez.
+
+    Nota: En PC-BASIC es mejor quedarse con la versión iterativa. Intentar hacer recursividad real requiere trucos muy complejos con POKE y PEEK.

data/docs/2-freebasic.md

@@ -147,3 +147,49 @@ Next
 ErrorFatal:
 Print "Algo salio muy mal. Cerrando..."
 ```
+
+# TODO
+
+En FreeBASIC
+
+Usamos una función limpia y tipos de datos protegidos para evitar que el número se "desborde".
+Fragmento de código
+
+Function FactorialIter(n As Integer) As ULongInt
+    Dim res As ULongInt = 1
+    For i As Integer = 1 To n
+        res *= i
+    Next
+    Return res
+End Function
+
+Print "Factorial de 10 (Iterativo):"; FactorialIter(10)
+
+3. Factorial Recursivo
+
+
+En FreeBASIC (Estilo Moderno)
+Fragmento de código
+
+Cls
+Print "Hola Mundo desde FreeBASIC"
+Sleep ' Espera a que pulses una tecla
+
+
+
+En FreeBASIC (Recursividad Real)
+
+FreeBASIC maneja la memoria de forma automática, permitiendo que la función se llame a sí misma elegantemente.
+Fragmento de código
+
+Function FactorialRec(n As Integer) As ULongInt
+    If n <= 1 Then 
+        Return 1
+    Else
+        Return n * FactorialRec(n - 1)
+    End If
+End Function
+
+Print "Factorial de 5 (Recursivo):"; FactorialRec(5)
+Sleep
+

data/docs/5-zxboriel.md

@@ -282,14 +282,6 @@ La mayoría de los programadores que usan Boriel en openSUSE prefieren las minú
     Diferenciación: Muchos usan mayúsculas para sus propias variables y minúsculas para los comandos del sistema (o al revés) para distinguir rápido qué es qué.
 ---
 
-3. Ejemplo comparativo
-
-Estilo "Retro" (Gritando):
-Fragmento de código
-
-10 BORDER 1: PAPER 7: INK 0: CLS
-20 LET X = 10
-30 PRINT AT 10, X; "HOLA"
 
 Estilo "Boriel" (Moderno y limpio):
 Fragmento de código
@@ -317,6 +309,8 @@ Zxboriel. Hola mundo y factorial iterativo y factorial recursivo
 
 ¡Excelente! Vamos a ver estos tres ejemplos en ZXBasic (Boriel). Notarás que el factorial recursivo es donde Boriel realmente brilla frente al BASIC antiguo, ya que el Spectrum original no permitía recursividad real de forma sencilla.
 
+---
+
 Aquí tienes el código en formato moderno (minúsculas y sin números de línea).
 1. Hola Mundo
 
@@ -356,6 +350,7 @@ dim n as ubyte = 5
 print "Factorial Iterativo de "; n; " es:"
 print factorial_iter(n)
 
+---
 3. Factorial Recursivo
 
 Boriel permite que una función se llame a sí misma. Nota importante: La recursividad en el Spectrum es lenta y puede agotar la memoria si el número es muy grande, pero para aprender la lógica es perfecta.
@@ -381,86 +376,3 @@ Cosas clave que debes saber:
     ubyte para el contador: Como el Spectrum tiene poca memoria y un procesador de 8 bits, usar ubyte (0-255) para la variable n e i hace que el programa sea mucho más rápido que si usaras integer.
 
     Indentación: Fíjate que he usado espacios para "meter hacia adentro" el código de los if y for. A Boriel no le importa, pero a tus ojos sí (hace el código mucho más profesional).
-
-¿Cómo probarlo todo junto?
-
-Puedes copiar los tres bloques en un solo archivo .bas, añadir un pause 0 al final para que la pantalla no se cierre, y usar el script que creamos antes:
-./build.sh programa.bas
-
-¿Te gustaría que te explique cómo optimizar aún más el código usando fixed (punto fijo) o prefieres intentar hacer un programa que pida el número por teclado con input?
-
-Haz los ejemplos con pcbasic y freebasic
-
-Para cerrar el círculo, aquí tienes los tres ejemplos comparados en PC-BASIC (el estilo de 1985 con números de línea) y FreeBASIC (el estilo moderno de 32/64 bits).
-
-Notarás que la mayor diferencia es cómo manejamos la recursividad, ya que el BASIC antiguo no la soportaba de forma nativa.
-1. Hola Mundo
-En PC-BASIC (Estilo GW-BASIC)
-Basic
-
-10 CLS
-20 PRINT "HOLA MUNDO DESDE PC-BASIC"
-30 END
-
-En FreeBASIC (Estilo Moderno)
-Fragmento de código
-
-Cls
-Print "Hola Mundo desde FreeBASIC"
-Sleep ' Espera a que pulses una tecla
-
-2. Factorial Iterativo (Bucle FOR)
-En PC-BASIC
-
-Aquí usamos una variable global F para el resultado y N para el número.
-Basic
-
-10 CLS
-20 INPUT "Introduce un numero: ", N
-30 F = 1
-40 FOR I = 1 TO N
-50 F = F * I
-60 NEXT I
-70 PRINT "El factorial es:"; F
-80 END
-
-En FreeBASIC
-
-Usamos una función limpia y tipos de datos protegidos para evitar que el número se "desborde".
-Fragmento de código
-
-Function FactorialIter(n As Integer) As ULongInt
-    Dim res As ULongInt = 1
-    For i As Integer = 1 To n
-        res *= i
-    Next
-    Return res
-End Function
-
-Print "Factorial de 10 (Iterativo):"; FactorialIter(10)
-
-3. Factorial Recursivo
-
-Aquí es donde está el gran cambio tecnológico.
-En PC-BASIC (Simulación con GOSUB)
-
-PC-BASIC no permite que una función se llame a sí misma. Para simularlo, los programadores antiguos usaban una "pila" manual o, más comúnmente, simplemente no lo hacían porque el GOSUB no crea variables nuevas cada vez.
-
-    Nota: En PC-BASIC es mejor quedarse con la versión iterativa. Intentar hacer recursividad real requiere trucos muy complejos con POKE y PEEK.
-
-En FreeBASIC (Recursividad Real)
-
-FreeBASIC maneja la memoria de forma automática, permitiendo que la función se llame a sí misma elegantemente.
-Fragmento de código
-
-Function FactorialRec(n As Integer) As ULongInt
-    If n <= 1 Then 
-        Return 1
-    Else
-        Return n * FactorialRec(n - 1)
-    End If
-End Function
-
-Print "Factorial de 5 (Recursivo):"; FactorialRec(5)
-Sleep
-

data/docs/keywords.md

@@ -0,0 +1,58 @@
+
+# Listado de los Keywords de BASIC ZX Spectrum
+
+
+Comandos de Control y Programa
+
+* LET: Asigna valores a variables.
+* PRINT: Muestra texto o números en pantalla.
+* INPUT: Detiene el programa para pedir datos al usuario.
+* LIST: Muestra el listado del código en memoria.
+* RUN: Inicia la ejecución del programa.
+* STOP: Detiene la ejecución (vital para separar el cuerpo principal de las subrutinas).
+* NEW: Borra el programa actual de la memoria.
+* REM: Se utiliza para insertar comentarios que el ordenador ignora.
+
+Estructuras de Control (Bucles y Saltos)
+
+* FOR: Inicia un bucle con una variable de control.
+* TO: Define el límite superior del bucle FOR.
+* STEP: Define el incremento del bucle (por defecto es 1).
+* NEXT: Cierra el bucle FOR.
+* IF: Evalúa una condición lógica.
+* THEN: Indica la acción a seguir si el IF es verdadero.
+* GOTO: Salto incondicional a una línea específica.
+* GOSUB: Salto a una subrutina.
+* RETURN: Regresa de una subrutina al punto posterior del GOSUB.
+
+Comandos Gráficos y Sonido
+
+* PLOT: Dibuja un punto en coordenadas (x, y).
+* DRAW: Dibuja una línea desde la última posición.
+* CIRCLE: Dibuja un círculo definido por coordenadas y radio.
+* BEEP: Produce un sonido especificando duración y tono.
+* INK: Cambia el color del trazo (0-7).
+* PAPER: Cambia el color del fondo.
+* BORDER: Cambia el color del borde de la pantalla.
+* CLS: Limpia la pantalla (Clear Screen).
+
+Funciones de Sistema y Manejo de Datos
+
+* DIM: Reserva espacio en memoria para arrays (arreglos).
+* DATA: Almacena datos dentro del programa.
+* READ: Lee los valores almacenados en las líneas DATA.
+* RESTORE: Reinicia el puntero de lectura de los DATA.
+* LOAD / SAVE: Carga o guarda programas en cinta (o disco).
+* RANDOMIZE: Inicializa el generador de números aleatorios.
+* POKE: Escribe un valor directamente en una dirección de memoria.
+* PEEK: Lee el valor de una dirección de memoria.
+
+Funciones Matemáticas y de Cadena
+
+* INT: Devuelve la parte entera de un número.
+* RND: Genera un número aleatorio.
+* STR$: Convierte un número en una cadena de texto.
+* VAL: Convierte una cadena de texto en un valor numérico.
+* LEN: Devuelve la longitud de una cadena.
+* SIN / COS / TAN: Funciones trigonométricas.
+

data/lib/ruby2basic/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Ruby2Basic
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/lib/ruby2basic/zxspectrum/transpiler.rb

@@ -0,0 +1,157 @@
+#frozen_string_literal: true
+require "prism"
+
+module Ruby2Basic
+  module ZXSpectrum
+    class Transpiler
+      attr_accessor :oneline
+  
+      def initialize
+        @oneline = false
+      end
+    
+      def reset
+        @lines = []
+        @line_num = 10
+        @subs = []
+        @labels = {}
+        @arrays = []
+        @string_vars = []
+      end
+  
+      def call(code)
+        reset
+        @result = Prism.parse(code)
+        @comments = @result.comments.map do |c| 
+          { line: c.location.start_line, text: c.location.slice.gsub(/^#\s*/, "") }
+        end
+  
+        return "Error de sintaxis" unless @result.success?
+        process_nodes(@result.value.statements.body)
+    
+        output = []
+        @arrays.each { |dim| output << "#{@line_num} #{dim}"; @line_num += 10 }
+        output += @lines
+  
+        unless @oneline
+          output << "#{@line_num} STOP"
+          @line_num += 10
+          output += @subs
+        end
+        output.join("\n")
+      end
+    
+      private
+    
+      # MODIFICACIÓN: Separamos el comando del contenido para no aplicar upcase a todo
+      def add_basic(command, content = "", to_subs: false)
+        line = "#{@line_num} #{command.upcase} #{content}".strip
+        to_subs ? @subs << line : @lines << line
+        @line_num += 10
+      end
+    
+      def process_nodes(nodes, to_subs: false)
+        nodes.each do |node|
+          check_for_comments(node.location.start_line, to_subs)
+          process_node(node, to_subs: to_subs)
+        end
+        check_for_comments(1000000, to_subs) 
+      end
+    
+      def check_for_comments(current_node_line, to_subs)
+        while @comments.any? && @comments.first[:line] <= current_node_line
+          comment = @comments.shift
+          add_basic("REM", comment[:text], to_subs: to_subs)
+        end
+      end
+    
+      def process_node(node, to_subs: false)
+        case node
+        when Prism::LocalVariableWriteNode
+          name = node.name.to_s
+          val = resolve(node.value)
+          
+          if node.value.is_a?(Prism::StringNode) || node.value.is_a?(Prism::InterpolatedStringNode)
+            @string_vars << name unless @string_vars.include?(name)
+            add_basic("LET", "#{name}$ = #{val}", to_subs: to_subs)
+          else
+            add_basic("LET", "#{name} = #{val}", to_subs: to_subs)
+          end
+      
+        when Prism::CallNode
+          case node.name.to_s
+          when "puts"
+            arg = node.arguments&.arguments&.first
+            add_basic("PRINT", resolve(arg), to_subs: to_subs)
+          when "times"
+            limit = resolve(node.receiver).to_i - 1
+            var = "i" # Variable de control en minúscula
+            add_basic("FOR", "#{var} = 0 TO #{limit}", to_subs: to_subs)
+            process_nodes(node.block.body.body, to_subs: to_subs) if node.block&.body
+            add_basic("NEXT", var, to_subs: to_subs)
+          else
+            if @labels[node.name.to_s]
+              add_basic("GOSUB", @labels[node.name.to_s].to_s, to_subs: to_subs)
+            end
+          end
+    
+        when Prism::IfNode
+          cond = resolve(node.predicate) 
+          stmt_count = node.statements&.body&.size || 0
+          jump_to = @line_num + (stmt_count * 10) + 10
+          add_basic("IF NOT", "#{cond} THEN GOTO #{jump_to}", to_subs: to_subs)
+          process_nodes(node.statements.body, to_subs: to_subs) if node.statements
+    
+        when Prism::DefNode
+          method_name = node.name.to_s
+          @labels[method_name] = @line_num
+          add_basic("REM", "SUB: #{method_name}", to_subs: true)
+          process_nodes(node.body.body, to_subs: true) if node.body
+          add_basic("RETURN", "", to_subs: true)
+        end
+      end
+      
+      def resolve(node)
+        return "0" if node.nil?
+        case node
+        when Prism::IntegerNode, Prism::FloatNode then node.slice
+        when Prism::StringNode then "\"#{node.content}\""
+        when Prism::LocalVariableReadNode
+          name = node.name.to_s
+          @string_vars.include?(name) ? "#{name}$" : name
+        
+        when Prism::InterpolatedStringNode
+          parts = node.parts.map do |part|
+            if part.is_a?(Prism::StringNode)
+              "\"#{part.content}\""
+            elsif part.is_a?(Prism::EmbeddedStatementsNode)
+              inner = part.statements.body.first
+              res = resolve(inner)
+              var_name = inner.respond_to?(:name) ? inner.name.to_s : nil
+              if !inner.is_a?(Prism::StringNode) && !@string_vars.include?(var_name)
+                "STR$(#{res})"
+              else
+                res
+              end
+            else
+              resolve(part)
+            end
+          end
+          parts.join(" + ")
+    
+        when Prism::CallNode
+          if node.receiver && node.arguments && node.arguments.arguments.size == 1
+            left = resolve(node.receiver)
+            right = resolve(node.arguments.arguments.first)
+            op = node.name.to_s == "==" ? "=" : node.name.to_s
+            "#{left} #{op} #{right}"
+          else
+            node.name.to_s
+          end
+        else "0"
+        end
+      end
+    end  
+  end
+end
+

data/lib/ruby2basic.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
 
 require_relative "ruby2basic/version"
-require_relative "ruby2basic/zxspectrum"
-
+require_relative "ruby2basic/zxspectrum/transpiler"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby2basic
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - David Vargas Ruiz
@@ -38,6 +38,7 @@ extra_rdoc_files:
 - docs/4-bwbasic.md
 - docs/5-zxboriel.md
 - docs/README.md
+- docs/keywords.md
 files:
 - LICENSE
 - README.md
@@ -48,9 +49,10 @@ files:
 - docs/4-bwbasic.md
 - docs/5-zxboriel.md
 - docs/README.md
+- docs/keywords.md
 - lib/ruby2basic.rb
 - lib/ruby2basic/version.rb
-- lib/ruby2basic/zxspectrum.rb
+- lib/ruby2basic/zxspectrum/transpiler.rb
 homepage: https://github.com/dvarrui/ruby2basic
 licenses:
 - MPL-2.0

data/lib/ruby2basic/zxspectrum.rb

@@ -1,146 +0,0 @@
-#frozen_string_literal: true
-require "prism"
-
-module Ruby2Basic
-  class ZXSpectrum
-    def initialize(code)
-      @result = Prism.parse(code)
-      @comments = @result.comments.map do |c| 
-        { line: c.location.start_line, text: c.location.slice.gsub(/^#\s*/, "") }
-      end
-      @lines = []
-      @line_num = 10
-      @subs = []
-      @labels = {}
-      @arrays = []
-      @string_vars = []
-    end
-  
-    def transpile
-      return "Error de sintaxis" unless @result.success?
-      process_nodes(@result.value.statements.body)
-  
-      output = []
-      @arrays.each { |dim| output << "#{@line_num} #{dim}"; @line_num += 10 }
-      output += @lines
-      output << "#{@line_num} STOP"
-      @line_num += 10
-      output += @subs
-      output.join("\n")
-    end
-  
-    private
-  
-    # MODIFICACIÓN: Separamos el comando del contenido para no aplicar upcase a todo
-    def add_basic(command, content = "", to_subs: false)
-      line = "#{@line_num} #{command.upcase} #{content}".strip
-      to_subs ? @subs << line : @lines << line
-      @line_num += 10
-    end
-  
-    def process_nodes(nodes, to_subs: false)
-      nodes.each do |node|
-        check_for_comments(node.location.start_line, to_subs)
-        process_node(node, to_subs: to_subs)
-      end
-      check_for_comments(1000000, to_subs) 
-    end
-  
-    def check_for_comments(current_node_line, to_subs)
-      while @comments.any? && @comments.first[:line] <= current_node_line
-        comment = @comments.shift
-        # REM se queda en mayúsculas, pero el texto del comentario se respeta
-        add_basic("REM", comment[:text], to_subs: to_subs)
-      end
-    end
-  
-    def process_node(node, to_subs: false)
-      case node
-      when Prism::LocalVariableWriteNode
-        name = node.name.to_s
-        val = resolve(node.value)
-        
-        if node.value.is_a?(Prism::StringNode) || node.value.is_a?(Prism::InterpolatedStringNode)
-          @string_vars << name unless @string_vars.include?(name)
-          add_basic("LET", "#{name}$ = #{val}", to_subs: to_subs)
-        else
-          add_basic("LET", "#{name} = #{val}", to_subs: to_subs)
-        end
-    
-      when Prism::CallNode
-        case node.name.to_s
-        when "puts"
-          arg = node.arguments&.arguments&.first
-          add_basic("PRINT", resolve(arg), to_subs: to_subs)
-        when "times"
-          limit = resolve(node.receiver).to_i - 1
-          var = "i" # Variable de control en minúscula
-          add_basic("FOR", "#{var} = 0 TO #{limit}", to_subs: to_subs)
-          process_nodes(node.block.body.body, to_subs: to_subs) if node.block&.body
-          add_basic("NEXT", var, to_subs: to_subs)
-        else
-          if @labels[node.name.to_s]
-            add_basic("GOSUB", @labels[node.name.to_s].to_s, to_subs: to_subs)
-          end
-        end
-  
-      when Prism::IfNode
-        cond = resolve(node.predicate) 
-        stmt_count = node.statements&.body&.size || 0
-        jump_to = @line_num + (stmt_count * 10) + 10
-        add_basic("IF NOT", "#{cond} THEN GOTO #{jump_to}", to_subs: to_subs)
-        process_nodes(node.statements.body, to_subs: to_subs) if node.statements
-  
-      when Prism::DefNode
-        method_name = node.name.to_s
-        @labels[method_name] = @line_num
-        add_basic("REM", "SUB: #{method_name}", to_subs: true)
-        process_nodes(node.body.body, to_subs: true) if node.body
-        add_basic("RETURN", "", to_subs: true)
-      end
-    end
-    
-    def resolve(node)
-      return "0" if node.nil?
-      case node
-      when Prism::IntegerNode, Prism::FloatNode then node.slice
-      when Prism::StringNode then "\"#{node.content}\""
-      when Prism::LocalVariableReadNode
-        name = node.name.to_s
-        @string_vars.include?(name) ? "#{name}$" : name
-      
-      when Prism::InterpolatedStringNode
-        parts = node.parts.map do |part|
-          if part.is_a?(Prism::StringNode)
-            "\"#{part.content}\""
-          elsif part.is_a?(Prism::EmbeddedStatementsNode)
-            inner = part.statements.body.first
-            res = resolve(inner)
-            var_name = inner.respond_to?(:name) ? inner.name.to_s : nil
-            
-            if !inner.is_a?(Prism::StringNode) && !@string_vars.include?(var_name)
-              "STR$(#{res})"
-            else
-              res
-            end
-          else
-            resolve(part)
-          end
-        end
-        parts.join("+")
-  
-      when Prism::CallNode
-        if node.receiver && node.arguments && node.arguments.arguments.size == 1
-          left = resolve(node.receiver)
-          right = resolve(node.arguments.arguments.first)
-          op = node.name.to_s == "==" ? "=" : node.name.to_s
-          "#{left}#{op}#{right}"
-        else
-          node.name.to_s
-        end
-      else "0"
-      end
-    end
-  end
-end
-