/
Signal.purs
140 lines (134 loc) · 3.01 KB
/
Signal.purs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
module Data.Posix.Signal where
import Prelude
import Data.Maybe (Maybe(..))
data Signal
= SIGABRT
| SIGALRM
| SIGBUS
| SIGCHLD
| SIGCLD
| SIGCONT
| SIGEMT
| SIGFPE
| SIGHUP
| SIGILL
| SIGINFO
| SIGINT
| SIGIO
| SIGIOT
| SIGKILL
| SIGLOST
| SIGPIPE
| SIGPOLL
| SIGPROF
| SIGPWR
| SIGQUIT
| SIGSEGV
| SIGSTKFLT
| SIGSTOP
| SIGSYS
| SIGTERM
| SIGTRAP
| SIGTSTP
| SIGTTIN
| SIGTTOU
| SIGUNUSED
| SIGURG
| SIGUSR1
| SIGUSR2
| SIGVTALRM
| SIGWINCH
| SIGXCPU
| SIGXFSZ
-- | Convert a Signal to a String. Suitable for Node.js APIs.
toString :: Signal -> String
toString s = case s of
SIGABRT -> "SIGABRT"
SIGALRM -> "SIGALRM"
SIGBUS -> "SIGBUS"
SIGCHLD -> "SIGCHLD"
SIGCLD -> "SIGCLD"
SIGCONT -> "SIGCONT"
SIGEMT -> "SIGEMT"
SIGFPE -> "SIGFPE"
SIGHUP -> "SIGHUP"
SIGILL -> "SIGILL"
SIGINFO -> "SIGINFO"
SIGINT -> "SIGINT"
SIGIO -> "SIGIO"
SIGIOT -> "SIGIOT"
SIGKILL -> "SIGKILL"
SIGLOST -> "SIGLOST"
SIGPIPE -> "SIGPIPE"
SIGPOLL -> "SIGPOLL"
SIGPROF -> "SIGPROF"
SIGPWR -> "SIGPWR"
SIGQUIT -> "SIGQUIT"
SIGSEGV -> "SIGSEGV"
SIGSTKFLT -> "SIGSTKFLT"
SIGSTOP -> "SIGSTOP"
SIGSYS -> "SIGSYS"
SIGTERM -> "SIGTERM"
SIGTRAP -> "SIGTRAP"
SIGTSTP -> "SIGTSTP"
SIGTTIN -> "SIGTTIN"
SIGTTOU -> "SIGTTOU"
SIGUNUSED -> "SIGUNUSED"
SIGURG -> "SIGURG"
SIGUSR1 -> "SIGUSR1"
SIGUSR2 -> "SIGUSR2"
SIGVTALRM -> "SIGVTALRM"
SIGWINCH -> "SIGWINCH"
SIGXCPU -> "SIGXCPU"
SIGXFSZ -> "SIGXFSZ"
-- | Try to parse a Signal from a String. Suitable for use with Node.js APIs.
-- | This function is a partial inverse of `toString`; in code, that means, for
-- | all `sig :: Signal`:
-- |
-- | `fromString (toString sig) == Just sig`
-- |
fromString :: String -> Maybe Signal
fromString s = case s of
"SIGABRT" -> Just SIGABRT
"SIGALRM" -> Just SIGALRM
"SIGBUS" -> Just SIGBUS
"SIGCHLD" -> Just SIGCHLD
"SIGCLD" -> Just SIGCLD
"SIGCONT" -> Just SIGCONT
"SIGEMT" -> Just SIGEMT
"SIGFPE" -> Just SIGFPE
"SIGHUP" -> Just SIGHUP
"SIGILL" -> Just SIGILL
"SIGINFO" -> Just SIGINFO
"SIGINT" -> Just SIGINT
"SIGIO" -> Just SIGIO
"SIGIOT" -> Just SIGIOT
"SIGKILL" -> Just SIGKILL
"SIGLOST" -> Just SIGLOST
"SIGPIPE" -> Just SIGPIPE
"SIGPOLL" -> Just SIGPOLL
"SIGPROF" -> Just SIGPROF
"SIGPWR" -> Just SIGPWR
"SIGQUIT" -> Just SIGQUIT
"SIGSEGV" -> Just SIGSEGV
"SIGSTKFLT" -> Just SIGSTKFLT
"SIGSTOP" -> Just SIGSTOP
"SIGSYS" -> Just SIGSYS
"SIGTERM" -> Just SIGTERM
"SIGTRAP" -> Just SIGTRAP
"SIGTSTP" -> Just SIGTSTP
"SIGTTIN" -> Just SIGTTIN
"SIGTTOU" -> Just SIGTTOU
"SIGUNUSED" -> Just SIGUNUSED
"SIGURG" -> Just SIGURG
"SIGUSR1" -> Just SIGUSR1
"SIGUSR2" -> Just SIGUSR2
"SIGVTALRM" -> Just SIGVTALRM
"SIGWINCH" -> Just SIGWINCH
"SIGXCPU" -> Just SIGXCPU
"SIGXFSZ" -> Just SIGXFSZ
_ -> Nothing
instance showSignal :: Show Signal where
show = toString
derive instance eqSignal :: Eq Signal
derive instance ordSignal :: Ord Signal