e4196edfbf
On s390 size_t is an unsigned long, nor an unsigned int. They both are
of the same size and can be cast to each other safely, but the compiler
still seems unhappy about incompatible pointers.
Fixes: 7c2da2ca8
108 lines
3.5 KiB
C
108 lines
3.5 KiB
C
#pragma once
|
|
|
|
/***
|
|
This file is part of systemd.
|
|
|
|
Copyright 2010 Lennart Poettering
|
|
|
|
systemd is free software; you can redistribute it and/or modify it
|
|
under the terms of the GNU Lesser General Public License as published by
|
|
the Free Software Foundation; either version 2.1 of the License, or
|
|
(at your option) any later version.
|
|
|
|
systemd is distributed in the hope that it will be useful, but
|
|
WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
|
along with systemd; If not, see <http://www.gnu.org/licenses/>.
|
|
***/
|
|
|
|
#include <inttypes.h>
|
|
#include <limits.h>
|
|
#include <stddef.h>
|
|
#include <stdint.h>
|
|
#include <sys/types.h>
|
|
|
|
#include "macro.h"
|
|
|
|
#define MODE_INVALID ((mode_t) -1)
|
|
|
|
int parse_boolean(const char *v) _pure_;
|
|
int parse_pid(const char *s, pid_t* ret_pid);
|
|
int parse_mode(const char *s, mode_t *ret);
|
|
int parse_ifindex(const char *s, int *ret);
|
|
|
|
int parse_size(const char *t, uint64_t base, uint64_t *size);
|
|
int parse_range(const char *t, unsigned *lower, unsigned *upper);
|
|
|
|
#define FORMAT_BYTES_MAX 8
|
|
char *format_bytes(char *buf, size_t l, uint64_t t);
|
|
|
|
int safe_atou(const char *s, unsigned *ret_u);
|
|
int safe_atoi(const char *s, int *ret_i);
|
|
int safe_atollu(const char *s, unsigned long long *ret_u);
|
|
int safe_atolli(const char *s, long long int *ret_i);
|
|
|
|
int safe_atou8(const char *s, uint8_t *ret);
|
|
|
|
int safe_atou16(const char *s, uint16_t *ret);
|
|
int safe_atoi16(const char *s, int16_t *ret);
|
|
|
|
static inline int safe_atou32(const char *s, uint32_t *ret_u) {
|
|
assert_cc(sizeof(uint32_t) == sizeof(unsigned));
|
|
return safe_atou(s, (unsigned*) ret_u);
|
|
}
|
|
|
|
static inline int safe_atoi32(const char *s, int32_t *ret_i) {
|
|
assert_cc(sizeof(int32_t) == sizeof(int));
|
|
return safe_atoi(s, (int*) ret_i);
|
|
}
|
|
|
|
static inline int safe_atou64(const char *s, uint64_t *ret_u) {
|
|
assert_cc(sizeof(uint64_t) == sizeof(unsigned long long));
|
|
return safe_atollu(s, (unsigned long long*) ret_u);
|
|
}
|
|
|
|
static inline int safe_atoi64(const char *s, int64_t *ret_i) {
|
|
assert_cc(sizeof(int64_t) == sizeof(long long int));
|
|
return safe_atolli(s, (long long int*) ret_i);
|
|
}
|
|
|
|
#if LONG_MAX == INT_MAX
|
|
static inline int safe_atolu(const char *s, unsigned long *ret_u) {
|
|
assert_cc(sizeof(unsigned long) == sizeof(unsigned));
|
|
return safe_atou(s, (unsigned*) ret_u);
|
|
}
|
|
static inline int safe_atoli(const char *s, long int *ret_u) {
|
|
assert_cc(sizeof(long int) == sizeof(int));
|
|
return safe_atoi(s, (int*) ret_u);
|
|
}
|
|
#else
|
|
static inline int safe_atolu(const char *s, unsigned long *ret_u) {
|
|
assert_cc(sizeof(unsigned long) == sizeof(unsigned long long));
|
|
return safe_atollu(s, (unsigned long long*) ret_u);
|
|
}
|
|
static inline int safe_atoli(const char *s, long int *ret_u) {
|
|
assert_cc(sizeof(long int) == sizeof(long long int));
|
|
return safe_atolli(s, (long long int*) ret_u);
|
|
}
|
|
#endif
|
|
|
|
#if SIZE_MAX == UINT_MAX
|
|
static inline int safe_atozu(const char *s, size_t *ret_u) {
|
|
assert_cc(sizeof(size_t) == sizeof(unsigned));
|
|
return safe_atou(s, (unsigned *) ret_u);
|
|
}
|
|
#else
|
|
static inline int safe_atozu(const char *s, size_t *ret_u) {
|
|
assert_cc(sizeof(size_t) == sizeof(long unsigned));
|
|
return safe_atolu(s, ret_u);
|
|
}
|
|
#endif
|
|
|
|
int safe_atod(const char *s, double *ret_d);
|
|
|
|
int parse_fractional_part_u(const char **s, size_t digits, unsigned *res);
|