X-Git-Url: http://nitlanguage.org?ds=sidebyside diff --git a/lib/standard/exec.nit b/lib/standard/exec.nit index 2cde874..cb29312 100644 --- a/lib/standard/exec.nit +++ b/lib/standard/exec.nit @@ -5,33 +5,33 @@ # # This file is free software, which comes along with NIT. This software is # distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; -# without even the implied warranty of MERCHANTABILITY or FITNESS FOR A +# without even the implied warranty of MERCHANTABILITY or FITNESS FOR A # PARTICULAR PURPOSE. You can modify it is you want, provided this header # is kept unaltered, and a notification of the changes is added. # You are allowed to redistribute it and sell it, alone or is a part of # another product. -# This module handle simple system calls -# Standard input and output can be handleb trougth streams. -package exec +# Invocation and management of operating system sub-processes. +# Standard input and output can be handled through streams. +module exec -import stream +import file -# Simple sub-processus +# Simple sub-process class Process - # The pid of the processus + # The pid of the process fun id: Int do return data.id - # Is the processus finished? + # Is the process finished? fun is_finished: Bool do return data.is_finished - # wait the terminaison of the process + # Wait the termination of the process fun wait do data.wait assert is_finished end - + # The status once finished fun status: Int do @@ -39,93 +39,109 @@ class Process return data.status end - # launch a command with some arguments - init(command: String, arguments: String...) - do - execute(command, arguments, 0) + # The executable run + # Is a filepath, or a executable found in PATH + var command: String + + # The arguments of the command + # Starts with the first real arguments---ie. does not include the progname (`argv[0]`, in C) + var arguments: nullable Array[String] + + # Launch a command with some arguments + init(command: String, arguments: String...) is old_style_init do + self.command = command + self.arguments = arguments + execute end - # launch a simple command without arguments - init init_(command: String) + # Launch a simple command with arguments passed as an array + init from_a(command: String, arguments: nullable Array[String]) do - execute(command, null, 0) + self.command = command + self.arguments = arguments + execute end - # Internal code to handle execusion - protected init execute(command: String, arguments: nullable Array[String], pipeflags: Int) + # flags used internally to know whith pipe to open + private fun pipeflags: Int do return 0 + + # Internal code to handle execution + protected fun execute do - var args = new Buffer + # The pass the arguments as a big C string where elements are separated with '\0' + var args = new FlatBuffer var l = 1 # Number of elements in args args.append(command) if arguments != null then for a in arguments do args.add('\0') + #a.output_class_name args.append(a) end l += arguments.length end data = basic_exec_execute(command.to_cstring, args.to_s.to_cstring, l, pipeflags) end - + private var data: NativeProcess private fun basic_exec_execute(p: NativeString, av: NativeString, ac: Int, pf: Int): NativeProcess is extern "exec_Process_Process_basic_exec_execute_4" end -# stdout of the processus is readable -class IProcess +# `Process` on which the `stdout` is readable like a `Reader` +class ProcessReader super Process - super IStream - var stream_in: FDIStream - + super Reader + + # File Descriptor used for the input. + var stream_in: FileReader is noinit + redef fun close do stream_in.close - + redef fun read_char do return stream_in.read_char + redef fun read_byte do return stream_in.read_byte + redef fun eof do return stream_in.eof - init(command: String, arguments: String...) - do - execute(command, arguments, 2) - stream_in = new FDIStream(data.out_fd) - end - - init init_(command: String) + redef fun pipeflags do return 2 + + redef fun execute do - execute(command, null, 2) - stream_in = new FDIStream(data.out_fd) + super + stream_in = new FileReader.from_fd(data.out_fd) end end -# stdin of the processus is writable -class OProcess +# `Process` on which `stdin` is writable like a `Writer` +class ProcessWriter super Process - super OStream - var stream_out: OStream + super Writer + + # File Descriptor used for the output. + var stream_out: Writer is noinit redef fun close do stream_out.close redef fun is_writable do return stream_out.is_writable redef fun write(s) do stream_out.write(s) - - init(command: String, arguments: String...) - do - execute(command, arguments, 1) - stream_out = new FDOStream(data.in_fd) - end - - init init_(command: String) + + redef fun pipeflags do return 1 + + redef fun execute do - execute(command, null, 1) - stream_out = new FDOStream(data.in_fd) + super + var out = new FileWriter.from_fd(data.in_fd) + out.set_buffering_mode(0, sys.buffer_mode_none) + stream_out = out end end -# stdin and stdout are both accessible -class IOProcess - super IProcess - super OProcess - super IOStream +# `Process` on which stdout can be read and stdin can be written to like a `Duplex` +class ProcessDuplex + super ProcessReader + super ProcessWriter + super Duplex redef fun close do @@ -133,34 +149,30 @@ class IOProcess stream_out.close end - init(command: String, arguments: String...) - do - execute(command, arguments, 3) - stream_in = new FDIStream(data.out_fd) - stream_out = new FDOStream(data.in_fd) - end - - init init_(command: String) + redef fun pipeflags do return 3 + + redef fun execute do - execute(command, null, 3) - stream_in = new FDIStream(data.out_fd) - stream_out = new FDOStream(data.in_fd) + super end end redef class Sys - # Execute a shell command and return it's error code + # Execute a shell command and return its error code fun system(command: String): Int do - return command.to_cstring.system + return command.to_cstring.system end end redef class NativeString + # Execute self as a shell command. + # + # See the posix function system(3). fun system: Int is extern "string_NativeString_NativeString_system_0" end -private extern NativeProcess +private extern class NativeProcess fun id: Int is extern "exec_NativeProcess_NativeProcess_id_0" fun is_finished: Bool is extern "exec_NativeProcess_NativeProcess_is_finished_0" fun status: Int is extern "exec_NativeProcess_NativeProcess_status_0"