tbeu/matio | Build 1088 | src/safe-math.h | Coveralls - Test Coverage History & Statistics

1

/* Overflow-safe math functions

2

 * Portable Snippets - https://github.com/nemequ/portable-snippets

3

 * Created by Evan Nemerson <evan@nemerson.com>

4

5

 *   To the extent possible under law, the authors have waived all

6

 *   copyright and related or neighboring rights to this code.  For

7

 *   details, see the Creative Commons Zero 1.0 Universal license at

8

 *   https://creativecommons.org/publicdomain/zero/1.0/

9

*/

10

11

#if !defined(PSNIP_SAFE_H)

12

#define PSNIP_SAFE_H

13

14

#if !defined(PSNIP_SAFE_FORCE_PORTABLE)

15

#  if defined(__has_builtin)

16

#    if __has_builtin(__builtin_add_overflow) && !defined(__ibmxl__)

17

#      define PSNIP_SAFE_HAVE_BUILTIN_OVERFLOW

18

#    endif

19

#  elif defined(__GNUC__) && (__GNUC__ >= 5) && !defined(__INTEL_COMPILER)

20

#    define PSNIP_SAFE_HAVE_BUILTIN_OVERFLOW

21

#  endif

22

#  if defined(HAVE_INTSAFE_H)

23

#    define PSNIP_SAFE_HAVE_INTSAFE_H

24

#  elif defined(__has_include)

25

#    if __has_include(<intsafe.h>)

26

#      define PSNIP_SAFE_HAVE_INTSAFE_H

27

#    endif

28

#  elif defined(_MSC_VER) && _MSC_VER >= 1600

29

#    define PSNIP_SAFE_HAVE_INTSAFE_H

30

#  elif defined(__CYGWIN__) && defined(__GNUC__) && __GNUC__ >= 5

31

#    define PSNIP_SAFE_HAVE_INTSAFE_H

32

#  endif

33

#endif /* !defined(PSNIP_SAFE_FORCE_PORTABLE) */

34

35

#if defined(__GNUC__)

36

#  define PSNIP_SAFE_LIKELY(expr)   __builtin_expect(!!(expr), 1)

37

#  define PSNIP_SAFE_UNLIKELY(expr) __builtin_expect(!!(expr), 0)

38

#else

39

#  define PSNIP_SAFE_LIKELY(expr) !!(expr)

40

#  define PSNIP_SAFE_UNLIKELY(expr) !!(expr)

41

#endif /* defined(__GNUC__) */

42

43

#if !defined(PSNIP_SAFE_STATIC_INLINE)

44

#  if defined(__GNUC__)

45

#    define PSNIP_SAFE__COMPILER_ATTRIBUTES __attribute__((__unused__))

46

#  else

47

#    define PSNIP_SAFE__COMPILER_ATTRIBUTES

48

#  endif

49

50

#  if defined(HEDLEY_INLINE)

51

#    define PSNIP_SAFE__INLINE HEDLEY_INLINE

52

#  elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L

53

#    define PSNIP_SAFE__INLINE inline

54

#  elif defined(__GNUC_STDC_INLINE__)

55

#    define PSNIP_SAFE__INLINE __inline__

56

#  elif defined(_MSC_VER) && _MSC_VER >= 1200

57

#    define PSNIP_SAFE__INLINE __inline

58

#  else

59

#    define PSNIP_SAFE__INLINE

60

#  endif

61

62

#  define PSNIP_SAFE__FUNCTION PSNIP_SAFE__COMPILER_ATTRIBUTES static PSNIP_SAFE__INLINE

63

#endif

64

65

#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L

66

#  define psnip_safe_bool _Bool

67

#else

68

#  define psnip_safe_bool int

69

#endif

70

71

#if !defined(PSNIP_SAFE_NO_FIXED)

72

/* For maximum portability include the exact-int module from

73

   portable snippets. */

74

#  if \

75

    !defined(psnip_int64_t) || !defined(psnip_uint64_t) || \

76

    !defined(psnip_int32_t) || !defined(psnip_uint32_t) || \

77

    !defined(psnip_int16_t) || !defined(psnip_uint16_t) || \

78

    !defined(psnip_int8_t)  || !defined(psnip_uint8_t)

79

#    include <stdint.h>

80

#    if !defined(psnip_int64_t)

81

#      define psnip_int64_t int64_t

82

#    endif

83

#    if !defined(psnip_uint64_t)

84

#      define psnip_uint64_t uint64_t

85

#    endif

86

#    if !defined(psnip_int32_t)

87

#      define psnip_int32_t int32_t

88

#    endif

89

#    if !defined(psnip_uint32_t)

90

#      define psnip_uint32_t uint32_t

91

#    endif

92

#    if !defined(psnip_int16_t)

93

#      define psnip_int16_t int16_t

94

#    endif

95

#    if !defined(psnip_uint16_t)

96

#      define psnip_uint16_t uint16_t

97

#    endif

98

#    if !defined(psnip_int8_t)

99

#      define psnip_int8_t int8_t

100

#    endif

101

#    if !defined(psnip_uint8_t)

102

#      define psnip_uint8_t uint8_t

103

#    endif

104

#  endif

105

#endif /* !defined(PSNIP_SAFE_NO_FIXED) */

106

#include <limits.h>

107

#include <stdlib.h>

108

109

#if !defined(PSNIP_SAFE_SIZE_MAX)

110

#  if defined(__SIZE_MAX__)

111

#    define PSNIP_SAFE_SIZE_MAX __SIZE_MAX__

112

#  elif defined(PSNIP_EXACT_INT_HAVE_STDINT)

113

#    include <stdint.h>

114

#  endif

115

#endif

116

117

#if defined(PSNIP_SAFE_SIZE_MAX)

118

#  define PSNIP_SAFE__SIZE_MAX_RT PSNIP_SAFE_SIZE_MAX

119

#else

120

#  define PSNIP_SAFE__SIZE_MAX_RT (~((size_t) 0))

121

#endif

122

123

#if defined(PSNIP_SAFE_HAVE_INTSAFE_H)

124

/* In VS 10, stdint.h and intsafe.h both define (U)INTN_MIN/MAX, which

125

   triggers warning C4005 (level 1). */

126

#  if defined(_MSC_VER) && (_MSC_VER == 1600)

127

#    pragma warning(push)

128

#    pragma warning(disable:4005)

129

#  endif

130

#  include <intsafe.h>

131

#  if defined(_MSC_VER) && (_MSC_VER == 1600)

132

#    pragma warning(pop)

133

#  endif

134

#endif /* defined(PSNIP_SAFE_HAVE_INTSAFE_H) */

135

136

/* If there is a type larger than the one we're concerned with it's

137

 * likely much faster to simply promote the operands, perform the

138

 * requested operation, verify that the result falls within the

139

 * original type, then cast the result back to the original type. */

140

141

#if !defined(PSNIP_SAFE_NO_PROMOTIONS)

142

143

#define PSNIP_SAFE_DEFINE_LARGER_BINARY_OP(T, name, op_name, op) \

144

  PSNIP_SAFE__FUNCTION psnip_safe_##name##_larger \

145

  psnip_safe_larger_##name##_##op_name (T a, T b) { \

