Signal handling, take 2.

runtime/bin/process.h

 // Copyright (c) 2012, 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.
 
 #ifndef BIN_PROCESS_H_
 #define BIN_PROCESS_H_
 
 #include "bin/builtin.h"
 #include "bin/io_buffer.h"
 #include "bin/thread.h"
@@ skipping 23 matching lines @@
 
  private:
   Dart_Handle stdout_data_;
   Dart_Handle stderr_data_;
   intptr_t exit_code_;
 
   DISALLOW_ALLOCATION();
 };
 
 
+enum ProcessSignals {

[Søren Gjesse, 2013/12/19 15:05:37]

Please add a comment that these constants need to be in sync with their Dart
counterparts.

[Anders Johnsen, 2013/12/19 15:07:41]

Done.

+  kSighup = 1,
+  kSigint = 2,
+  kSigquit = 3,
+  kSigill = 4,
+  kSigtrap = 5,
+  kSigabrt = 6,
+  kSigbus = 7,
+  kSigfpe = 8,
+  kSigkill = 9,
+  kSigusr1 = 10,
+  kSigsegv = 11,
+  kSigusr2 = 12,
+  kSigpipe = 13,
+  kSigalrm = 14,
+  kSigterm = 15,
+  kSigchld = 17,
+  kSigcont = 18,
+  kSigstop = 19,
+  kSigtstp = 20,
+  kSigttin = 21,
+  kSigttou = 22,
+  kSigurg = 23,
+  kSigxcpu = 24,
+  kSigxfsz = 25,
+  kSigvtalrm = 26,
+  kSigprof = 27,
+  kSigwinch = 28,
+  kSigpoll = 29,
+  kSigsys = 31
+};
+
+
 class Process {
  public:
   // Start a new process providing access to stdin, stdout, stderr and
   // process exit streams.
   static int Start(const char* path,
                    char* arguments[],
                    intptr_t arguments_length,
                    const char* working_directory,
                    char* environment[],
                    intptr_t environment_length,
@@ skipping 23 matching lines @@
     return global_exit_code_;
   }
 
   static void SetGlobalExitCode(int exit_code) {
     MutexLocker ml(global_exit_code_mutex_);
     global_exit_code_ = exit_code;
   }
 
   static intptr_t CurrentProcessId();
 
+  static intptr_t SetSignalHandler(intptr_t signal);
+  static void ClearSignalHandler(intptr_t signal);
+
   static Dart_Handle GetProcessIdNativeField(Dart_Handle process,
                                              intptr_t* pid);
   static Dart_Handle SetProcessIdNativeField(Dart_Handle process,
                                              intptr_t pid);
 
  private:
   static int global_exit_code_;
   static dart::Mutex* global_exit_code_mutex_;
 
   DISALLOW_ALLOCATION();
   DISALLOW_IMPLICIT_CONSTRUCTORS(Process);
 };
 
 
+class SignalInfo {
+ public:
+  SignalInfo(int fd, int signal, SignalInfo* prev = NULL)
+      : fd_(fd),
+        signal_(signal),
+        // SignalInfo is expected to be created when in a isolate.
+        port_(Dart_GetMainPortId()),
+        next_(NULL),
+        prev_(prev) {
+    if (prev_ != NULL) {
+      prev_->next_ = this;
+    }
+  }
+
+  ~SignalInfo();
+
+  void Unlink() {
+    if (prev_ != NULL) {
+      prev_->next_ = next_;
+    }
+    if (next_ != NULL) {
+      next_->prev_ = prev_;
+    }
+  }
+
+  int fd() const { return fd_; }
+  int signal() const { return signal_; }
+  Dart_Port port() const { return port_; }
+  SignalInfo* next() const { return next_; }
+
+ private:
+  int fd_;
+  int signal_;
+  // The port_ is used to identify what isolate the signal-info belongs to.
+  Dart_Port port_;
+  SignalInfo* next_;
+  SignalInfo* prev_;
+};
+
+
 // Utility class for collecting the output when running a process
 // synchronously by using Process::Wait. This class is sub-classed in
 // the platform specific files to implement reading into the buffers
 // allocated.
 class BufferListBase {
  protected:
   static const intptr_t kBufferSize = 16 * 1024;
 
   class BufferListNode {
    public:
@@ skipping 85 matching lines @@
   intptr_t data_size_;
 
   // Number of free bytes in the last node in the list.
   intptr_t free_size_;
 };
 
 }  // namespace bin
 }  // namespace dart
 
 #endif  // BIN_PROCESS_H_