# enum Signal

##
Overview

Safely handle inter-process signals on POSIX systems.

Signals are dispatched to the event loop and later processed in a dedicated fiber. Some received signals may never be processed when the program terminates.

    puts "Ctrl+C still has the OS default action (stops the program)"
    sleep 3

    Signal::INT.trap do
      puts "Gotcha!"
    end
    puts "Ctrl+C will be caught from now on"
    sleep 3

    Signal::INT.reset
    puts "Ctrl+C is back to the OS default action"
    sleep 3

Note:

- An uncaught exception in a signal handler is a fatal error.

##
Defined in:

##
Enum Members

HUP = `1`
INT = `2`
QUIT = `3`
ILL = `4`
TRAP = `5`
IOT = `6`
ABRT = `6`
FPE = `8`
KILL = `9`
BUS = `7`
SEGV = `11`
SYS = `31`
PIPE = `13`
ALRM = `14`
TERM = `15`
URG = `23`
STOP = `19`
TSTP = `20`
CONT = `18`
CHLD = `17`
TTIN = `21`
TTOU = `22`
IO = `29`
XCPU = `24`
XFSZ = `25`
VTALRM = `26`
USR1 = `10`
USR2 = `12`
WINCH = `28`
PWR = `30`
STKFLT = `16`
UNUSED = `31`

##
Instance Method Summary

- #abrt?
- #alrm?
- #bus?
- #chld?
- #cont?
- #fpe?
- #hup?
- #ignore : Nil

  Clears the handler for this signal and prevents the OS default action.

- #ill?
- #int?
- #io?
- #iot?
- #kill?
- #pipe?
- #pwr?
- #quit?
- #reset : Nil

  Resets the handler for this signal to the OS default.

- #segv?
- #stkflt?
- #stop?
- #sys?
- #term?
- #trap(&handler : Signal -> ) : Nil

  Sets the handler for this signal to the passed function.

- #trap?
- #tstp?
- #ttin?
- #ttou?
- #unused?
- #urg?
- #usr1?
- #usr2?
- #vtalrm?
- #winch?
- #xcpu?
- #xfsz?

### Instance methods inherited from struct `Enum`

&(other : self) &, +(other : Int) +, -(other : Int) -, <=>(other : self) <=>, ==(other : self) ==, ^(other : self) ^, clone clone, each(&) each, hash(hasher) hash, includes?(other : self) includes?, to_f32 : Float32 to_f32, to_f32! : Float32 to_f32!, to_f64 : Float64 to_f64, to_f64! : Float64 to_f64!, to_i : Int32 to_i, to_i16 : Int16 to_i16, to_i16! : Int16 to_i16!, to_i32 : Int32 to_i32, to_i32! : Int32 to_i32!, to_i64 : Int64 to_i64, to_i64! : Int64 to_i64!, to_i8 : Int8 to_i8, to_i8! : Int8 to_i8!, to_json(json : JSON::Builder) to_json, to_s(io : IO) : Nil
to_s : String to_s, to_u16 : UInt16 to_u16, to_u16! : UInt16 to_u16!, to_u32 : UInt32 to_u32, to_u32! : UInt32 to_u32!, to_u64 : UInt64 to_u64, to_u64! : UInt64 to_u64!, to_u8 : UInt8 to_u8, to_u8! : UInt8 to_u8!, to_yaml(yaml : YAML::Nodes::Builder) to_yaml, |(other : self) |, ~ ~

### Constructor methods inherited from struct `Enum`

from_value(value : Int) : self from_value, from_value?(value : Int) : self? from_value?, new(ctx : YAML::ParseContext, node : YAML::Nodes::Node)
new(pull : JSON::PullParser) new, parse(string : String) : self parse, parse?(string : String) : self? parse?

### Class methods inherited from struct `Enum`

each(&) each, names : Array(String) names, valid?(value : self) : Bool valid?, values : Array(self) values

### Instance methods inherited from module `Comparable(Enum)`

<(other : T) <, <=(other : T) <=, <=>(other : T) <=>, ==(other : T) ==, >(other : T) >, >=(other : T) >=, clamp(min, max)
clamp(range : Range) clamp

### Instance methods inherited from struct `Value`

==(other : JSON::Any)
==(other : YAML::Any)
==(other) ==, dup dup

### Instance methods inherited from class `Object`

!=(other) !=, !~(other) !~, ==(other) ==, ===(other : JSON::Any)
===(other : YAML::Any)
===(other) ===, =~(other) =~, __crystal_pseudo_! : Bool __crystal_pseudo_!, __crystal_pseudo_as(type : Class) __crystal_pseudo_as, __crystal_pseudo_as?(type : Class) __crystal_pseudo_as?, __crystal_pseudo_is_a?(type : Class) : Bool __crystal_pseudo_is_a?, __crystal_pseudo_nil? : Bool __crystal_pseudo_nil?, __crystal_pseudo_responds_to?(name : Symbol) : Bool __crystal_pseudo_responds_to?, class class, dup dup, hash(hasher)
hash hash, inspect : String
inspect(io : IO) : Nil inspect, itself itself, not_nil! not_nil!, pretty_inspect(width = 79, newline = "\n", indent = 0) : String pretty_inspect, pretty_print(pp : PrettyPrint) : Nil pretty_print, tap(&) tap, to_json(io : IO)
to_json to_json, to_pretty_json(indent : String = " ")
to_pretty_json(io : IO, indent : String = " ") to_pretty_json, to_s : String
to_s(io : IO) : Nil to_s, to_yaml(io : IO)
to_yaml to_yaml, try(&) try, unsafe_as(type : T.class) forall T unsafe_as

### Class methods inherited from class `Object`

from_json(string_or_io, root : String)
from_json(string_or_io) from_json, from_yaml(string_or_io : String | IO) from_yaml

##
Instance Method Detail

def abrt? #
def alrm? #
def bus? #
def chld? #
def cont? #
def fpe? #
def hup? #
def ignore : Nil #

Clears the handler for this signal and prevents the OS default action.

Note that trying to ignore `CHLD` will actually set the default crystal handler that monitors and reaps child processes. This prevents zombie processes and is required by `Process#wait` for example.

def ill? #
def int? #
def io? #
def iot? #
def kill? #
def pipe? #
def pwr? #
def quit? #
def reset : Nil #

Resets the handler for this signal to the OS default.

Note that trying to reset `CHLD` will actually set the default crystal handler that monitors and reaps child processes. This prevents zombie processes and is required by `Process#wait` for example.

def segv? #
def stkflt? #
def stop? #
def sys? #
def term? #
def trap(&handler : Signal -> ) : Nil #

Sets the handler for this signal to the passed function.

After executing this, whenever the current process receives the corresponding signal, the passed function will be called (instead of the OS default). The handler will run in a signal-safe fiber thought the event loop; there is no limit to what functions can be called, unlike raw signals that run on the sigaltstack.

Note that `CHLD` is always trapped and child processes will always be reaped before the custom handler is called, hence a custom `CHLD` handler must check child processes using `Process.exists?`. Trying to use waitpid with a zero or negative value won't work.

def trap? #
def tstp? #
def ttin? #
def ttou? #
def unused? #
def urg? #
def usr1? #
def usr2? #
def vtalrm? #
def winch? #
def xcpu? #
def xfsz? #