Cannot read from `stdin`.

[hv10]

Hello dear Maintainers,

when trying to use juliac to compile the following small example on MacOS (M4 Mac):

(@main)(ARGS) = begin
    s::String = readline(stdin)
    println(Core.stdout, s)
    return 0
end

I encounter the following 2 errors:

◐ Compiling...Verifier error #1: unresolved call from statement Main.readline(Main.stdin::IO)::String
Stacktrace:
 [1] main(ARGS::Vector{String})
   @ Main ~/Downloads/test_juliac/LSLAppTest/scripts/DataLoadingTest.jl:13
 [2] _main(argc::Int32, argv::Ptr{Ptr{Int8}})
   @ Main ~/.julia/packages/JuliaC/EFQEY/src/scripts/juliac-buildscript.jl:77

Verifier error #2: unresolved call from statement Main.readline(Main.stdin::IO)::String
Stacktrace:
 [1] main(ARGS::Vector{String})
   @ Main ~/Downloads/test_juliac/LSLAppTest/scripts/DataLoadingTest.jl:13
 [2] _main(argc::Int32, argv::Ptr{Ptr{Int8}})
   @ Main ~/.julia/packages/JuliaC/EFQEY/src/scripts/juliac-buildscript.jl:77

Trim verify finished with 2 errors, 0 warnings.
✓ Compiling...
ERROR: Failed to compile scripts/DataLoadingTest.jl
Stacktrace:
 [1] error(s::String)
   @ Base ./error.jl:44
 [2] compile_products(recipe::JuliaC.ImageRecipe)
   @ JuliaC ~/.julia/packages/JuliaC/EFQEY/src/compiling.jl:142
 [3] _main_cli(args::Vector{String}; io::Base.TTY)
   @ JuliaC ~/.julia/packages/JuliaC/EFQEY/src/JuliaC.jl:191
 [4] _main_cli(args::Vector{String})
   @ JuliaC ~/.julia/packages/JuliaC/EFQEY/src/JuliaC.jl:182
 [5] main(ARGS::Vector{String})
   @ JuliaC ~/.julia/packages/JuliaC/EFQEY/src/JuliaC.jl:197
 [6] _start()
   @ Base ./client.jl:556

I was able to find out that Base.stdin seems to be unavailable, and recreating the Base.TTY for the RawFD of 0 did not help (file descriptor for stdin under POSIX, iirc.) as we encounter the following situation:

(@main)(ARGS) = begin
    s::String = readline(Base.TTY(Base.RawFD(0)))
    println(Core.stdout, s)
    return 0
end

Error:

◐ Compiling...Verifier error #1: unresolved call from statement (Base.var"#readcb_specialized#uv_readcb##0"())(ccall(:jl_value_ptr)::Base.LibuvStream, nread::Any, ccall(:jl_uv_buf_len)::UInt64)::Any
Stacktrace:
 [1] uv_readcb(handle::Ptr{Nothing}, nread::Int64, buf::Ptr{Nothing})
   @ Base stream.jl:720

It seems to me that parts of libuv are not yet "compileable", would you be able to point me to the reason or give me some pointers on how to read from stdin when using juliac?

[hv10]

A solution on my MacOS based PC was to interface directly with the C stdlib by ccall'ing the POSIX read function.
The function I came up with which fulfilled my needs was as follows (using the File Descriptor fd=0 as stdin):

module StaticIO

export readline_c, println_c, write_c

# -----------------------------
# Read a line from stdin
# -----------------------------
readline_c()::Union{String,Nothing} = readline_c(0)
function readline_c(fd::Int)::Union{String,Nothing}
    buf = Vector{UInt8}(undef, 1024)     # fixed buffer
    pos::Int = 1                         # current write position
    byte_ref = Ref{UInt8}()              # reference for ccall
    eof_flag = false

    while true
        # Read 1 byte from stdin (fd 0)
        n::Int = ccall(
            :read, Int, # library function and return type
            (Int, Ptr{UInt8}, Csize_t), # argument types
            fd, byte_ref, 1) # arguments: fd, buffer, count

        if n == 0
            # EOF or error
            eof_flag = true
            break
        end

        byte::UInt8 = byte_ref[]
        buf[pos] = byte
        pos += 1

        # Stop at newline
        if byte == 0x0a
            break
        end

        if pos > length(buf)
            error("Line too long")
        end
    end

    if pos > 1
        return String(buf[1:pos-1])
    else
        return nothing
    end
end

end # module

[AwesomeQuest]

    n::Int = ccall(
        :read, Int, # library function and return type
        (Int, Ptr{UInt8}, Csize_t), # argument types
        fd, byte_ref, 1) # arguments: fd, buffer, count

A note for future readers, on windows :read should be :_read

[YuriMiyamori]

There is another way that avoids calling the C stdlib directly. On Linux and macOS, you can use a Ref to an IOStream so that the compiler can fully infer the type at compile time and still bind stdin at runtime:

const STDIN_REF = Ref{IOStream}(open("/dev/null")) # Using a Ref with a concrete IOStream type lets the compiler fully infer the type

function (@main)(ARGS::Vector{String})
    STDIN_REF[] = open("/dev/stdin") # Set stdin at runtime
    line = readline(STDIN_REF[]) # IOStream type is already determined
    println(Core.stdout, line)
    # ...
    return 0
end

[hv10]

There is another way that avoids calling the C stdlib directly. On Linux and macOS, you can use a Ref to an IOStream so that the compiler can fully infer the type at compile time and still bind stdin at runtime:
[...]

@YuriMiyamori are you aware how a user on Windows would do the same? Using the normal IOStream interface seems vastly preferrable to me.

[YuriMiyamori]

@hv10
I thought fdio(0) might work, and in fact it compiles, but at runtime the input is simply ignored. Changing the trim settings (including trim=safe and 'trim=no') did not make a difference. So unfortunately it seems difficult to achieve this at the moment.

One more note: the previous code still works even when simplified to:

# for unix only
function (@main)(::Vector{String})
    line = readline(open("/dev/stdin"))
    println(Core.stdout, "stdin: $line")
    return 0
end