1 files changed, 58 insertions, 58 deletions

diff --git a/lib/prism/ffi.rb b/lib/prism/ffi.rb
index 82643be808..3ff1875611 100644
--- a/lib/prism/ffi.rb
+++ b/lib/prism/ffi.rb
@@ -6,7 +6,7 @@
 require "rbconfig"
 require "ffi"
 
-module YARP
+module Prism
   BACKEND = :FFI
 
   module LibRubyParser
@@ -35,13 +35,13 @@ module YARP
     def self.load_exported_functions_from(header, *functions)
       File.foreach(File.expand_path("../../include/#{header}", __dir__)) do |line|
         # We only want to attempt to load exported functions.
-        next unless line.start_with?("YP_EXPORTED_FUNCTION ")
+        next unless line.start_with?("PRISM_EXPORTED_FUNCTION ")
 
         # We only want to load the functions that we are interested in.
         next unless functions.any? { |function| line.include?(function) }
 
         # Parse the function declaration.
-        unless /^YP_EXPORTED_FUNCTION (?<return_type>.+) (?<name>\w+)\((?<arg_types>.+)\);$/ =~ line
+        unless /^PRISM_EXPORTED_FUNCTION (?<return_type>.+) (?<name>\w+)\((?<arg_types>.+)\);$/ =~ line
           raise "Could not parse #{line}"
         end
 
@@ -67,35 +67,35 @@ module YARP
     end
 
     load_exported_functions_from(
-      "yarp.h",
-      "yp_version",
-      "yp_parse_serialize",
-      "yp_lex_serialize",
-      "yp_parse_lex_serialize"
+      "prism.h",
+      "pm_version",
+      "pm_parse_serialize",
+      "pm_lex_serialize",
+      "pm_parse_lex_serialize"
     )
 
     load_exported_functions_from(
-      "yarp/util/yp_buffer.h",
-      "yp_buffer_sizeof",
-      "yp_buffer_init",
-      "yp_buffer_value",
-      "yp_buffer_length",
-      "yp_buffer_free"
+      "prism/util/pm_buffer.h",
+      "pm_buffer_sizeof",
+      "pm_buffer_init",
+      "pm_buffer_value",
+      "pm_buffer_length",
+      "pm_buffer_free"
     )
 
     load_exported_functions_from(
-      "yarp/util/yp_string.h",
-      "yp_string_mapped_init",
-      "yp_string_free",
-      "yp_string_source",
-      "yp_string_length",
-      "yp_string_sizeof"
+      "prism/util/pm_string.h",
+      "pm_string_mapped_init",
+      "pm_string_free",
+      "pm_string_source",
+      "pm_string_length",
+      "pm_string_sizeof"
     )
 
-    # This object represents a yp_buffer_t. We only use it as an opaque pointer,
-    # so it doesn't need to know the fields of yp_buffer_t.
-    class YPBuffer
-      SIZEOF = LibRubyParser.yp_buffer_sizeof
+    # This object represents a pm_buffer_t. We only use it as an opaque pointer,
+    # so it doesn't need to know the fields of pm_buffer_t.
+    class PrismBuffer
+      SIZEOF = LibRubyParser.pm_buffer_sizeof
 
       attr_reader :pointer
 
@@ -104,11 +104,11 @@ module YARP
       end
 
       def value
-        LibRubyParser.yp_buffer_value(pointer)
+        LibRubyParser.pm_buffer_value(pointer)
       end
 
       def length
-        LibRubyParser.yp_buffer_length(pointer)
+        LibRubyParser.pm_buffer_length(pointer)
       end
 
       def read
@@ -121,19 +121,19 @@ module YARP
         pointer = FFI::MemoryPointer.new(SIZEOF)
 
         begin
-          raise unless LibRubyParser.yp_buffer_init(pointer)
+          raise unless LibRubyParser.pm_buffer_init(pointer)
           yield new(pointer)
         ensure
-          LibRubyParser.yp_buffer_free(pointer)
+          LibRubyParser.pm_buffer_free(pointer)
           pointer.free
         end
       end
     end
 
-    # This object represents a yp_string_t. We only use it as an opaque pointer,
+    # This object represents a pm_string_t. We only use it as an opaque pointer,
     # so it doesn't have to be an FFI::Struct.
-    class YPString
-      SIZEOF = LibRubyParser.yp_string_sizeof
+    class PrismString
+      SIZEOF = LibRubyParser.pm_string_sizeof
 
       attr_reader :pointer
 
@@ -142,93 +142,93 @@ module YARP
       end
 
       def source
-        LibRubyParser.yp_string_source(pointer)
+        LibRubyParser.pm_string_source(pointer)
       end
 
       def length
-        LibRubyParser.yp_string_length(pointer)
+        LibRubyParser.pm_string_length(pointer)
       end
 
       def read
         source.read_string(length)
       end
 