146

    return ((psnip_safe_##name##_larger) a) op ((psnip_safe_##name##_larger) b); \

147

148

149

#define PSNIP_SAFE_DEFINE_LARGER_UNARY_OP(T, name, op_name, op) \

150

  PSNIP_SAFE__FUNCTION psnip_safe_##name##_larger \

151

  psnip_safe_larger_##name##_##op_name (T value) { \

152

    return (op ((psnip_safe_##name##_larger) value)); \

153

154

155

#define PSNIP_SAFE_DEFINE_LARGER_SIGNED_OPS(T, name) \

156

  PSNIP_SAFE_DEFINE_LARGER_BINARY_OP(T, name, add, +) \

157

  PSNIP_SAFE_DEFINE_LARGER_BINARY_OP(T, name, sub, -) \

158

  PSNIP_SAFE_DEFINE_LARGER_BINARY_OP(T, name, mul, *) \

159

  PSNIP_SAFE_DEFINE_LARGER_BINARY_OP(T, name, div, /) \

160

  PSNIP_SAFE_DEFINE_LARGER_BINARY_OP(T, name, mod, %) \

161

  PSNIP_SAFE_DEFINE_LARGER_UNARY_OP (T, name, neg, -)

162

163

#define PSNIP_SAFE_DEFINE_LARGER_UNSIGNED_OPS(T, name) \

164

  PSNIP_SAFE_DEFINE_LARGER_BINARY_OP(T, name, add, +) \

165

  PSNIP_SAFE_DEFINE_LARGER_BINARY_OP(T, name, sub, -) \

166

  PSNIP_SAFE_DEFINE_LARGER_BINARY_OP(T, name, mul, *) \

167

  PSNIP_SAFE_DEFINE_LARGER_BINARY_OP(T, name, div, /) \

168

  PSNIP_SAFE_DEFINE_LARGER_BINARY_OP(T, name, mod, %)

169

170

#define PSNIP_SAFE_IS_LARGER(ORIG_MAX, DEST_MAX) ((DEST_MAX / ORIG_MAX) >= ORIG_MAX)

171

172

#if defined(__GNUC__) && ((__GNUC__ >= 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && defined(__SIZEOF_INT128__) && !defined(__ibmxl__)

173

#define PSNIP_SAFE_HAVE_128

174

#pragma GCC diagnostic push

175

#pragma GCC diagnostic ignored "-Wpedantic"

176

typedef __int128  psnip_safe_int128_t;

177

typedef unsigned __int128 psnip_safe_uint128_t;

178

#pragma GCC diagnostic pop

179

#endif /* defined(__GNUC__) */

180

181

#if !defined(PSNIP_SAFE_NO_FIXED)

182

#define PSNIP_SAFE_HAVE_INT8_LARGER

183

#define PSNIP_SAFE_HAVE_UINT8_LARGER

184

typedef psnip_int16_t  psnip_safe_int8_larger;

185

typedef psnip_uint16_t psnip_safe_uint8_larger;

186

187

#define PSNIP_SAFE_HAVE_INT16_LARGER

188

typedef psnip_int32_t  psnip_safe_int16_larger;

189

typedef psnip_uint32_t psnip_safe_uint16_larger;

190

191

#define PSNIP_SAFE_HAVE_INT32_LARGER

192

typedef psnip_int64_t  psnip_safe_int32_larger;

193

typedef psnip_uint64_t psnip_safe_uint32_larger;

194

195

#if defined(PSNIP_SAFE_HAVE_128)

196

#define PSNIP_SAFE_HAVE_INT64_LARGER

197

typedef psnip_safe_int128_t psnip_safe_int64_larger;

198

typedef psnip_safe_uint128_t psnip_safe_uint64_larger;

199

#endif /* defined(PSNIP_SAFE_HAVE_128) */

200

#endif /* !defined(PSNIP_SAFE_NO_FIXED) */

201

202

#define PSNIP_SAFE_HAVE_LARGER_SCHAR

203

#if PSNIP_SAFE_IS_LARGER(SCHAR_MAX, SHRT_MAX)

204

typedef short psnip_safe_schar_larger;

205

#elif PSNIP_SAFE_IS_LARGER(SCHAR_MAX, INT_MAX)

206

typedef int psnip_safe_schar_larger;

207

#elif PSNIP_SAFE_IS_LARGER(SCHAR_MAX, LONG_MAX)

208

typedef long psnip_safe_schar_larger;

209

#elif PSNIP_SAFE_IS_LARGER(SCHAR_MAX, LLONG_MAX)

210

typedef long long psnip_safe_schar_larger;

211

#elif !defined(PSNIP_SAFE_NO_FIXED) && PSNIP_SAFE_IS_LARGER(SCHAR_MAX, 0x7fff)

212

typedef psnip_int16_t psnip_safe_schar_larger;

213

#elif !defined(PSNIP_SAFE_NO_FIXED) && PSNIP_SAFE_IS_LARGER(SCHAR_MAX, 0x7fffffffLL)

214

typedef psnip_int32_t psnip_safe_schar_larger;

215

#elif !defined(PSNIP_SAFE_NO_FIXED) && PSNIP_SAFE_IS_LARGER(SCHAR_MAX, 0x7fffffffffffffffLL)

216

typedef psnip_int64_t psnip_safe_schar_larger;

217

#elif !defined(PSNIP_SAFE_NO_FIXED) && defined(PSNIP_SAFE_HAVE_128) && (SCHAR_MAX <= 0x7fffffffffffffffLL)

218

typedef psnip_safe_int128_t psnip_safe_schar_larger;

219

#else

220

#undef PSNIP_SAFE_HAVE_LARGER_SCHAR

221

#endif

222

223

#define PSNIP_SAFE_HAVE_LARGER_UCHAR

224

#if PSNIP_SAFE_IS_LARGER(UCHAR_MAX, USHRT_MAX)

225

typedef unsigned short psnip_safe_uchar_larger;

226

#elif PSNIP_SAFE_IS_LARGER(UCHAR_MAX, UINT_MAX)

227

typedef unsigned int psnip_safe_uchar_larger;

228

#elif PSNIP_SAFE_IS_LARGER(UCHAR_MAX, ULONG_MAX)

229

typedef unsigned long psnip_safe_uchar_larger;

230

#elif PSNIP_SAFE_IS_LARGER(UCHAR_MAX, ULLONG_MAX)

231

typedef unsigned long long psnip_safe_uchar_larger;

232

#elif !defined(PSNIP_SAFE_NO_FIXED) && PSNIP_SAFE_IS_LARGER(UCHAR_MAX, 0xffffU)

233

typedef psnip_uint16_t psnip_safe_uchar_larger;

234

#elif !defined(PSNIP_SAFE_NO_FIXED) && PSNIP_SAFE_IS_LARGER(UCHAR_MAX, 0xffffffffUL)

235

typedef psnip_uint32_t psnip_safe_uchar_larger;

236

#elif !defined(PSNIP_SAFE_NO_FIXED) && PSNIP_SAFE_IS_LARGER(UCHAR_MAX, 0xffffffffffffffffULL)

237

typedef psnip_uint64_t psnip_safe_uchar_larger;

238

#elif !defined(PSNIP_SAFE_NO_FIXED) && defined(PSNIP_SAFE_HAVE_128) && (UCHAR_MAX <= 0xffffffffffffffffULL)

239

typedef psnip_safe_uint128_t psnip_safe_uchar_larger;

240

#else

241

#undef PSNIP_SAFE_HAVE_LARGER_UCHAR

242

#endif

243

244

#if CHAR_MIN == 0 && defined(PSNIP_SAFE_HAVE_LARGER_UCHAR)

245

#define PSNIP_SAFE_HAVE_LARGER_CHAR

246

typedef psnip_safe_uchar_larger psnip_safe_char_larger;

247

#elif CHAR_MIN < 0 && defined(PSNIP_SAFE_HAVE_LARGER_SCHAR)

248

#define PSNIP_SAFE_HAVE_LARGER_CHAR

249

typedef psnip_safe_schar_larger psnip_safe_char_larger;

250

#endif

251

252

#define PSNIP_SAFE_HAVE_LARGER_SHRT

253

#if PSNIP_SAFE_IS_LARGER(SHRT_MAX, INT_MAX)

254

typedef int psnip_safe_short_larger;

255

#elif PSNIP_SAFE_IS_LARGER(SHRT_MAX, LONG_MAX)

256

typedef long psnip_safe_short_larger;

257

#elif PSNIP_SAFE_IS_LARGER(SHRT_MAX, LLONG_MAX)

258

typedef long long psnip_safe_short_larger;

259

#elif !defined(PSNIP_SAFE_NO_FIXED) && PSNIP_SAFE_IS_LARGER(SHRT_MAX, 0x7fff)

260

typedef psnip_int16_t psnip_safe_short_larger;

261

#elif !defined(PSNIP_SAFE_NO_FIXED) && PSNIP_SAFE_IS_LARGER(SHRT_MAX, 0x7fffffffLL)

262

typedef psnip_int32_t psnip_safe_short_larger;

263

#elif !defined(PSNIP_SAFE_NO_FIXED) && PSNIP_SAFE_IS_LARGER(SHRT_MAX, 0x7fffffffffffffffLL)

264

typedef psnip_int64_t psnip_safe_short_larger;

265

#elif !defined(PSNIP_SAFE_NO_FIXED) && defined(PSNIP_SAFE_HAVE_128) && (SHRT_MAX <= 0x7fffffffffffffffLL)

266

typedef psnip_safe_int128_t psnip_safe_short_larger;

267

#else

268

#undef PSNIP_SAFE_HAVE_LARGER_SHRT

269

#endif

270

271

#define PSNIP_SAFE_HAVE_LARGER_USHRT

272

#if PSNIP_SAFE_IS_LARGER(USHRT_MAX, UINT_MAX)

273

typedef unsigned int psnip_safe_ushort_larger;

274

#elif PSNIP_SAFE_IS_LARGER(USHRT_MAX, ULONG_MAX)

275

typedef unsigned long psnip_safe_ushort_larger;

276

#elif PSNIP_SAFE_IS_LARGER(USHRT_MAX, ULLONG_MAX)

277

typedef unsigned long long psnip_safe_ushort_larger;

278

#elif !defined(PSNIP_SAFE_NO_FIXED) && PSNIP_SAFE_IS_LARGER(USHRT_MAX, 0xffff)

279

typedef psnip_uint16_t psnip_safe_ushort_larger;

280

#elif !defined(PSNIP_SAFE_NO_FIXED) && PSNIP_SAFE_IS_LARGER(USHRT_MAX, 0xffffffffUL)

281

typedef psnip_uint32_t psnip_safe_ushort_larger;

282

#elif !defined(PSNIP_SAFE_NO_FIXED) && PSNIP_SAFE_IS_LARGER(USHRT_MAX, 0xffffffffffffffffULL)

283

typedef psnip_uint64_t psnip_safe_ushort_larger;

284

#elif !defined(PSNIP_SAFE_NO_FIXED) && defined(PSNIP_SAFE_HAVE_128) && (USHRT_MAX <= 0xffffffffffffffffULL)

285

typedef psnip_safe_uint128_t psnip_safe_ushort_larger;

286

#else

287

#undef PSNIP_SAFE_HAVE_LARGER_USHRT

288

#endif

289

290

#define PSNIP_SAFE_HAVE_LARGER_INT

291

#if PSNIP_SAFE_IS_LARGER(INT_MAX, LONG_MAX)

292

typedef long psnip_safe_int_larger;

293

#elif PSNIP_SAFE_IS_LARGER(INT_MAX, LLONG_MAX)

294

typedef long long psnip_safe_int_larger;

295

#elif !defined(PSNIP_SAFE_NO_FIXED) && PSNIP_SAFE_IS_LARGER(INT_MAX, 0x7fff)

296

typedef psnip_int16_t psnip_safe_int_larger;

297

#elif !defined(PSNIP_SAFE_NO_FIXED) && PSNIP_SAFE_IS_LARGER(INT_MAX, 0x7fffffffLL)

298

typedef psnip_int32_t psnip_safe_int_larger;

299

#elif !defined(PSNIP_SAFE_NO_FIXED) && PSNIP_SAFE_IS_LARGER(INT_MAX, 0x7fffffffffffffffLL)

300

typedef psnip_int64_t psnip_safe_int_larger;

301

#elif !defined(PSNIP_SAFE_NO_FIXED) && defined(PSNIP_SAFE_HAVE_128) && (INT_MAX <= 0x7fffffffffffffffLL)

302

typedef psnip_safe_int128_t psnip_safe_int_larger;

303

#else

304

#undef PSNIP_SAFE_HAVE_LARGER_INT

305

#endif

306

307

#define PSNIP_SAFE_HAVE_LARGER_UINT

308

#if PSNIP_SAFE_IS_LARGER(UINT_MAX, ULONG_MAX)

309

typedef unsigned long psnip_safe_uint_larger;

310

#elif PSNIP_SAFE_IS_LARGER(UINT_MAX, ULLONG_MAX)

311

typedef unsigned long long psnip_safe_uint_larger;

312

#elif !defined(PSNIP_SAFE_NO_FIXED) && PSNIP_SAFE_IS_LARGER(UINT_MAX, 0xffff)

313

typedef psnip_uint16_t psnip_safe_uint_larger;

314

#elif !defined(PSNIP_SAFE_NO_FIXED) && PSNIP_SAFE_IS_LARGER(UINT_MAX, 0xffffffffUL)

315

typedef psnip_uint32_t psnip_safe_uint_larger;

316

#elif !defined(PSNIP_SAFE_NO_FIXED) && PSNIP_SAFE_IS_LARGER(UINT_MAX, 0xffffffffffffffffULL)

317

typedef psnip_uint64_t psnip_safe_uint_larger;

318

#elif !defined(PSNIP_SAFE_NO_FIXED) && defined(PSNIP_SAFE_HAVE_128) && (UINT_MAX <= 0xffffffffffffffffULL)

319

typedef psnip_safe_uint128_t psnip_safe_uint_larger;

320

#else

321

#undef PSNIP_SAFE_HAVE_LARGER_UINT

322

#endif

323

324

#define PSNIP_SAFE_HAVE_LARGER_LONG

325

#if PSNIP_SAFE_IS_LARGER(LONG_MAX, LLONG_MAX)

326

typedef long long psnip_safe_long_larger;

327

#elif !defined(PSNIP_SAFE_NO_FIXED) && PSNIP_SAFE_IS_LARGER(LONG_MAX, 0x7fff)

328

typedef psnip_int16_t psnip_safe_long_larger;

329

#elif !defined(PSNIP_SAFE_NO_FIXED) && PSNIP_SAFE_IS_LARGER(LONG_MAX, 0x7fffffffLL)

330

typedef psnip_int32_t psnip_safe_long_larger;

331

#elif !defined(PSNIP_SAFE_NO_FIXED) && PSNIP_SAFE_IS_LARGER(LONG_MAX, 0x7fffffffffffffffLL)

332

typedef psnip_int64_t psnip_safe_long_larger;

333

#elif !defined(PSNIP_SAFE_NO_FIXED) && defined(PSNIP_SAFE_HAVE_128) && (LONG_MAX <= 0x7fffffffffffffffLL)

334

typedef psnip_safe_int128_t psnip_safe_long_larger;

335

#else

336

#undef PSNIP_SAFE_HAVE_LARGER_LONG

337

#endif

338

339

#define PSNIP_SAFE_HAVE_LARGER_ULONG

340

#if PSNIP_SAFE_IS_LARGER(ULONG_MAX, ULLONG_MAX)

341

typedef unsigned long long psnip_safe_ulong_larger;

342

#elif !defined(PSNIP_SAFE_NO_FIXED) && PSNIP_SAFE_IS_LARGER(ULONG_MAX, 0xffff)

343

typedef psnip_uint16_t psnip_safe_ulong_larger;

344

#elif !defined(PSNIP_SAFE_NO_FIXED) && PSNIP_SAFE_IS_LARGER(ULONG_MAX, 0xffffffffUL)

345

typedef psnip_uint32_t psnip_safe_ulong_larger;

346

#elif !defined(PSNIP_SAFE_NO_FIXED) && PSNIP_SAFE_IS_LARGER(ULONG_MAX, 0xffffffffffffffffULL)

347

typedef psnip_uint64_t psnip_safe_ulong_larger;

348

#elif !defined(PSNIP_SAFE_NO_FIXED) && defined(PSNIP_SAFE_HAVE_128) && (ULONG_MAX <= 0xffffffffffffffffULL)

349

typedef psnip_safe_uint128_t psnip_safe_ulong_larger;

350

#else

351

#undef PSNIP_SAFE_HAVE_LARGER_ULONG

352

#endif

353

354

#define PSNIP_SAFE_HAVE_LARGER_LLONG

355

#if !defined(PSNIP_SAFE_NO_FIXED) && PSNIP_SAFE_IS_LARGER(LLONG_MAX, 0x7fff)

356

typedef psnip_int16_t psnip_safe_llong_larger;

357

#elif !defined(PSNIP_SAFE_NO_FIXED) && PSNIP_SAFE_IS_LARGER(LLONG_MAX, 0x7fffffffLL)

358

typedef psnip_int32_t psnip_safe_llong_larger;

359

#elif !defined(PSNIP_SAFE_NO_FIXED) && PSNIP_SAFE_IS_LARGER(LLONG_MAX, 0x7fffffffffffffffLL)

360

typedef psnip_int64_t psnip_safe_llong_larger;

361

#elif !defined(PSNIP_SAFE_NO_FIXED) && defined(PSNIP_SAFE_HAVE_128) && (LLONG_MAX <= 0x7fffffffffffffffLL)

362

typedef psnip_safe_int128_t psnip_safe_llong_larger;

363

#else

364

#undef PSNIP_SAFE_HAVE_LARGER_LLONG

365

#endif

366

367

#define PSNIP_SAFE_HAVE_LARGER_ULLONG

368

#if !defined(PSNIP_SAFE_NO_FIXED) && PSNIP_SAFE_IS_LARGER(ULLONG_MAX, 0xffff)

369

typedef psnip_uint16_t psnip_safe_ullong_larger;

370

#elif !defined(PSNIP_SAFE_NO_FIXED) && PSNIP_SAFE_IS_LARGER(ULLONG_MAX, 0xffffffffUL)

371

typedef psnip_uint32_t psnip_safe_ullong_larger;

372

#elif !defined(PSNIP_SAFE_NO_FIXED) && PSNIP_SAFE_IS_LARGER(ULLONG_MAX, 0xffffffffffffffffULL)

373

typedef psnip_uint64_t psnip_safe_ullong_larger;

374

#elif !defined(PSNIP_SAFE_NO_FIXED) && defined(PSNIP_SAFE_HAVE_128) && (ULLONG_MAX <= 0xffffffffffffffffULL)

375

typedef psnip_safe_uint128_t psnip_safe_ullong_larger;

376

#else

377

#undef PSNIP_SAFE_HAVE_LARGER_ULLONG

378

#endif

379

380

#if defined(PSNIP_SAFE_SIZE_MAX)

381

#define PSNIP_SAFE_HAVE_LARGER_SIZE

382

#if PSNIP_SAFE_IS_LARGER(PSNIP_SAFE_SIZE_MAX, USHRT_MAX)

383

typedef unsigned short psnip_safe_size_larger;

384

#elif PSNIP_SAFE_IS_LARGER(PSNIP_SAFE_SIZE_MAX, UINT_MAX)

385

typedef unsigned int psnip_safe_size_larger;

386

#elif PSNIP_SAFE_IS_LARGER(PSNIP_SAFE_SIZE_MAX, ULONG_MAX)

387

typedef unsigned long psnip_safe_size_larger;

388

#elif PSNIP_SAFE_IS_LARGER(PSNIP_SAFE_SIZE_MAX, ULLONG_MAX)

389

typedef unsigned long long psnip_safe_size_larger;

390

#elif !defined(PSNIP_SAFE_NO_FIXED) && PSNIP_SAFE_IS_LARGER(PSNIP_SAFE_SIZE_MAX, 0xffff)

391

typedef psnip_uint16_t psnip_safe_size_larger;

392

#elif !defined(PSNIP_SAFE_NO_FIXED) && PSNIP_SAFE_IS_LARGER(PSNIP_SAFE_SIZE_MAX, 0xffffffffUL)

393

typedef psnip_uint32_t psnip_safe_size_larger;

394

#elif !defined(PSNIP_SAFE_NO_FIXED) && PSNIP_SAFE_IS_LARGER(PSNIP_SAFE_SIZE_MAX, 0xffffffffffffffffULL)

395

typedef psnip_uint64_t psnip_safe_size_larger;

396

#elif !defined(PSNIP_SAFE_NO_FIXED) && defined(PSNIP_SAFE_HAVE_128) && (PSNIP_SAFE_SIZE_MAX <= 0xffffffffffffffffULL)

397

typedef psnip_safe_uint128_t psnip_safe_size_larger;

398

#else

399

#undef PSNIP_SAFE_HAVE_LARGER_SIZE

400

#endif

401

#endif

402

403

#if defined(PSNIP_SAFE_HAVE_LARGER_SCHAR)

404

PSNIP_SAFE_DEFINE_LARGER_SIGNED_OPS(signed char, schar)

405

#endif

406

407

#if defined(PSNIP_SAFE_HAVE_LARGER_UCHAR)

408

PSNIP_SAFE_DEFINE_LARGER_UNSIGNED_OPS(unsigned char, uchar)

409

#endif

410

411

#if defined(PSNIP_SAFE_HAVE_LARGER_CHAR)

412

#if CHAR_MIN == 0

413

PSNIP_SAFE_DEFINE_LARGER_UNSIGNED_OPS(char, char)

414

#else

415

PSNIP_SAFE_DEFINE_LARGER_SIGNED_OPS(char, char)

416

#endif

417

#endif

418

419

#if defined(PSNIP_SAFE_HAVE_LARGER_SHORT)

420

PSNIP_SAFE_DEFINE_LARGER_SIGNED_OPS(short, short)

421

#endif

422

423

#if defined(PSNIP_SAFE_HAVE_LARGER_USHORT)

424

PSNIP_SAFE_DEFINE_LARGER_UNSIGNED_OPS(unsigned short, ushort)

425

#endif

426

427

#if defined(PSNIP_SAFE_HAVE_LARGER_INT)

428

PSNIP_SAFE_DEFINE_LARGER_SIGNED_OPS(int, int)

429

#endif

430

431

#if defined(PSNIP_SAFE_HAVE_LARGER_UINT)

432

PSNIP_SAFE_DEFINE_LARGER_UNSIGNED_OPS(unsigned int, uint)

433

#endif

434

435

#if defined(PSNIP_SAFE_HAVE_LARGER_LONG)

436

PSNIP_SAFE_DEFINE_LARGER_SIGNED_OPS(long, long)

437

#endif

438

439

#if defined(PSNIP_SAFE_HAVE_LARGER_ULONG)

440

PSNIP_SAFE_DEFINE_LARGER_UNSIGNED_OPS(unsigned long, ulong)

441

#endif

442

443

#if defined(PSNIP_SAFE_HAVE_LARGER_LLONG)

444

PSNIP_SAFE_DEFINE_LARGER_SIGNED_OPS(long long, llong)

445

#endif

446

447

#if defined(PSNIP_SAFE_HAVE_LARGER_ULLONG)

448

PSNIP_SAFE_DEFINE_LARGER_UNSIGNED_OPS(unsigned long long, ullong)

449

#endif

450

451

#if defined(PSNIP_SAFE_HAVE_LARGER_SIZE)

452

PSNIP_SAFE_DEFINE_LARGER_UNSIGNED_OPS(size_t, size)

453

#endif

454

455

#if !defined(PSNIP_SAFE_NO_FIXED)

456

PSNIP_SAFE_DEFINE_LARGER_SIGNED_OPS(psnip_int8_t,   int8)

457

PSNIP_SAFE_DEFINE_LARGER_UNSIGNED_OPS(psnip_uint8_t,  uint8)

458

PSNIP_SAFE_DEFINE_LARGER_SIGNED_OPS(psnip_int16_t,  int16)

459

PSNIP_SAFE_DEFINE_LARGER_UNSIGNED_OPS(psnip_uint16_t, uint16)

460

PSNIP_SAFE_DEFINE_LARGER_SIGNED_OPS(psnip_int32_t,  int32)

461

PSNIP_SAFE_DEFINE_LARGER_UNSIGNED_OPS(psnip_uint32_t, uint32)

462

#if defined(PSNIP_SAFE_HAVE_128)

463

PSNIP_SAFE_DEFINE_LARGER_SIGNED_OPS(psnip_int64_t,  int64)

464

PSNIP_SAFE_DEFINE_LARGER_UNSIGNED_OPS(psnip_uint64_t, uint64)

465

#endif

466

#endif

467

468

#endif /* !defined(PSNIP_SAFE_NO_PROMOTIONS) */

469

470

#define PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(T, name, op_name) \

471

  PSNIP_SAFE__FUNCTION psnip_safe_bool \

472

  psnip_safe_##name##_##op_name(T* res, T a, T b) { \

473

    return !__builtin_##op_name##_overflow(a, b, res); \

474

475

476

#define PSNIP_SAFE_DEFINE_PROMOTED_SIGNED_BINARY_OP(T, name, op_name, min, max) \

477

  PSNIP_SAFE__FUNCTION psnip_safe_bool \

478

  psnip_safe_##name##_##op_name(T* res, T a, T b) { \

479

    const psnip_safe_##name##_larger r = psnip_safe_larger_##name##_##op_name(a, b); \

480

    *res = (T) r; \

481

    return (r >= min) && (r <= max); \

482

483

484

#define PSNIP_SAFE_DEFINE_PROMOTED_UNSIGNED_BINARY_OP(T, name, op_name, max) \

485

  PSNIP_SAFE__FUNCTION psnip_safe_bool \

486

  psnip_safe_##name##_##op_name(T* res, T a, T b) { \

487

    const psnip_safe_##name##_larger r = psnip_safe_larger_##name##_##op_name(a, b); \

488

    *res = (T) r; \

489

    return (r <= max); \

490

491

492

#define PSNIP_SAFE_DEFINE_SIGNED_ADD(T, name, min, max) \

493

  PSNIP_SAFE__FUNCTION psnip_safe_bool \

494

  psnip_safe_##name##_add (T* res, T a, T b) { \

495

    psnip_safe_bool r = !( ((b > 0) && (a > (max - b))) ||   \

496

                 ((b < 0) && (a < (min - b))) ); \

497

    if(PSNIP_SAFE_LIKELY(r)) \

498

        *res = a + b; \

499

    return r; \

500

501

502

#define PSNIP_SAFE_DEFINE_UNSIGNED_ADD(T, name, max) \

503

  PSNIP_SAFE__FUNCTION psnip_safe_bool \

504

  psnip_safe_##name##_add (T* res, T a, T b) { \

505

    *res = (T) (a + b); \

506

    return !PSNIP_SAFE_UNLIKELY((b > 0) && (a > (max - b))); \

507

508

509

#define PSNIP_SAFE_DEFINE_SIGNED_SUB(T, name, min, max) \

510

  PSNIP_SAFE__FUNCTION psnip_safe_bool \

511

  psnip_safe_##name##_sub (T* res, T a, T b) { \

512

      psnip_safe_bool r = !((b > 0 && a < (min + b)) || \

513

                  (b < 0 && a > (max + b))); \

514

      if(PSNIP_SAFE_LIKELY(r)) \

515

          *res = a - b; \

516

      return r; \

517

518

519

#define PSNIP_SAFE_DEFINE_UNSIGNED_SUB(T, name, max) \

520

  PSNIP_SAFE__FUNCTION psnip_safe_bool \

521

  psnip_safe_##name##_sub (T* res, T a, T b) { \

522

      *res = a - b; \

523

      return !PSNIP_SAFE_UNLIKELY(b > a); \

524

525

526

#define PSNIP_SAFE_DEFINE_SIGNED_MUL(T, name, min, max) \

527

  PSNIP_SAFE__FUNCTION psnip_safe_bool \

528

  psnip_safe_##name##_mul (T* res, T a, T b) { \

529

    psnip_safe_bool r = 1;  \

530

    if (a > 0) { \

531

      if (b > 0) { \

532

        if (a > (max / b)) { \

533

          r = 0; \

534

} \

535

      } else { \

536

        if (b < (min / a)) { \

537

          r = 0; \

538

} \

539

} \

540

    } else { \

541

      if (b > 0) { \

542

        if (a < (min / b)) { \

543

          r = 0; \

544

} \

545

      } else { \

546

        if ( (a != 0) && (b < (max / a))) { \

547

          r = 0; \

548

} \

549

} \

550

} \

551

    if(PSNIP_SAFE_LIKELY(r)) \

552

        *res = a * b; \

553

    return r; \

554

555

556

#define PSNIP_SAFE_DEFINE_UNSIGNED_MUL(T, name, max) \

557

  PSNIP_SAFE__FUNCTION psnip_safe_bool \

558

  psnip_safe_##name##_mul (T* res, T a, T b) { \

559

    *res = (T) (a * b); \

560

    return !PSNIP_SAFE_UNLIKELY((a > 0) && (b > 0) && (a > (max / b))); \

561

562

563

#define PSNIP_SAFE_DEFINE_SIGNED_DIV(T, name, min, max)   \

564

  PSNIP_SAFE__FUNCTION psnip_safe_bool \

565

  psnip_safe_##name##_div (T* res, T a, T b) { \

566

    if (PSNIP_SAFE_UNLIKELY(b == 0)) { \

567

      *res = 0; \

568

      return 0; \

569

    } else if (PSNIP_SAFE_UNLIKELY(a == min && b == -1)) {    \

570

      *res = min; \

571

      return 0; \

572

    } else { \

573

      *res = (T) (a / b); \

574

      return 1; \

575

} \

576

577

578

#define PSNIP_SAFE_DEFINE_UNSIGNED_DIV(T, name, max) \

579

  PSNIP_SAFE__FUNCTION psnip_safe_bool \

580

  psnip_safe_##name##_div (T* res, T a, T b) { \

581

    if (PSNIP_SAFE_UNLIKELY(b == 0)) { \

582

      *res = 0; \

583

      return 0; \

584

    } else { \

585

      *res = a / b; \

586

      return 1; \

587

} \

588

589

590

#define PSNIP_SAFE_DEFINE_SIGNED_MOD(T, name, min, max) \

591

  PSNIP_SAFE__FUNCTION psnip_safe_bool \

592

  psnip_safe_##name##_mod (T* res, T a, T b) { \

593

    if (PSNIP_SAFE_UNLIKELY(b == 0)) { \

594

      *res = 0; \

595

      return 0; \

596

    } else if (PSNIP_SAFE_UNLIKELY(a == min && b == -1)) { \

597

      *res = min; \

598

      return 0; \

599

    } else { \

600

      *res = (T) (a % b); \

601

      return 1; \

602

} \

603

604

605

#define PSNIP_SAFE_DEFINE_UNSIGNED_MOD(T, name, max) \

606

  PSNIP_SAFE__FUNCTION psnip_safe_bool \

607

  psnip_safe_##name##_mod (T* res, T a, T b) { \

608

    if (PSNIP_SAFE_UNLIKELY(b == 0)) { \

609

      *res = 0; \

610

      return 0; \

611

    } else { \

612

      *res = a % b; \

613

      return 1; \

614

} \

615

616

617

#define PSNIP_SAFE_DEFINE_SIGNED_NEG(T, name, min, max) \

618

  PSNIP_SAFE__FUNCTION psnip_safe_bool \

619

  psnip_safe_##name##_neg (T* res, T value) { \

620

    psnip_safe_bool r = value != min; \

621

    *res = PSNIP_SAFE_LIKELY(r) ? -value : max; \

622

    return r; \

623

624

625

#define PSNIP_SAFE_DEFINE_INTSAFE(T, name, op, isf) \

626

  PSNIP_SAFE__FUNCTION psnip_safe_bool \

627

  psnip_safe_##name##_##op (T* res, T a, T b) { \

628

    return isf(a, b, res) == S_OK; \

629

630

631

#if CHAR_MIN == 0

632

#if defined(PSNIP_SAFE_HAVE_BUILTIN_OVERFLOW)

633

PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(char, char, add)

634

PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(char, char, sub)

635

PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(char, char, mul)

636

#elif defined(PSNIP_SAFE_HAVE_LARGER_CHAR)

637

PSNIP_SAFE_DEFINE_PROMOTED_UNSIGNED_BINARY_OP(char, char, add, CHAR_MAX)

638

PSNIP_SAFE_DEFINE_PROMOTED_UNSIGNED_BINARY_OP(char, char, sub, CHAR_MAX)

639

PSNIP_SAFE_DEFINE_PROMOTED_UNSIGNED_BINARY_OP(char, char, mul, CHAR_MAX)

640

#else

641

PSNIP_SAFE_DEFINE_UNSIGNED_ADD(char, char, CHAR_MAX)

642

PSNIP_SAFE_DEFINE_UNSIGNED_SUB(char, char, CHAR_MAX)

643

PSNIP_SAFE_DEFINE_UNSIGNED_MUL(char, char, CHAR_MAX)

644

#endif

645

PSNIP_SAFE_DEFINE_UNSIGNED_DIV(char, char, CHAR_MAX)

646

PSNIP_SAFE_DEFINE_UNSIGNED_MOD(char, char, CHAR_MAX)

647

#else /* CHAR_MIN != 0 */

648

#if defined(PSNIP_SAFE_HAVE_BUILTIN_OVERFLOW)

649

PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(char, char, add)

650

PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(char, char, sub)

651

PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(char, char, mul)

652

#elif defined(PSNIP_SAFE_HAVE_LARGER_CHAR)

653

PSNIP_SAFE_DEFINE_PROMOTED_SIGNED_BINARY_OP(char, char, add, CHAR_MIN, CHAR_MAX)

654

PSNIP_SAFE_DEFINE_PROMOTED_SIGNED_BINARY_OP(char, char, sub, CHAR_MIN, CHAR_MAX)

655

PSNIP_SAFE_DEFINE_PROMOTED_SIGNED_BINARY_OP(char, char, mul, CHAR_MIN, CHAR_MAX)

656

#else

657

PSNIP_SAFE_DEFINE_SIGNED_ADD(char, char, CHAR_MIN, CHAR_MAX)

658

PSNIP_SAFE_DEFINE_SIGNED_SUB(char, char, CHAR_MIN, CHAR_MAX)

659

PSNIP_SAFE_DEFINE_SIGNED_MUL(char, char, CHAR_MIN, CHAR_MAX)

660

#endif

661

PSNIP_SAFE_DEFINE_SIGNED_DIV(char, char, CHAR_MIN, CHAR_MAX)

662

PSNIP_SAFE_DEFINE_SIGNED_MOD(char, char, CHAR_MIN, CHAR_MAX)

663

PSNIP_SAFE_DEFINE_SIGNED_NEG(char, char, CHAR_MIN, CHAR_MAX)

664

#endif

665

666

#if defined(PSNIP_SAFE_HAVE_BUILTIN_OVERFLOW)

667

PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(signed char, schar, add)

668

PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(signed char, schar, sub)

669

PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(signed char, schar, mul)

670

#elif defined(PSNIP_SAFE_HAVE_LARGER_SCHAR)

671

PSNIP_SAFE_DEFINE_PROMOTED_SIGNED_BINARY_OP(signed char, schar, add, SCHAR_MIN, SCHAR_MAX)

672

PSNIP_SAFE_DEFINE_PROMOTED_SIGNED_BINARY_OP(signed char, schar, sub, SCHAR_MIN, SCHAR_MAX)

673

PSNIP_SAFE_DEFINE_PROMOTED_SIGNED_BINARY_OP(signed char, schar, mul, SCHAR_MIN, SCHAR_MAX)

674

#else

675

PSNIP_SAFE_DEFINE_SIGNED_ADD(signed char, schar, SCHAR_MIN, SCHAR_MAX)

676

PSNIP_SAFE_DEFINE_SIGNED_SUB(signed char, schar, SCHAR_MIN, SCHAR_MAX)

677

PSNIP_SAFE_DEFINE_SIGNED_MUL(signed char, schar, SCHAR_MIN, SCHAR_MAX)

678

#endif

679

PSNIP_SAFE_DEFINE_SIGNED_DIV(signed char, schar, SCHAR_MIN, SCHAR_MAX)

680

PSNIP_SAFE_DEFINE_SIGNED_MOD(signed char, schar, SCHAR_MIN, SCHAR_MAX)

681

PSNIP_SAFE_DEFINE_SIGNED_NEG(signed char, schar, SCHAR_MIN, SCHAR_MAX)

682

683

#if defined(PSNIP_SAFE_HAVE_BUILTIN_OVERFLOW)

684

PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(unsigned char, uchar, add)

685

PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(unsigned char, uchar, sub)

686

PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(unsigned char, uchar, mul)

687

#elif defined(PSNIP_SAFE_HAVE_LARGER_UCHAR)

688

PSNIP_SAFE_DEFINE_PROMOTED_UNSIGNED_BINARY_OP(unsigned char, uchar, add, UCHAR_MAX)

689

PSNIP_SAFE_DEFINE_PROMOTED_UNSIGNED_BINARY_OP(unsigned char, uchar, sub, UCHAR_MAX)

690

PSNIP_SAFE_DEFINE_PROMOTED_UNSIGNED_BINARY_OP(unsigned char, uchar, mul, UCHAR_MAX)

691

#else

692

PSNIP_SAFE_DEFINE_UNSIGNED_ADD(unsigned char, uchar, UCHAR_MAX)

693

PSNIP_SAFE_DEFINE_UNSIGNED_SUB(unsigned char, uchar, UCHAR_MAX)

694

PSNIP_SAFE_DEFINE_UNSIGNED_MUL(unsigned char, uchar, UCHAR_MAX)

695

#endif

696

PSNIP_SAFE_DEFINE_UNSIGNED_DIV(unsigned char, uchar, UCHAR_MAX)

697

PSNIP_SAFE_DEFINE_UNSIGNED_MOD(unsigned char, uchar, UCHAR_MAX)

698

699

#if defined(PSNIP_SAFE_HAVE_BUILTIN_OVERFLOW)

700

PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(short, short, add)

701

PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(short, short, sub)

702

PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(short, short, mul)

703

#elif defined(PSNIP_SAFE_HAVE_LARGER_SHORT)

704

PSNIP_SAFE_DEFINE_PROMOTED_SIGNED_BINARY_OP(short, short, add, SHRT_MIN, SHRT_MAX)

705

PSNIP_SAFE_DEFINE_PROMOTED_SIGNED_BINARY_OP(short, short, sub, SHRT_MIN, SHRT_MAX)

706

PSNIP_SAFE_DEFINE_PROMOTED_SIGNED_BINARY_OP(short, short, mul, SHRT_MIN, SHRT_MAX)

707

#else

708

PSNIP_SAFE_DEFINE_SIGNED_ADD(short, short, SHRT_MIN, SHRT_MAX)

709

PSNIP_SAFE_DEFINE_SIGNED_SUB(short, short, SHRT_MIN, SHRT_MAX)

710

PSNIP_SAFE_DEFINE_SIGNED_MUL(short, short, SHRT_MIN, SHRT_MAX)

711

#endif

712

PSNIP_SAFE_DEFINE_SIGNED_DIV(short, short, SHRT_MIN, SHRT_MAX)

713

PSNIP_SAFE_DEFINE_SIGNED_MOD(short, short, SHRT_MIN, SHRT_MAX)

714

PSNIP_SAFE_DEFINE_SIGNED_NEG(short, short, SHRT_MIN, SHRT_MAX)

715

716

#if defined(PSNIP_SAFE_HAVE_BUILTIN_OVERFLOW)

717

PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(unsigned short, ushort, add)

718

PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(unsigned short, ushort, sub)

719

PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(unsigned short, ushort, mul)

720

#elif defined(PSNIP_SAFE_HAVE_INTSAFE_H)

721

PSNIP_SAFE_DEFINE_INTSAFE(USHORT, ushort, add, UShortAdd)

722

PSNIP_SAFE_DEFINE_INTSAFE(USHORT, ushort, sub, UShortSub)

723

PSNIP_SAFE_DEFINE_INTSAFE(USHORT, ushort, mul, UShortMult)

724

#elif defined(PSNIP_SAFE_HAVE_LARGER_USHORT)

725

PSNIP_SAFE_DEFINE_PROMOTED_UNSIGNED_BINARY_OP(unsigned short, ushort, add, USHRT_MAX)

726

PSNIP_SAFE_DEFINE_PROMOTED_UNSIGNED_BINARY_OP(unsigned short, ushort, sub, USHRT_MAX)

727

PSNIP_SAFE_DEFINE_PROMOTED_UNSIGNED_BINARY_OP(unsigned short, ushort, mul, USHRT_MAX)

728

#else

729

PSNIP_SAFE_DEFINE_UNSIGNED_ADD(unsigned short, ushort, USHRT_MAX)

730

PSNIP_SAFE_DEFINE_UNSIGNED_SUB(unsigned short, ushort, USHRT_MAX)

731

PSNIP_SAFE_DEFINE_UNSIGNED_MUL(unsigned short, ushort, USHRT_MAX)

732

#endif

733

PSNIP_SAFE_DEFINE_UNSIGNED_DIV(unsigned short, ushort, USHRT_MAX)

734

PSNIP_SAFE_DEFINE_UNSIGNED_MOD(unsigned short, ushort, USHRT_MAX)

735

736

#if defined(PSNIP_SAFE_HAVE_BUILTIN_OVERFLOW)

737

PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(int, int, add)

738

PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(int, int, sub)

740

#elif defined(PSNIP_SAFE_HAVE_LARGER_INT)

741

PSNIP_SAFE_DEFINE_PROMOTED_SIGNED_BINARY_OP(int, int, add, INT_MIN, INT_MAX)

742

PSNIP_SAFE_DEFINE_PROMOTED_SIGNED_BINARY_OP(int, int, sub, INT_MIN, INT_MAX)

743

PSNIP_SAFE_DEFINE_PROMOTED_SIGNED_BINARY_OP(int, int, mul, INT_MIN, INT_MAX)

744

#else

745

PSNIP_SAFE_DEFINE_SIGNED_ADD(int, int, INT_MIN, INT_MAX)

746

PSNIP_SAFE_DEFINE_SIGNED_SUB(int, int, INT_MIN, INT_MAX)

747

PSNIP_SAFE_DEFINE_SIGNED_MUL(int, int, INT_MIN, INT_MAX)

748

#endif

749

PSNIP_SAFE_DEFINE_SIGNED_DIV(int, int, INT_MIN, INT_MAX)

750

PSNIP_SAFE_DEFINE_SIGNED_MOD(int, int, INT_MIN, INT_MAX)

751

PSNIP_SAFE_DEFINE_SIGNED_NEG(int, int, INT_MIN, INT_MAX)

752

753

#if defined(PSNIP_SAFE_HAVE_BUILTIN_OVERFLOW)

754

PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(unsigned int, uint, add)

755

PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(unsigned int, uint, sub)

756

PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(unsigned int, uint, mul)

757

#elif defined(PSNIP_SAFE_HAVE_INTSAFE_H)

758

PSNIP_SAFE_DEFINE_INTSAFE(UINT, uint, add, UIntAdd)

759

PSNIP_SAFE_DEFINE_INTSAFE(UINT, uint, sub, UIntSub)

760

PSNIP_SAFE_DEFINE_INTSAFE(UINT, uint, mul, UIntMult)

761

#elif defined(PSNIP_SAFE_HAVE_LARGER_UINT)

762

PSNIP_SAFE_DEFINE_PROMOTED_UNSIGNED_BINARY_OP(unsigned int, uint, add, UINT_MAX)

763

PSNIP_SAFE_DEFINE_PROMOTED_UNSIGNED_BINARY_OP(unsigned int, uint, sub, UINT_MAX)

764

PSNIP_SAFE_DEFINE_PROMOTED_UNSIGNED_BINARY_OP(unsigned int, uint, mul, UINT_MAX)

765

#else

766

PSNIP_SAFE_DEFINE_UNSIGNED_ADD(unsigned int, uint, UINT_MAX)

767

PSNIP_SAFE_DEFINE_UNSIGNED_SUB(unsigned int, uint, UINT_MAX)

768

PSNIP_SAFE_DEFINE_UNSIGNED_MUL(unsigned int, uint, UINT_MAX)

769

#endif

770

PSNIP_SAFE_DEFINE_UNSIGNED_DIV(unsigned int, uint, UINT_MAX)

771

PSNIP_SAFE_DEFINE_UNSIGNED_MOD(unsigned int, uint, UINT_MAX)

772

773

#if defined(PSNIP_SAFE_HAVE_BUILTIN_OVERFLOW)

774

PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(long, long, add)

775

PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(long, long, sub)

776

PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(long, long, mul)

777

#elif defined(PSNIP_SAFE_HAVE_LARGER_LONG)

778

PSNIP_SAFE_DEFINE_PROMOTED_SIGNED_BINARY_OP(long, long, add, LONG_MIN, LONG_MAX)

779

PSNIP_SAFE_DEFINE_PROMOTED_SIGNED_BINARY_OP(long, long, sub, LONG_MIN, LONG_MAX)

780

PSNIP_SAFE_DEFINE_PROMOTED_SIGNED_BINARY_OP(long, long, mul, LONG_MIN, LONG_MAX)

781

#else

782

PSNIP_SAFE_DEFINE_SIGNED_ADD(long, long, LONG_MIN, LONG_MAX)

783

PSNIP_SAFE_DEFINE_SIGNED_SUB(long, long, LONG_MIN, LONG_MAX)

784

PSNIP_SAFE_DEFINE_SIGNED_MUL(long, long, LONG_MIN, LONG_MAX)

785

#endif

786

PSNIP_SAFE_DEFINE_SIGNED_DIV(long, long, LONG_MIN, LONG_MAX)

787

PSNIP_SAFE_DEFINE_SIGNED_MOD(long, long, LONG_MIN, LONG_MAX)

788

PSNIP_SAFE_DEFINE_SIGNED_NEG(long, long, LONG_MIN, LONG_MAX)

789

790

#if defined(PSNIP_SAFE_HAVE_BUILTIN_OVERFLOW)

791

PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(unsigned long, ulong, add)

792

PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(unsigned long, ulong, sub)

793

PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(unsigned long, ulong, mul)

794

#elif defined(PSNIP_SAFE_HAVE_INTSAFE_H)

795

PSNIP_SAFE_DEFINE_INTSAFE(ULONG, ulong, add, ULongAdd)

796

PSNIP_SAFE_DEFINE_INTSAFE(ULONG, ulong, sub, ULongSub)

797

PSNIP_SAFE_DEFINE_INTSAFE(ULONG, ulong, mul, ULongMult)

798

#elif defined(PSNIP_SAFE_HAVE_LARGER_ULONG)

799

PSNIP_SAFE_DEFINE_PROMOTED_UNSIGNED_BINARY_OP(unsigned long, ulong, add, ULONG_MAX)

800

PSNIP_SAFE_DEFINE_PROMOTED_UNSIGNED_BINARY_OP(unsigned long, ulong, sub, ULONG_MAX)

801

PSNIP_SAFE_DEFINE_PROMOTED_UNSIGNED_BINARY_OP(unsigned long, ulong, mul, ULONG_MAX)

802

#else

803

PSNIP_SAFE_DEFINE_UNSIGNED_ADD(unsigned long, ulong, ULONG_MAX)

804

PSNIP_SAFE_DEFINE_UNSIGNED_SUB(unsigned long, ulong, ULONG_MAX)

805

PSNIP_SAFE_DEFINE_UNSIGNED_MUL(unsigned long, ulong, ULONG_MAX)

806

#endif

807

PSNIP_SAFE_DEFINE_UNSIGNED_DIV(unsigned long, ulong, ULONG_MAX)

808

PSNIP_SAFE_DEFINE_UNSIGNED_MOD(unsigned long, ulong, ULONG_MAX)

809

810

#if defined(PSNIP_SAFE_HAVE_BUILTIN_OVERFLOW)

811

PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(long long, llong, add)

812

PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(long long, llong, sub)

813

PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(long long, llong, mul)

814

#elif defined(PSNIP_SAFE_HAVE_LARGER_LLONG)

815

PSNIP_SAFE_DEFINE_PROMOTED_SIGNED_BINARY_OP(long long, llong, add, LLONG_MIN, LLONG_MAX)

816

PSNIP_SAFE_DEFINE_PROMOTED_SIGNED_BINARY_OP(long long, llong, sub, LLONG_MIN, LLONG_MAX)

817

PSNIP_SAFE_DEFINE_PROMOTED_SIGNED_BINARY_OP(long long, llong, mul, LLONG_MIN, LLONG_MAX)

818

#else

819

PSNIP_SAFE_DEFINE_SIGNED_ADD(long long, llong, LLONG_MIN, LLONG_MAX)

820

PSNIP_SAFE_DEFINE_SIGNED_SUB(long long, llong, LLONG_MIN, LLONG_MAX)

821

PSNIP_SAFE_DEFINE_SIGNED_MUL(long long, llong, LLONG_MIN, LLONG_MAX)

822

#endif

823

PSNIP_SAFE_DEFINE_SIGNED_DIV(long long, llong, LLONG_MIN, LLONG_MAX)

824

PSNIP_SAFE_DEFINE_SIGNED_MOD(long long, llong, LLONG_MIN, LLONG_MAX)

825

PSNIP_SAFE_DEFINE_SIGNED_NEG(long long, llong, LLONG_MIN, LLONG_MAX)

826

827

#if defined(PSNIP_SAFE_HAVE_BUILTIN_OVERFLOW)

828

PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(unsigned long long, ullong, add)

829

PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(unsigned long long, ullong, sub)

830

PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(unsigned long long, ullong, mul)

831

#elif defined(PSNIP_SAFE_HAVE_INTSAFE_H)

832

PSNIP_SAFE_DEFINE_INTSAFE(ULONGLONG, ullong, add, ULongLongAdd)

833

PSNIP_SAFE_DEFINE_INTSAFE(ULONGLONG, ullong, sub, ULongLongSub)

834

PSNIP_SAFE_DEFINE_INTSAFE(ULONGLONG, ullong, mul, ULongLongMult)

835

#elif defined(PSNIP_SAFE_HAVE_LARGER_ULLONG)

836

PSNIP_SAFE_DEFINE_PROMOTED_UNSIGNED_BINARY_OP(unsigned long long, ullong, add, ULLONG_MAX)

837

PSNIP_SAFE_DEFINE_PROMOTED_UNSIGNED_BINARY_OP(unsigned long long, ullong, sub, ULLONG_MAX)

838

PSNIP_SAFE_DEFINE_PROMOTED_UNSIGNED_BINARY_OP(unsigned long long, ullong, mul, ULLONG_MAX)

839

#else

840

PSNIP_SAFE_DEFINE_UNSIGNED_ADD(unsigned long long, ullong, ULLONG_MAX)

841

PSNIP_SAFE_DEFINE_UNSIGNED_SUB(unsigned long long, ullong, ULLONG_MAX)

842

PSNIP_SAFE_DEFINE_UNSIGNED_MUL(unsigned long long, ullong, ULLONG_MAX)

843

#endif

844

PSNIP_SAFE_DEFINE_UNSIGNED_DIV(unsigned long long, ullong, ULLONG_MAX)

845

PSNIP_SAFE_DEFINE_UNSIGNED_MOD(unsigned long long, ullong, ULLONG_MAX)

846

847

#if defined(PSNIP_SAFE_HAVE_BUILTIN_OVERFLOW)

849

PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(size_t, size, sub)

851

#elif defined(PSNIP_SAFE_HAVE_INTSAFE_H)

852

PSNIP_SAFE_DEFINE_INTSAFE(size_t, size, add, SizeTAdd)

853

PSNIP_SAFE_DEFINE_INTSAFE(size_t, size, sub, SizeTSub)

854

PSNIP_SAFE_DEFINE_INTSAFE(size_t, size, mul, SizeTMult)

855

#elif defined(PSNIP_SAFE_HAVE_LARGER_SIZE)

856

PSNIP_SAFE_DEFINE_PROMOTED_UNSIGNED_BINARY_OP(size_t, size, add, PSNIP_SAFE__SIZE_MAX_RT)

857

PSNIP_SAFE_DEFINE_PROMOTED_UNSIGNED_BINARY_OP(size_t, size, sub, PSNIP_SAFE__SIZE_MAX_RT)

858

PSNIP_SAFE_DEFINE_PROMOTED_UNSIGNED_BINARY_OP(size_t, size, mul, PSNIP_SAFE__SIZE_MAX_RT)

859

#else

860

PSNIP_SAFE_DEFINE_UNSIGNED_ADD(size_t, size, PSNIP_SAFE__SIZE_MAX_RT)

861

PSNIP_SAFE_DEFINE_UNSIGNED_SUB(size_t, size, PSNIP_SAFE__SIZE_MAX_RT)

862

PSNIP_SAFE_DEFINE_UNSIGNED_MUL(size_t, size, PSNIP_SAFE__SIZE_MAX_RT)

863

#endif

864

PSNIP_SAFE_DEFINE_UNSIGNED_DIV(size_t, size, PSNIP_SAFE__SIZE_MAX_RT)

865

PSNIP_SAFE_DEFINE_UNSIGNED_MOD(size_t, size, PSNIP_SAFE__SIZE_MAX_RT)

866

867

#if !defined(PSNIP_SAFE_NO_FIXED)

868

869

#if defined(PSNIP_SAFE_HAVE_BUILTIN_OVERFLOW)

870

PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(psnip_int8_t, int8, add)

871

PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(psnip_int8_t, int8, sub)

872

PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(psnip_int8_t, int8, mul)

873

#elif defined(PSNIP_SAFE_HAVE_LARGER_INT8)

874

PSNIP_SAFE_DEFINE_PROMOTED_SIGNED_BINARY_OP(psnip_int8_t, int8, add, (-0x7fLL-1), 0x7f)

875

PSNIP_SAFE_DEFINE_PROMOTED_SIGNED_BINARY_OP(psnip_int8_t, int8, sub, (-0x7fLL-1), 0x7f)

876

PSNIP_SAFE_DEFINE_PROMOTED_SIGNED_BINARY_OP(psnip_int8_t, int8, mul, (-0x7fLL-1), 0x7f)

877

#else

878

PSNIP_SAFE_DEFINE_SIGNED_ADD(psnip_int8_t, int8, (-0x7fLL-1), 0x7f)

879

PSNIP_SAFE_DEFINE_SIGNED_SUB(psnip_int8_t, int8, (-0x7fLL-1), 0x7f)

880

PSNIP_SAFE_DEFINE_SIGNED_MUL(psnip_int8_t, int8, (-0x7fLL-1), 0x7f)

881

#endif

882

PSNIP_SAFE_DEFINE_SIGNED_DIV(psnip_int8_t, int8, (-0x7fLL-1), 0x7f)

883

PSNIP_SAFE_DEFINE_SIGNED_MOD(psnip_int8_t, int8, (-0x7fLL-1), 0x7f)

884

PSNIP_SAFE_DEFINE_SIGNED_NEG(psnip_int8_t, int8, (-0x7fLL-1), 0x7f)

885

886

#if defined(PSNIP_SAFE_HAVE_BUILTIN_OVERFLOW)

887

PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(psnip_uint8_t, uint8, add)

888

PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(psnip_uint8_t, uint8, sub)

889

PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(psnip_uint8_t, uint8, mul)

890

#elif defined(PSNIP_SAFE_HAVE_LARGER_UINT8)

891

PSNIP_SAFE_DEFINE_PROMOTED_UNSIGNED_BINARY_OP(psnip_uint8_t, uint8, add, 0xff)

892

PSNIP_SAFE_DEFINE_PROMOTED_UNSIGNED_BINARY_OP(psnip_uint8_t, uint8, sub, 0xff)

893

PSNIP_SAFE_DEFINE_PROMOTED_UNSIGNED_BINARY_OP(psnip_uint8_t, uint8, mul, 0xff)

894

#else

895

PSNIP_SAFE_DEFINE_UNSIGNED_ADD(psnip_uint8_t, uint8, 0xff)

896

PSNIP_SAFE_DEFINE_UNSIGNED_SUB(psnip_uint8_t, uint8, 0xff)

897

PSNIP_SAFE_DEFINE_UNSIGNED_MUL(psnip_uint8_t, uint8, 0xff)

898

#endif

899

PSNIP_SAFE_DEFINE_UNSIGNED_DIV(psnip_uint8_t, uint8, 0xff)

900

PSNIP_SAFE_DEFINE_UNSIGNED_MOD(psnip_uint8_t, uint8, 0xff)

901

902

#if defined(PSNIP_SAFE_HAVE_BUILTIN_OVERFLOW)

903

PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(psnip_int16_t, int16, add)

904

PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(psnip_int16_t, int16, sub)

905

PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(psnip_int16_t, int16, mul)

906

#elif defined(PSNIP_SAFE_HAVE_LARGER_INT16)

907

PSNIP_SAFE_DEFINE_PROMOTED_SIGNED_BINARY_OP(psnip_int16_t, int16, add, (-32767-1), 0x7fff)

908

PSNIP_SAFE_DEFINE_PROMOTED_SIGNED_BINARY_OP(psnip_int16_t, int16, sub, (-32767-1), 0x7fff)

909

PSNIP_SAFE_DEFINE_PROMOTED_SIGNED_BINARY_OP(psnip_int16_t, int16, mul, (-32767-1), 0x7fff)

910

#else

911

PSNIP_SAFE_DEFINE_SIGNED_ADD(psnip_int16_t, int16, (-32767-1), 0x7fff)

912

PSNIP_SAFE_DEFINE_SIGNED_SUB(psnip_int16_t, int16, (-32767-1), 0x7fff)

913

PSNIP_SAFE_DEFINE_SIGNED_MUL(psnip_int16_t, int16, (-32767-1), 0x7fff)

914

#endif

915

PSNIP_SAFE_DEFINE_SIGNED_DIV(psnip_int16_t, int16, (-32767-1), 0x7fff)

916

PSNIP_SAFE_DEFINE_SIGNED_MOD(psnip_int16_t, int16, (-32767-1), 0x7fff)

917

PSNIP_SAFE_DEFINE_SIGNED_NEG(psnip_int16_t, int16, (-32767-1), 0x7fff)

918

919

#if defined(PSNIP_SAFE_HAVE_BUILTIN_OVERFLOW)

920

PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(psnip_uint16_t, uint16, add)

921

PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(psnip_uint16_t, uint16, sub)

922

PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(psnip_uint16_t, uint16, mul)

923

#elif defined(PSNIP_SAFE_HAVE_INTSAFE_H) && defined(_WIN32)

924

PSNIP_SAFE_DEFINE_INTSAFE(psnip_uint16_t, uint16, add, UShortAdd)

925

PSNIP_SAFE_DEFINE_INTSAFE(psnip_uint16_t, uint16, sub, UShortSub)

926

PSNIP_SAFE_DEFINE_INTSAFE(psnip_uint16_t, uint16, mul, UShortMult)

927

#elif defined(PSNIP_SAFE_HAVE_LARGER_UINT16)

928

PSNIP_SAFE_DEFINE_PROMOTED_UNSIGNED_BINARY_OP(psnip_uint16_t, uint16, add, 0xffff)

929

PSNIP_SAFE_DEFINE_PROMOTED_UNSIGNED_BINARY_OP(psnip_uint16_t, uint16, sub, 0xffff)

930

PSNIP_SAFE_DEFINE_PROMOTED_UNSIGNED_BINARY_OP(psnip_uint16_t, uint16, mul, 0xffff)

931

#else

932

PSNIP_SAFE_DEFINE_UNSIGNED_ADD(psnip_uint16_t, uint16, 0xffff)

933

PSNIP_SAFE_DEFINE_UNSIGNED_SUB(psnip_uint16_t, uint16, 0xffff)

934

PSNIP_SAFE_DEFINE_UNSIGNED_MUL(psnip_uint16_t, uint16, 0xffff)

935

#endif

936

PSNIP_SAFE_DEFINE_UNSIGNED_DIV(psnip_uint16_t, uint16, 0xffff)

937

PSNIP_SAFE_DEFINE_UNSIGNED_MOD(psnip_uint16_t, uint16, 0xffff)

938

939

#if defined(PSNIP_SAFE_HAVE_BUILTIN_OVERFLOW)

940

PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(psnip_int32_t, int32, add)

941

PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(psnip_int32_t, int32, sub)

942

PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(psnip_int32_t, int32, mul)

943

#elif defined(PSNIP_SAFE_HAVE_LARGER_INT32)

944

PSNIP_SAFE_DEFINE_PROMOTED_SIGNED_BINARY_OP(psnip_int32_t, int32, add, (-0x7fffffffLL-1), 0x7fffffffLL)

945

PSNIP_SAFE_DEFINE_PROMOTED_SIGNED_BINARY_OP(psnip_int32_t, int32, sub, (-0x7fffffffLL-1), 0x7fffffffLL)

946

PSNIP_SAFE_DEFINE_PROMOTED_SIGNED_BINARY_OP(psnip_int32_t, int32, mul, (-0x7fffffffLL-1), 0x7fffffffLL)

947

#else

948

PSNIP_SAFE_DEFINE_SIGNED_ADD(psnip_int32_t, int32, (-0x7fffffffLL-1), 0x7fffffffLL)

949

PSNIP_SAFE_DEFINE_SIGNED_SUB(psnip_int32_t, int32, (-0x7fffffffLL-1), 0x7fffffffLL)

950

PSNIP_SAFE_DEFINE_SIGNED_MUL(psnip_int32_t, int32, (-0x7fffffffLL-1), 0x7fffffffLL)

951

#endif

952

PSNIP_SAFE_DEFINE_SIGNED_DIV(psnip_int32_t, int32, (-0x7fffffffLL-1), 0x7fffffffLL)

953

PSNIP_SAFE_DEFINE_SIGNED_MOD(psnip_int32_t, int32, (-0x7fffffffLL-1), 0x7fffffffLL)

954

PSNIP_SAFE_DEFINE_SIGNED_NEG(psnip_int32_t, int32, (-0x7fffffffLL-1), 0x7fffffffLL)

955

956

#if defined(PSNIP_SAFE_HAVE_BUILTIN_OVERFLOW)

957

PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(psnip_uint32_t, uint32, add)

958

PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(psnip_uint32_t, uint32, sub)

959

PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(psnip_uint32_t, uint32, mul)

960

#elif defined(PSNIP_SAFE_HAVE_INTSAFE_H) && defined(_WIN32)

961

PSNIP_SAFE_DEFINE_INTSAFE(psnip_uint32_t, uint32, add, UIntAdd)

962

PSNIP_SAFE_DEFINE_INTSAFE(psnip_uint32_t, uint32, sub, UIntSub)

963

PSNIP_SAFE_DEFINE_INTSAFE(psnip_uint32_t, uint32, mul, UIntMult)

964

#elif defined(PSNIP_SAFE_HAVE_LARGER_UINT32)

965

PSNIP_SAFE_DEFINE_PROMOTED_UNSIGNED_BINARY_OP(psnip_uint32_t, uint32, add, 0xffffffffUL)

966

PSNIP_SAFE_DEFINE_PROMOTED_UNSIGNED_BINARY_OP(psnip_uint32_t, uint32, sub, 0xffffffffUL)

967

PSNIP_SAFE_DEFINE_PROMOTED_UNSIGNED_BINARY_OP(psnip_uint32_t, uint32, mul, 0xffffffffUL)

968

#else

969

PSNIP_SAFE_DEFINE_UNSIGNED_ADD(psnip_uint32_t, uint32, 0xffffffffUL)

970

PSNIP_SAFE_DEFINE_UNSIGNED_SUB(psnip_uint32_t, uint32, 0xffffffffUL)

971

PSNIP_SAFE_DEFINE_UNSIGNED_MUL(psnip_uint32_t, uint32, 0xffffffffUL)

972

#endif

973

PSNIP_SAFE_DEFINE_UNSIGNED_DIV(psnip_uint32_t, uint32, 0xffffffffUL)

974

PSNIP_SAFE_DEFINE_UNSIGNED_MOD(psnip_uint32_t, uint32, 0xffffffffUL)

975

976

#if defined(PSNIP_SAFE_HAVE_BUILTIN_OVERFLOW)

977

PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(psnip_int64_t, int64, add)

978

PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(psnip_int64_t, int64, sub)

979

PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(psnip_int64_t, int64, mul)

980

#elif defined(PSNIP_SAFE_HAVE_LARGER_INT64)

981

PSNIP_SAFE_DEFINE_PROMOTED_SIGNED_BINARY_OP(psnip_int64_t, int64, add, (-0x7fffffffffffffffLL-1), 0x7fffffffffffffffLL)

982

PSNIP_SAFE_DEFINE_PROMOTED_SIGNED_BINARY_OP(psnip_int64_t, int64, sub, (-0x7fffffffffffffffLL-1), 0x7fffffffffffffffLL)

983

PSNIP_SAFE_DEFINE_PROMOTED_SIGNED_BINARY_OP(psnip_int64_t, int64, mul, (-0x7fffffffffffffffLL-1), 0x7fffffffffffffffLL)

984

#else

985

PSNIP_SAFE_DEFINE_SIGNED_ADD(psnip_int64_t, int64, (-0x7fffffffffffffffLL-1), 0x7fffffffffffffffLL)

986

PSNIP_SAFE_DEFINE_SIGNED_SUB(psnip_int64_t, int64, (-0x7fffffffffffffffLL-1), 0x7fffffffffffffffLL)

987

PSNIP_SAFE_DEFINE_SIGNED_MUL(psnip_int64_t, int64, (-0x7fffffffffffffffLL-1), 0x7fffffffffffffffLL)

988

#endif

989

PSNIP_SAFE_DEFINE_SIGNED_DIV(psnip_int64_t, int64, (-0x7fffffffffffffffLL-1), 0x7fffffffffffffffLL)

990

PSNIP_SAFE_DEFINE_SIGNED_MOD(psnip_int64_t, int64, (-0x7fffffffffffffffLL-1), 0x7fffffffffffffffLL)

991

PSNIP_SAFE_DEFINE_SIGNED_NEG(psnip_int64_t, int64, (-0x7fffffffffffffffLL-1), 0x7fffffffffffffffLL)

992

993

#if defined(PSNIP_SAFE_HAVE_BUILTIN_OVERFLOW)

994

PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(psnip_uint64_t, uint64, add)

995

PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(psnip_uint64_t, uint64, sub)

996

PSNIP_SAFE_DEFINE_BUILTIN_BINARY_OP(psnip_uint64_t, uint64, mul)

997

#elif defined(PSNIP_SAFE_HAVE_INTSAFE_H) && defined(_WIN32)

998

PSNIP_SAFE_DEFINE_INTSAFE(psnip_uint64_t, uint64, add, ULongLongAdd)

999

PSNIP_SAFE_DEFINE_INTSAFE(psnip_uint64_t, uint64, sub, ULongLongSub)

1000

PSNIP_SAFE_DEFINE_INTSAFE(psnip_uint64_t, uint64, mul, ULongLongMult)

1001

#elif defined(PSNIP_SAFE_HAVE_LARGER_UINT64)

1002

PSNIP_SAFE_DEFINE_PROMOTED_UNSIGNED_BINARY_OP(psnip_uint64_t, uint64, add, 0xffffffffffffffffULL)

1003

PSNIP_SAFE_DEFINE_PROMOTED_UNSIGNED_BINARY_OP(psnip_uint64_t, uint64, sub, 0xffffffffffffffffULL)

1004

PSNIP_SAFE_DEFINE_PROMOTED_UNSIGNED_BINARY_OP(psnip_uint64_t, uint64, mul, 0xffffffffffffffffULL)

1005

#else

1006

PSNIP_SAFE_DEFINE_UNSIGNED_ADD(psnip_uint64_t, uint64, 0xffffffffffffffffULL)

1007

PSNIP_SAFE_DEFINE_UNSIGNED_SUB(psnip_uint64_t, uint64, 0xffffffffffffffffULL)

1008

PSNIP_SAFE_DEFINE_UNSIGNED_MUL(psnip_uint64_t, uint64, 0xffffffffffffffffULL)

1009

#endif

1010

PSNIP_SAFE_DEFINE_UNSIGNED_DIV(psnip_uint64_t, uint64, 0xffffffffffffffffULL)

1011

PSNIP_SAFE_DEFINE_UNSIGNED_MOD(psnip_uint64_t, uint64, 0xffffffffffffffffULL)

1012

1013

#endif /* !defined(PSNIP_SAFE_NO_FIXED) */

1014

1015

#define PSNIP_SAFE_C11_GENERIC_SELECTION(res, op) \

1016

  _Generic((*res), \

1017

           char: psnip_safe_char_##op, \

1018

           unsigned char: psnip_safe_uchar_##op, \

1019

           short: psnip_safe_short_##op, \

1020

           unsigned short: psnip_safe_ushort_##op, \

1021

           int: psnip_safe_int_##op, \

1022

           unsigned int: psnip_safe_uint_##op, \

1023

           long: psnip_safe_long_##op, \

1024

           unsigned long: psnip_safe_ulong_##op, \

1025

           long long: psnip_safe_llong_##op, \

1026

           unsigned long long: psnip_safe_ullong_##op)

1027

1028

#define PSNIP_SAFE_C11_GENERIC_BINARY_OP(op, res, a, b) \

1029

  PSNIP_SAFE_C11_GENERIC_SELECTION(res, op)(res, a, b)

1030

#define PSNIP_SAFE_C11_GENERIC_UNARY_OP(op, res, v) \

1031

  PSNIP_SAFE_C11_GENERIC_SELECTION(res, op)(res, v)

1032

1033

#if defined(PSNIP_SAFE_HAVE_BUILTIN_OVERFLOW)

1034

#define psnip_safe_add(res, a, b) !__builtin_add_overflow(a, b, res)

1035

#define psnip_safe_sub(res, a, b) !__builtin_sub_overflow(a, b, res)

1036

#define psnip_safe_mul(res, a, b) !__builtin_mul_overflow(a, b, res)

1037

#define psnip_safe_div(res, a, b) !__builtin_div_overflow(a, b, res)

1038

#define psnip_safe_mod(res, a, b) !__builtin_mod_overflow(a, b, res)

1039

#define psnip_safe_neg(res, v)    PSNIP_SAFE_C11_GENERIC_UNARY_OP (neg, res, v)

1040

1041

#elif defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)

1042

/* The are no fixed-length or size selections because they cause an

1043

 * error about _Generic specifying two compatible types.  Hopefully

1044

 * this doesn't cause problems on exotic platforms, but if it does

1045

 * please let me know and I'll try to figure something out. */

1046

1047

#define psnip_safe_add(res, a, b) PSNIP_SAFE_C11_GENERIC_BINARY_OP(add, res, a, b)

1048

#define psnip_safe_sub(res, a, b) PSNIP_SAFE_C11_GENERIC_BINARY_OP(sub, res, a, b)

1049

#define psnip_safe_mul(res, a, b) PSNIP_SAFE_C11_GENERIC_BINARY_OP(mul, res, a, b)

1050

#define psnip_safe_div(res, a, b) PSNIP_SAFE_C11_GENERIC_BINARY_OP(div, res, a, b)

1051

#define psnip_safe_mod(res, a, b) PSNIP_SAFE_C11_GENERIC_BINARY_OP(mod, res, a, b)

1052

#define psnip_safe_neg(res, v)    PSNIP_SAFE_C11_GENERIC_UNARY_OP (neg, res, v)

1053

#endif

1054

1055

#if !defined(PSNIP_SAFE_HAVE_BUILTINS) && (defined(PSNIP_SAFE_EMULATE_NATIVE) || defined(PSNIP_BUILTIN_EMULATE_NATIVE))

1056

#  define __builtin_sadd_overflow(a, b, res)   (!psnip_safe_int_add(res, a, b))

1057

#  define __builtin_saddl_overflow(a, b, res)  (!psnip_safe_long_add(res, a, b))

1058

#  define __builtin_saddll_overflow(a, b, res) (!psnip_safe_llong_add(res, a, b))

1059

#  define __builtin_uadd_overflow(a, b, res)   (!psnip_safe_uint_add(res, a, b))

1060

#  define __builtin_uaddl_overflow(a, b, res)  (!psnip_safe_ulong_add(res, a, b))

1061

#  define __builtin_uaddll_overflow(a, b, res) (!psnip_safe_ullong_add(res, a, b))

1062

1063

#  define __builtin_ssub_overflow(a, b, res)   (!psnip_safe_int_sub(res, a, b))

1064

#  define __builtin_ssubl_overflow(a, b, res)  (!psnip_safe_long_sub(res, a, b))

1065

#  define __builtin_ssubll_overflow(a, b, res) (!psnip_safe_llong_sub(res, a, b))

1066

#  define __builtin_usub_overflow(a, b, res)   (!psnip_safe_uint_sub(res, a, b))

1067

#  define __builtin_usubl_overflow(a, b, res)  (!psnip_safe_ulong_sub(res, a, b))

1068

#  define __builtin_usubll_overflow(a, b, res) (!psnip_safe_ullong_sub(res, a, b))

1069

1070

#  define __builtin_smul_overflow(a, b, res)   (!psnip_safe_int_mul(res, a, b))

1071

#  define __builtin_smull_overflow(a, b, res)  (!psnip_safe_long_mul(res, a, b))

1072

#  define __builtin_smulll_overflow(a, b, res) (!psnip_safe_llong_mul(res, a, b))

1073

#  define __builtin_umul_overflow(a, b, res)   (!psnip_safe_uint_mul(res, a, b))

1074

#  define __builtin_umull_overflow(a, b, res)  (!psnip_safe_ulong_mul(res, a, b))

1075

#  define __builtin_umulll_overflow(a, b, res) (!psnip_safe_ullong_mul(res, a, b))

1076

#endif

1077

1078

#endif /* !defined(PSNIP_SAFE_H) */

tbeu / matio / #1088

Source File
Press 'n' to go to next uncovered line, 'b' for previous

tbeu / matio / #1088

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous