pty_{master,slave} -> pt{m,s}

We decided to get rid of the master/slave terminology in Julia in #30058.
However, we decided to keep it for PTYs, where the terminology is imposed
upon us by POSIX (and thus changing it would be confusing for people who
might need to read up on the POSIX definitions of these concepts). It
was recently suggested to revisit this, by renaming to ptm and pts instead,
which also fit well (as the devies that the fds refer to are `/dev/ptmx`
and `/dev/pts` respectively), are googleable (`pty pts` will yield the
correct man page) and will probably need to remain even if POSIX
adjusts their terminology, since they're part of the ABI (presumably
they'll be backronymed to whatever terminology ends up winning).
This patch does this rename.

contrib/generate_precompile.jl

@@ -86,7 +86,7 @@ function generate_precompile_statements()
 
     mktemp() do precompile_file, precompile_file_h
         # Run a repl process and replay our script
-        pty_slave, pty_master = open_fake_pty()
+        pts, ptm = open_fake_pty()
         blackhole = Sys.isunix() ? "/dev/null" : "nul"
         if have_repl
             cmdargs = ```--color=yes
@@ -104,25 +104,25 @@ function generate_precompile_statements()
                    --cpu-target=native --startup-file=no --color=yes
                    -e 'import REPL; REPL.Terminals.is_precompiling[] = true'
                    -i $cmdargs```,
-                pty_slave, pty_slave, pty_slave; wait=false)
+                   pts, pts, pts; wait=false)
         end
-        Base.close_stdio(pty_slave)
-        # Prepare a background process to copy output from process until `pty_slave` is closed
+        Base.close_stdio(pts)
+        # Prepare a background process to copy output from process until `pts` is closed
         output_copy = Base.BufferStream()
         tee = @async try
-            while !eof(pty_master)
-                l = readavailable(pty_master)
+            while !eof(ptm)
+                l = readavailable(ptm)
                 write(debug_output, l)
                 Sys.iswindows() && (sleep(0.1); yield(); yield()) # workaround hang - probably a libuv issue?
                 write(output_copy, l)
             end
             close(output_copy)
-            close(pty_master)
+            close(ptm)
         catch ex
             close(output_copy)
-            close(pty_master)
+            close(ptm)
             if !(ex isa Base.IOError && ex.code == Base.UV_EIO)
-                rethrow() # ignore EIO on pty_master after pty_slave dies
+                rethrow() # ignore EIO on ptm after pts dies
             end
         end
         # wait for the definitive prompt before start writing to the TTY
@@ -141,7 +141,7 @@ function generate_precompile_statements()
                 bytesavailable(output_copy) > 0 && readavailable(output_copy)
                 # push our input
                 write(debug_output, "\n#### inputting statement: ####\n$(repr(l))\n####\n")
-                write(pty_master, l, "\n")
+                write(ptm, l, "\n")
                 readuntil(output_copy, "\n")
                 # wait for the next prompt-like to appear
                 # NOTE: this is rather innaccurate because the Pkg REPL mode is a special flower
@@ -150,10 +150,10 @@ function generate_precompile_statements()
             end
             println()
         end
-        write(pty_master, "exit()\n")
+        write(ptm, "exit()\n")
         wait(tee)
         success(p) || Base.pipeline_error(p)
-        close(pty_master)
+        close(ptm)
         write(debug_output, "\n#### FINISHED ####\n")
 
         # Extract the precompile statements from the precompile file

stdlib/LibGit2/test/libgit2.jl

@@ -47,9 +47,9 @@ function challenge_prompt(cmd::Cmd, challenges; timeout::Integer=60, debug::Bool
         return "Process output found:\n\"\"\"\n$str\n\"\"\""
     end
     out = IOBuffer()
-    with_fake_pty() do pty_slave, pty_master
-        p = run(detach(cmd), pty_slave, pty_slave, pty_slave, wait=false)
-        Base.close_stdio(pty_slave)
+    with_fake_pty() do pts, ptm
+        p = run(detach(cmd), pts, pts, pts, wait=false)
+        Base.close_stdio(pts)
 
         # Kill the process if it takes too long. Typically occurs when process is waiting
         # for input.
@@ -79,25 +79,25 @@ function challenge_prompt(cmd::Cmd, challenges; timeout::Integer=60, debug::Bool
         end
 
         for (challenge, response) in challenges
-            write(out, readuntil(pty_master, challenge, keep=true))
-            if !isopen(pty_master)
+            write(out, readuntil(ptm, challenge, keep=true))
+            if !isopen(ptm)
                 error("Could not locate challenge: \"$challenge\". ",
                       format_output(out))
             end
-            write(pty_master, response)
+            write(ptm, response)
         end
 
-        # Capture output from process until `pty_slave` is closed
+        # Capture output from process until `pts` is closed
         try
-            write(out, pty_master)
+            write(out, ptm)
         catch ex
             if !(ex isa Base.IOError && ex.code == Base.UV_EIO)
                 rethrow() # ignore EIO from master after slave dies
             end
         end
 
         status = fetch(timer)
-        close(pty_master)
+        close(ptm)
         if status != :success
             if status == :timeout
                 error("Process timed out possibly waiting for a response. ",

stdlib/REPL/test/repl.jl

@@ -768,43 +768,43 @@ Base.exit_on_sigint(true)
 
 let exename = Base.julia_cmd()
     # Test REPL in dumb mode
-    with_fake_pty() do pty_slave, pty_master
+    with_fake_pty() do pts, ptm
         nENV = copy(ENV)
         nENV["TERM"] = "dumb"
-        p = run(detach(setenv(`$exename --startup-file=no -q`, nENV)), pty_slave, pty_slave, pty_slave, wait=false)
-        Base.close_stdio(pty_slave)
-        output = readuntil(pty_master, "julia> ", keep=true)
+        p = run(detach(setenv(`$exename --startup-file=no -q`, nENV)), pts, pts, pts, wait=false)
+        Base.close_stdio(pts)
+        output = readuntil(ptm, "julia> ", keep=true)
         if ccall(:jl_running_on_valgrind, Cint,()) == 0
             # If --trace-children=yes is passed to valgrind, we will get a
             # valgrind banner here, not just the prompt.
             @test output == "julia> "
         end
-        write(pty_master, "1\nexit()\n")
+        write(ptm, "1\nexit()\n")
 
-        output = readuntil(pty_master, ' ', keep=true)
+        output = readuntil(ptm, ' ', keep=true)
         if Sys.iswindows()
 	    # Our fake pty is actually a pipe, and thus lacks the input echo feature of posix
             @test output == "1\n\njulia> "
         else
             @test output == "1\r\nexit()\r\n1\r\n\r\njulia> "
         end
-        @test bytesavailable(pty_master) == 0
+        @test bytesavailable(ptm) == 0
         @test if Sys.iswindows() || Sys.isbsd()
-                eof(pty_master)
+                eof(ptm)
             else
                 # Some platforms (such as linux) report EIO instead of EOF
                 # possibly consume child-exited notification
                 # for example, see discussion in https://bugs.python.org/issue5380
                 try
-                    eof(pty_master) && !Sys.islinux()
+                    eof(ptm) && !Sys.islinux()
                 catch ex
                     (ex isa Base.IOError && ex.code == Base.UV_EIO) || rethrow()
-                    @test_throws ex eof(pty_master) # make sure the error is sticky
-                    pty_master.readerror = nothing
-                    eof(pty_master)
+                    @test_throws ex eof(ptm) # make sure the error is sticky
+                    ptm.readerror = nothing
+                    eof(ptm)
                 end
             end
-        @test read(pty_master, String) == ""
+        @test read(ptm, String) == ""
         wait(p)
     end
 

test/testhelpers/FakePTYs.jl

@@ -16,25 +16,25 @@ function open_fake_pty()
         pid = string(getpid(), base=16, pad=16)
         pipename = """\\\\?\\pipe\\cygwin-$pid-pty10-abcdefg"""
         server = listen(pipename)
-        pty_slave = connect(pipename)
-        @assert ccall(:jl_ispty, Cint, (Ptr{Cvoid},), pty_slave.handle) == 1
-        pty_master = accept(server)
+        pts = connect(pipename)
+        @assert ccall(:jl_ispty, Cint, (Ptr{Cvoid},), pts.handle) == 1
+        ptm = accept(server)
         close(server)
         # extract just the file descriptor
-        fds = Libc.dup(Base._fd(pty_slave))
-        close(pty_slave)
-        pty_slave = fds
-        # convert pty_slave handle to a TTY
-        #fds = pty_slave.handle
-        #pty_slave.status = Base.StatusClosed
-        #pty_slave.handle = C_NULL
-        #pty_slave = Base.TTY(fds, Base.StatusOpen)
+        fds = Libc.dup(Base._fd(pts))
+        close(pts)
+        pts = fds
+        # convert pts handle to a TTY
+        #fds = pts.handle
+        #pts.status = Base.StatusClosed
+        #pts.handle = C_NULL
+        #pts = Base.TTY(fds, Base.StatusOpen)
     else
         O_RDWR = Base.Filesystem.JL_O_RDWR
         O_NOCTTY = Base.Filesystem.JL_O_NOCTTY
 
         fdm = ccall(:posix_openpt, Cint, (Cint,), O_RDWR | O_NOCTTY)
-        fdm == -1 && error("Failed to open pty_master")
+        fdm == -1 && error("Failed to open ptm")
         rc = ccall(:grantpt, Cint, (Cint,), fdm)
         rc != 0 && error("grantpt failed")
         rc = ccall(:unlockpt, Cint, (Cint,), fdm)
@@ -43,21 +43,21 @@ function open_fake_pty()
         fds = ccall(:open, Cint, (Ptr{UInt8}, Cint),
             ccall(:ptsname, Ptr{UInt8}, (Cint,), fdm), O_RDWR | O_NOCTTY)
 
-        pty_slave = RawFD(fds)
-        # pty_slave = fdio(fds, true)
-        # pty_slave = Base.Filesystem.File(RawFD(fds))
-        # pty_slave = Base.TTY(RawFD(fds); readable = false)
-        pty_master = Base.TTY(RawFD(fdm))
+            pts = RawFD(fds)
+        # pts = fdio(fds, true)
+        # pts = Base.Filesystem.File(RawFD(fds))
+        # pts = Base.TTY(RawFD(fds); readable = false)
+        ptm = Base.TTY(RawFD(fdm))
     end
-    return pty_slave, pty_master
+    return pts, ptm
 end
 
 function with_fake_pty(f)
-    pty_slave, pty_master = open_fake_pty()
+    pts, ptm = open_fake_pty()
     try
-        f(pty_slave, pty_master)
+        f(pts, ptm)
     finally
-        close(pty_master)
+        close(ptm)
     end
     nothing
 end