-      # Yields a yp_string_t pointer to the given block.
+      # Yields a pm_string_t pointer to the given block.
       def self.with(filepath, &block)
         pointer = FFI::MemoryPointer.new(SIZEOF)
 
         begin
-          raise unless LibRubyParser.yp_string_mapped_init(pointer, filepath)
+          raise unless LibRubyParser.pm_string_mapped_init(pointer, filepath)
           yield new(pointer)
         ensure
-          LibRubyParser.yp_string_free(pointer)
+          LibRubyParser.pm_string_free(pointer)
           pointer.free
         end
       end
     end
 
     def self.dump_internal(source, source_size, filepath)
-      YPBuffer.with do |buffer|
+      PrismBuffer.with do |buffer|
         metadata = [filepath.bytesize, filepath.b, 0].pack("LA*L") if filepath
-        yp_parse_serialize(source, source_size, buffer.pointer, metadata)
+        pm_parse_serialize(source, source_size, buffer.pointer, metadata)
         buffer.read
       end
     end
   end
 
   # Mark the LibRubyParser module as private as it should only be called through
-  # the YARP module.
+  # the prism module.
   private_constant :LibRubyParser
 
-  # The version constant is set by reading the result of calling yp_version.
-  VERSION = LibRubyParser.yp_version.read_string
+  # The version constant is set by reading the result of calling pm_version.
+  VERSION = LibRubyParser.pm_version.read_string
 
-  # Mirror the YARP.dump API by using the serialization API.
+  # Mirror the Prism.dump API by using the serialization API.
   def self.dump(code, filepath = nil)
     LibRubyParser.dump_internal(code, code.bytesize, filepath)
   end
 
-  # Mirror the YARP.dump_file API by using the serialization API.
+  # Mirror the Prism.dump_file API by using the serialization API.
   def self.dump_file(filepath)
-    LibRubyParser::YPString.with(filepath) do |string|
+    LibRubyParser::PrismString.with(filepath) do |string|
       LibRubyParser.dump_internal(string.source, string.length, filepath)
     end
   end
 
-  # Mirror the YARP.lex API by using the serialization API.
+  # Mirror the Prism.lex API by using the serialization API.
   def self.lex(code, filepath = nil)
-    LibRubyParser::YPBuffer.with do |buffer|
-      LibRubyParser.yp_lex_serialize(code, code.bytesize, filepath, buffer.pointer)
+    LibRubyParser::PrismBuffer.with do |buffer|
+      LibRubyParser.pm_lex_serialize(code, code.bytesize, filepath, buffer.pointer)
       Serialize.load_tokens(Source.new(code), buffer.read)
     end
   end
 
-  # Mirror the YARP.lex_file API by using the serialization API.
+  # Mirror the Prism.lex_file API by using the serialization API.
   def self.lex_file(filepath)
-    LibRubyParser::YPString.with(filepath) do |string|
+    LibRubyParser::PrismString.with(filepath) do |string|
       lex(string.read, filepath)
     end
   end
 
-  # Mirror the YARP.parse API by using the serialization API.
+  # Mirror the Prism.parse API by using the serialization API.
   def self.parse(code, filepath = nil)
-    YARP.load(code, dump(code, filepath))
+    Prism.load(code, dump(code, filepath))
   end
 
-  # Mirror the YARP.parse_file API by using the serialization API. This uses
+  # Mirror the Prism.parse_file API by using the serialization API. This uses
   # native strings instead of Ruby strings because it allows us to use mmap when
   # it is available.
   def self.parse_file(filepath)
-    LibRubyParser::YPString.with(filepath) do |string|
+    LibRubyParser::PrismString.with(filepath) do |string|
       parse(string.read, filepath)
     end
   end
 
-  # Mirror the YARP.parse_lex API by using the serialization API.
+  # Mirror the Prism.parse_lex API by using the serialization API.
   def self.parse_lex(code, filepath = nil)
-    LibRubyParser::YPBuffer.with do |buffer|
+    LibRubyParser::PrismBuffer.with do |buffer|
       metadata = [filepath.bytesize, filepath.b, 0].pack("LA*L") if filepath
-      LibRubyParser.yp_parse_lex_serialize(code, code.bytesize, buffer.pointer, metadata)
+      LibRubyParser.pm_parse_lex_serialize(code, code.bytesize, buffer.pointer, metadata)
 
       source = Source.new(code)
       loader = Serialize::Loader.new(source, buffer.read)
@@ -242,9 +242,9 @@ module YARP
     end
   end
 
-  # Mirror the YARP.parse_lex_file API by using the serialization API.
+  # Mirror the Prism.parse_lex_file API by using the serialization API.
   def self.parse_lex_file(filepath)
-    LibRubyParser::YPString.with(filepath) do |string|
+    LibRubyParser::PrismString.with(filepath) do |string|
       parse_lex(string.read, filepath)
     end
   end