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
141
142
143
144
145
146
147
148
149
150

use super::
{
  Failure,
  Pointer,
  Success,
  Syscall,
  super::io::
  {
    Flags,
    Mode,
    RawFd,
  },
};

impl          Syscall
{
  /// Safeish wrapper for `Read`.
  /// Read from `count` bytes from file descriptor `file` into `buffer`.
  ///
  /// # Errors
  /// Fails if result is negativ.
  ///
  /// # Safety
  /// Assuming this `Syscall` exists on this machine,
  ///   is conforming to the standard and
  ///   the `buffer` is large enough,
  ///     this wrapper is safe.
  ///
  /// # Examples
  /// Read 16 bytes from Standard Input to `buffer`:
  /// ```rust
  ///   let buffer = [u8;16];
  ///   let length = Syscall::read(fs::STDIN, &buffer, buffer.len());
  /// ```
  #[inline(always)]
  pub fn        read                    < T >
  (
    file:                               RawFd,
    buffer:                             T,
    count:                              usize,
  )
  ->  Result
      <
        Success,
        Failure,
      >
  where
    T:  Pointer,
  {
    unsafe
    {
      Syscall::Read
      .call3
      (
        file as usize,
        buffer,
        count,
      )
    }
  }

  /// Safeish wrapper for `Write`.
  /// Write `count` bytes from `buffer` to file descriptor `file`.
  ///
  /// # Errors
  /// Fails if result is negativ.
  ///
  /// # Safety
  /// Assuming this `Syscall` exists on this machine,
  ///   is conforming to the standard and
  ///   the `buffer` is large enough,
  ///     this wrapper is safe.
  ///
  /// # Examples
  /// Write »Hello World« to Standard Output:
  /// ```rust
  ///   let buffer = "HelloWorld\n";
  ///   let length = Syscall::write(fs::STDOUT, &buffer, buffer.len());
  /// ```
  #[inline(always)]
  pub fn        write                   < T >
  (
    file:                               RawFd,
    buffer:                             T,
    count:                              usize,
  )
  ->  Result
      <
        Success,
        Failure,
      >
  where
    T:  Pointer,
  {
    unsafe
    {
      Syscall::Write
      .call3
      (
        file as usize,
        buffer,
        count,
      )
    }
  }

  /// Safeish wrapper for `Open`.
  /// Open and possibly create the file `pathName` with given `flags`.
  /// Set permissions to `mode` if creating the file.
  ///
  /// # Errors
  /// Fails if result is negativ.
  ///
  /// # Safety
  /// Assuming this `Syscall` exists on this machine,
  ///   is conforming to the standard and
  ///   the `pathName` is null-terminated,
  ///     this wrapper is safe.
  ///
  /// # Examples
  /// Read 16 bytes from Standard Input to `buffer`:
  /// ```rust
  ///   let buffer = [u8;16];
  ///   let length = Syscall::read(fs::STDIN, &buffer, buffer.len());
  /// ```
  #[inline(always)]
  pub fn        open
  (
    pathName:                           &str,
    flags:                              Flags,
    mode:                               Mode,
  )
  ->  Result
      <
        Success,
        Failure,
      >
  {
    unsafe
    {
      Syscall::Open
      .call3
      (
        pathName,
        flags,
        mode,
      )
    }
  }
}