process docs: fixed grammar

sdk/lib/io/process.dart

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of dart.io;
 
 // TODO(ager): The only reason for this class is that we
 // cannot patch a top-level at this point.
 class _ProcessUtils {
   external static void _exit(int status);
@@ skipping 79 matching lines @@
  */
 abstract class Process {
   /**
    * Returns a [:Future:] which completes with the exit code of the process
    * when the process completes.
    *
    * The handling of exit codes is platform specific.
    *
    * On Linux and Mac a normal exit code will be a positive value in
    * the range [0..255]. If the process was terminated due to a signal
-   * the exit code will be a negative value in the range [-255..0[,
+   * the exit code will be a negative value in the range [-255..-1],
    * where the absolute value of the exit code is the signal
    * number. For example, if a process crashes due to a segmentation
    * violation the exit code will be -11, as the signal SIGSEGV has the
    * number 11.
    *
    * On Windows a process can report any 32-bit value as an exit
    * code. When returning the exit code this exit code is turned into
    * a signed value. Some special values are used to report
    * termination due to some system event. E.g. if a process crashes
    * due to an access violation the 32-bit exit code is `0xc0000005`,
@@ skipping 136 matching lines @@
    * Returns the standard input stream of the process as an [IOSink].
    */
   IOSink get stdin;
 
   /**
    * Returns the process id of the process.
    */
   int get pid;
 
   /**
-   * On Windows, [kill] kills the process, ignoring the [signal]
-   * flag. On Posix systems, [kill] sends [signal] to the
-   * process. Depending on the signal send, it'll have different
-   * meanings. When the process terminates as a result of calling
-   * [kill], the [exitCode] future is completed with the exit code.
+   * On Linux and Mac OS, [kill] sends [signal] to the process. When the process
+   * terminates as a result of calling [kill], the value for [exitCode] may be a
+   * negative number corresponding to the provided [signal].
    *
-   * Returns [:true:] if the process is successfully killed (the
-   * signal is successfully sent). Returns [:false:] if the process
-   * could not be killed (the signal could not be sent). Usually,
-   * a [:false:] return value from kill means that the process is
+   * On Windows, [kill] kills the process, ignoring the [signal] flag.
+   *
+   * Returns [:true:] if the signal is successfully sent and process is killed.
+   * Otherwise the signal could not be sent, usually meaning that the process is
    * already dead.
    */
   bool kill([ProcessSignal signal = ProcessSignal.SIGTERM]);
 }
 
 
 /**
  * [ProcessResult] represents the result of running a non-interactive
  * process started with [:Process.run:].
  */
@@ skipping 113 matching lines @@
   final int errorCode;
 
   const ProcessException(this.executable, this.arguments, [this.message = "",
                          this.errorCode = 0]);
   String toString() {
     var msg = (message == null) ? 'OS error code: $errorCode' : message;
     var args = arguments.join(' ');
     return "ProcessException: $msg\n  Command: $executable $args";
   }
 }