lib/standard/exec.nit

   1 # This file is part of NIT ( http://www.nitlanguage.org ).
   2 #
   3 # Copyright 2004-2008 Jean Privat <jean@pryen.org>
   4 # Copyright 2008 Floréal Morandat <morandat@lirmm.fr>
   5 #
   6 # This file is free software, which comes along with NIT.  This software is
   7 # distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
   8 # without  even  the implied warranty of  MERCHANTABILITY or  FITNESS FOR A
   9 # PARTICULAR PURPOSE.  You can modify it is you want,  provided this header
  10 # is kept unaltered, and a notification of the changes is added.
  11 # You  are  allowed  to  redistribute it and sell it, alone or is a part of
  12 # another product.
  13
  14 # Invocation and management of operating system sub-processes.
  15 # Standard input and output can be handled through streams.
  16 module exec
  17
  18 import file
  19
  20 # Simple sub-process
  21 class Process
  22         # The pid of the process
  23         fun id: Int do return data.id
  24
  25         # Is the process finished?
  26         fun is_finished: Bool do return data.is_finished
  27
  28         # Wait the termination of the process
  29         fun wait
  30         do
  31                 data.wait
  32                 assert is_finished
  33         end
  34
  35         # The status once finished
  36         fun status: Int
  37         do
  38                 assert is_finished
  39                 return data.status
  40         end
  41
  42         # The executable run
  43         # Is a filepath, or a executable found in PATH
  44         var command: String
  45
  46         # The arguments of the command
  47         # Starts with the first real arguments---ie. does not include the progname (`argv[0]`, in C)
  48         var arguments: nullable Array[String]
  49
  50         # Launch a command with some arguments
  51         init(command: String, arguments: String...) is old_style_init do
  52                 self.command = command
  53                 self.arguments = arguments
  54                 execute
  55         end
  56
  57         # Launch a simple command with arguments passed as an array
  58         init from_a(command: String, arguments: nullable Array[String])
  59         do
  60                 self.command = command
  61                 self.arguments = arguments
  62                 execute
  63         end
  64
  65         # flags used internally to know whith pipe to open
  66         private fun pipeflags: Int do return 0
  67
  68         # Internal code to handle execution
  69         protected fun execute
  70         do
  71                 # The pass the arguments as a big C string where elements are separated with '\0'
  72                 var args = new FlatBuffer
  73                 var l = 1 # Number of elements in args
  74                 args.append(command)
  75                 if arguments != null then
  76                         for a in arguments do
  77                                 args.add('\0')
  78                                 #a.output_class_name
  79                                 args.append(a)
  80                         end
  81                         l += arguments.length
  82                 end
  83                 data = basic_exec_execute(command.to_cstring, args.to_s.to_cstring, l, pipeflags)
  84         end
  85
  86         private var data: NativeProcess
  87         private fun basic_exec_execute(p: NativeString, av: NativeString, ac: Int, pf: Int): NativeProcess is extern "exec_Process_Process_basic_exec_execute_4"
  88 end
  89
  90 # `Process` on which the `stdout` is readable like a `Reader`
  91 class ProcessReader
  92         super Process
  93         super Reader
  94
  95         # File Descriptor used for the input.
  96         var stream_in: FileReader is noinit
  97
  98         redef fun close do stream_in.close
  99
 100         redef fun read_char do return stream_in.read_char
 101
 102         redef fun eof do return stream_in.eof
 103
 104         redef fun pipeflags do return 2
 105
 106         redef fun execute
 107         do
 108                 super
 109                 stream_in = new FileReader.from_fd(data.out_fd)
 110         end
 111 end
 112
 113 # `Process` on which `stdin` is writable like a `Writer`
 114 class ProcessWriter
 115         super Process
 116         super Writer
 117
 118         # File Descriptor used for the output.
 119         var stream_out: Writer is noinit
 120
 121         redef fun close do stream_out.close
 122
 123         redef fun is_writable do return stream_out.is_writable
 124
 125         redef fun write(s) do stream_out.write(s)
 126
 127         redef fun pipeflags do return 1
 128
 129         redef fun execute
 130         do
 131                 super
 132                 var out = new FileWriter.from_fd(data.in_fd)
 133                 out.set_buffering_mode(0, sys.buffer_mode_none)
 134                 stream_out = out
 135         end
 136 end
 137
 138 # `Process` on which stdout can be read and stdin can be written to like a `Duplex`
 139 class ProcessDuplex
 140         super ProcessReader
 141         super ProcessWriter
 142         super Duplex
 143
 144         redef fun close
 145         do
 146                 stream_in.close
 147                 stream_out.close
 148         end
 149
 150         redef fun pipeflags do return 3
 151
 152         redef fun execute
 153         do
 154                 super
 155         end
 156 end
 157
 158 redef class Sys
 159         # Execute a shell command and return its error code
 160         fun system(command: String): Int
 161         do
 162                 return command.to_cstring.system
 163         end
 164 end
 165
 166 redef class NativeString
 167         # Execute self as a shell command.
 168         #
 169         # See the posix function system(3).
 170         fun system: Int is extern "string_NativeString_NativeString_system_0"
 171 end
 172
 173 private extern class NativeProcess
 174         fun id: Int is extern "exec_NativeProcess_NativeProcess_id_0"
 175         fun is_finished: Bool is extern "exec_NativeProcess_NativeProcess_is_finished_0"
 176         fun status: Int is extern "exec_NativeProcess_NativeProcess_status_0"
 177         fun wait is extern "exec_NativeProcess_NativeProcess_wait_0"
 178
 179         fun in_fd: Int is extern "exec_NativeProcess_NativeProcess_in_fd_0"
 180         fun out_fd: Int is extern "exec_NativeProcess_NativeProcess_out_fd_0"
 181         fun err_fd: Int is extern "exec_NativeProcess_NativeProcess_err_fd_0"
 182 end
 183