Embedded/sc
1
0
Fork 0
mirror of https://github.com/tezc/sc.git synced 2025-01-14 06:43:04 +08:00
Code Issues Packages Projects Releases Wiki Activity

fix compiler warnings

Browse Source
This commit is contained in:
tezc 2021-01-24 17:56:18 +03:00
parent 11f9911ca4
commit 471b331b8d
33 changed files with 205 additions and 182 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
array/array_example.c
View File

@ -5,6 +5,7 @@
int main(int argc, char *argv[])
{
int *p;
int val;
sc_array_create(p, 0);
@ -24,6 +25,10 @@ int main(int argc, char *argv[])
printf("Elem = %d \n", p[i]);
}
sc_array_foreach(p, val) {
printf("Elem = %d \n", val);
}
sc_array_destroy(p);
return 0;

5
array/array_test.c
View File

@ -204,6 +204,11 @@ void fail_test()
sc_array_remove_unordered(arr, 0);
assert(arr[0] == 4);
assert(sc_array_size(arr) == 4);
sc_array_clear(arr);
assert(sc_array_size(arr) == 0);
sc_array_add(arr, 10);
assert(sc_array_size(arr) == 1);
assert(arr[0] == 10);
sc_array_destroy(arr);
}

3
array/sc_array.c
View File

@ -24,9 +24,6 @@
#include "sc_array.h"
#include <stdbool.h>
#include <stddef.h>
#ifndef SC_SIZE_MAX
#define SC_SIZE_MAX SIZE_MAX
#endif

12
buffer/buf_test.c
View File

@ -129,6 +129,18 @@ void test1()
buf = sc_buf_wrap(text, sizeof(text), SC_BUF_REF);
sc_buf_put_text(&buf, "test %d test %s", 1, "test");
assert(strcmp(sc_buf_rbuf(&buf), "test 1 test test") == 0);
sc_buf_term(&buf);
buf = sc_buf_wrap(text, sizeof(text), SC_BUF_REF);
sc_buf_put_str(&buf, "1test");
sc_buf_put_str(&buf, "2test");
buf2 = sc_buf_wrap(sc_buf_rbuf(&buf), sc_buf_size(&buf), SC_BUF_READ);
assert(sc_buf_size(&buf2) == sc_buf_size(&buf));
assert(strcmp(sc_buf_get_str(&buf2), "1test") == 0);
assert(strcmp(sc_buf_get_str(&buf2), "2test") == 0);
sc_buf_term(&buf);
sc_buf_term(&buf2);
}
void test2()

78
buffer/sc_buf.c
View File

@ -26,8 +26,6 @@
#include <assert.h>
#include <stdio.h>
#include <string.h>
#define sc_buf_min(a, b) ((a) > (b) ? (b) : (a))
@ -56,7 +54,7 @@ struct sc_buf sc_buf_wrap(void *data, uint32_t len, int flags)
.limit = flags & SC_BUF_REF ? len : UINT32_MAX,
.wpos = flags & SC_BUF_DATA ? len : 0,
.rpos = 0,
.ref = flags & SC_BUF_REF,
.ref = (bool) (flags & SC_BUF_REF),
.error = 0};
return buf;
@ -281,7 +279,7 @@ static uint32_t sc_buf_peek_64_pos(struct sc_buf *buf, uint32_t pos, uint64_t *v
return sizeof(*val);
}
static uint32_t sc_buf_set_8_pos(struct sc_buf *buf, uint32_t pos, uint8_t *val)
static uint32_t sc_buf_set_8_pos(struct sc_buf *buf, uint32_t pos, const uint8_t *val)
{
if (buf->error != 0 || (pos + sizeof(*val) > buf->cap)) {
buf->error |= SC_BUF_CORRUPT;
@ -293,7 +291,7 @@ static uint32_t sc_buf_set_8_pos(struct sc_buf *buf, uint32_t pos, uint8_t *val)
return sizeof(*val);
}
static uint32_t sc_buf_set_16_pos(struct sc_buf *buf, uint32_t pos, uint16_t *val)
static uint32_t sc_buf_set_16_pos(struct sc_buf *buf, uint32_t pos, const uint16_t *val)
{
unsigned char* p;
@ -304,15 +302,15 @@ static uint32_t sc_buf_set_16_pos(struct sc_buf *buf, uint32_t pos, uint16_t *va
p = &buf->mem[pos];
p[0] = *val >> 0;
p[1] = *val >> 8;
p[2] = *val >> 16;
p[3] = *val >> 24;
p[0] = (unsigned char) (*val >> 0);
p[1] = (unsigned char) (*val >> 8);
p[2] = (unsigned char) (*val >> 16);
p[3] = (unsigned char) (*val >> 24);
return sizeof(*val);
}
static uint32_t sc_buf_set_32_pos(struct sc_buf *buf, uint32_t pos, uint32_t *val)
static uint32_t sc_buf_set_32_pos(struct sc_buf *buf, uint32_t pos, const uint32_t *val)
{
unsigned char* p;
@ -323,15 +321,15 @@ static uint32_t sc_buf_set_32_pos(struct sc_buf *buf, uint32_t pos, uint32_t *va
p = &buf->mem[pos];
p[0] = *val >> 0;
p[1] = *val >> 8;
p[2] = *val >> 16;
p[3] = *val >> 24;
p[0] = (unsigned char) (*val >> 0);
p[1] = (unsigned char) (*val >> 8);
p[2] = (unsigned char) (*val >> 16);
p[3] = (unsigned char) (*val >> 24);
return sizeof(*val);
}
static uint32_t sc_buf_set_64_pos(struct sc_buf *buf, uint32_t pos, uint64_t *val)
static uint32_t sc_buf_set_64_pos(struct sc_buf *buf, uint32_t pos, const uint64_t *val)
{
unsigned char* p;
@ -342,14 +340,14 @@ static uint32_t sc_buf_set_64_pos(struct sc_buf *buf, uint32_t pos, uint64_t *va
p = &buf->mem[pos];
p[0] = *val >> 0;
p[1] = *val >> 8;
p[2] = *val >> 16;
p[3] = *val >> 24;
p[4] = *val >> 32;
p[5] = *val >> 40;
p[6] = *val >> 48;
p[7] = *val >> 56;
p[0] = (unsigned char) (*val >> 0);
p[1] = (unsigned char) (*val >> 8);
p[2] = (unsigned char) (*val >> 16);
p[3] = (unsigned char) (*val >> 24);
p[4] = (unsigned char) (*val >> 32);
p[5] = (unsigned char) (*val >> 40);
p[6] = (unsigned char) (*val >> 48);
p[7] = (unsigned char) (*val >> 56);
return sizeof(*val);
}
@ -581,11 +579,9 @@ void sc_buf_put_raw(struct sc_buf *buf, const void *ptr, uint32_t len)
void sc_buf_put_bool(struct sc_buf *buf, bool val)
{
sc_buf_put_8(buf, val);
sc_buf_put_8(buf, (uint8_t) val);
}
void sc_buf_put_8(struct sc_buf *buf, uint8_t val)
{
if (!sc_buf_reserve(buf, sizeof(val))) {
@ -595,8 +591,6 @@ void sc_buf_put_8(struct sc_buf *buf, uint8_t val)
buf->wpos += sc_buf_set_8_pos(buf, buf->wpos, &val);
}
void sc_buf_put_16(struct sc_buf *buf, uint16_t val)
{
if (!sc_buf_reserve(buf, sizeof(val))) {
@ -606,8 +600,6 @@ void sc_buf_put_16(struct sc_buf *buf, uint16_t val)
buf->wpos += sc_buf_set_16_pos(buf, buf->wpos, &val);
}
void sc_buf_put_32(struct sc_buf *buf, uint32_t val)
{
if (!sc_buf_reserve(buf, sizeof(val))) {
@ -638,28 +630,34 @@ void sc_buf_put_double(struct sc_buf *buf, double val)
void sc_buf_put_str(struct sc_buf *buf, const char *str)
{
uint32_t size;
size_t size;
if (str == NULL) {
sc_buf_put_32(buf, -1);
sc_buf_put_32(buf, UINT32_MAX);
return;
}
size = strlen(str);
if (size >= UINT32_MAX) {
buf->error |= SC_BUF_CORRUPT;
return;
}
sc_buf_put_32(buf, size);
sc_buf_put_raw(buf, str, size + sc_buf_8_len('\0'));
sc_buf_put_32(buf, (uint32_t) size);
sc_buf_put_raw(buf, str, (uint32_t) size + sc_buf_8_len('\0'));
}
void sc_buf_put_str_len(struct sc_buf *buf, const char *str, int len)
{
assert(len > 0);
if (str == NULL) {
sc_buf_put_32(buf, -1);
sc_buf_put_32(buf, UINT32_MAX);
return;
}
sc_buf_put_32(buf, len);
sc_buf_put_raw(buf, str, len);
sc_buf_put_32(buf, (uint32_t) len);
sc_buf_put_raw(buf, str, (uint32_t) len);
sc_buf_put_8(buf, '\0');
}
@ -687,7 +685,7 @@ void sc_buf_put_fmt(struct sc_buf *buf, const char *fmt, ...)
}
if (rc >= quota) {
if (!sc_buf_reserve(buf, rc)) {
if (!sc_buf_reserve(buf, (uint32_t) rc)) {
return;
}
@ -705,7 +703,7 @@ void sc_buf_put_fmt(struct sc_buf *buf, const char *fmt, ...)
}
sc_buf_set_32_at(buf, pos, rc);
sc_buf_set_32_at(buf, pos, (uint32_t) rc);
sc_buf_mark_write(buf, rc + sc_buf_32_len(0) + sc_buf_8_len('\0'));
}
@ -728,7 +726,7 @@ void sc_buf_put_text(struct sc_buf *buf, const char *fmt, ...)
}
if (rc >= quota) {
if (!sc_buf_reserve(buf, rc)) {
if (!sc_buf_reserve(buf, (uint32_t) rc)) {
sc_buf_set_wpos(buf, pos);
return;
}

19
buffer/sc_buf.h
View File

@ -361,16 +361,17 @@ void sc_buf_put_raw(struct sc_buf *buf, const void *ptr, uint32_t len);
*/
// clang-format off
static inline uint32_t sc_buf_bool_len(bool val) { return 1;}
static inline uint32_t sc_buf_8_len(uint8_t val) {return 1;}
static inline uint32_t sc_buf_16_len(uint16_t val){return 2;}
static inline uint32_t sc_buf_32_len(uint32_t val){return 4;}
static inline uint32_t sc_buf_64_len(uint64_t val){return 8;}
static inline uint32_t sc_buf_double_len(double val){return 8;}
static inline uint32_t sc_buf_bool_len(bool val) {(void) val; return 1;}
static inline uint32_t sc_buf_8_len(uint8_t val) {(void) val; return 1;}
static inline uint32_t sc_buf_16_len(uint16_t val){(void) val; return 2;}
static inline uint32_t sc_buf_32_len(uint32_t val){(void) val; return 4;}
static inline uint32_t sc_buf_64_len(uint64_t val){(void) val; return 8;}
static inline uint32_t sc_buf_double_len(double val){(void) val; return 8;}
// clang-format on
static inline uint32_t sc_buf_blob_len(void *ptr, uint32_t len)
{
(void) ptr;
assert(len <= INT32_MAX - 4);
return len + sc_buf_32_len(len);
@ -378,13 +379,15 @@ static inline uint32_t sc_buf_blob_len(void *ptr, uint32_t len)
static inline uint32_t sc_buf_str_len(const char *str)
{
const uint32_t bytes = sc_buf_32_len(UINT32_MAX) + sc_buf_8_len('\0');
if (str == NULL) {
return sc_buf_32_len(-1);
return sc_buf_32_len(UINT32_MAX);
}
assert(strlen(str) <= INT32_MAX - 5);
return sc_buf_32_len(-1) + strlen(str) + sc_buf_8_len('\0');
return bytes + (uint32_t) strlen(str);
}
#endif

4
crc32/sc_crc32.c
View File

@ -34,9 +34,9 @@
1.2 2020 Added gcc intrinsics, fixed alignment issues.
*/
#include <memory.h>
#include "sc_crc32.h"
#include <stddef.h>
#include <stdint.h>
/* CRC-32C (iSCSI) polynomial in reversed bit order. */
#define CRC32_POLY 0x82f63b78

4
ini/sc_ini.c
View File

@ -79,7 +79,7 @@ static char *trim_bom(char *str)
}
int sc_ini_parse(void *arg, sc_ini_on_item on_item, void *arg1,
char *(*next_line)(void *arg, char *buf, size_t size))
char *(*next_line)(void *, char *, size_t))
{
int rc = 0, line = 0;
char buf[SC_INI_MAX_LINE_LEN];
@ -129,7 +129,7 @@ int sc_ini_parse(void *arg, sc_ini_on_item on_item, void *arg1,
static char *file_next_line(void *p, char *buf, size_t size)
{
return fgets(buf, size, (FILE *) p);
return fgets(buf, (int) size, (FILE *) p);
}
static char *string_next_line(void *p, char *buf, size_t size)

3
logger/sc_log.c
View File

@ -26,7 +26,6 @@
#include <errno.h>
#include <stdarg.h>
#include <string.h>
#include <time.h>
#ifndef thread_local
@ -236,7 +235,7 @@ int sc_log_set_file(const char *prev_file, const char *current_file)
goto error;
}
sc_log.file_size = size;
sc_log.file_size = (size_t) size;
sc_log.fp = fp;
goto out;

6
logger/sc_log.h
View File

@ -42,7 +42,7 @@ enum sc_log_level
// clang-format off
const static struct sc_log_level_pair
{
const int id;
const enum sc_log_level id;
const char *str;
} sc_log_levels[] = {
{SC_LOG_DEBUG, "DEBUG"},
@ -135,7 +135,7 @@ int sc_log_set_callback(sc_log_callback cb, void *arg);
int sc_log_log(enum sc_log_level level, const char *fmt, ...);
/**
* Max file size to rotate.
* Max file size to rotate, should not be more than 4 GB.
*/
#define SC_LOG_FILE_SIZE (2 * 1024 * 1024)
@ -144,6 +144,7 @@ int sc_log_log(enum sc_log_level level, const char *fmt, ...);
* in the log line.
*/
#ifdef SC_LOG_PRINT_FILE_NAME
#define sc_log_ap(fmt, ...) \
"(%s:%d) " fmt, strrchr("/" __FILE__, '/') + 1, __LINE__, \
__VA_ARGS__
@ -151,7 +152,6 @@ int sc_log_log(enum sc_log_level level, const char *fmt, ...);
#define sc_log_ap(fmt, ...) fmt, __VA_ARGS__
#endif
/**
* Printf-style format
* e.g

3
map/sc_map.c
View File

@ -1,8 +1,5 @@
#include "sc_map.h"
#include <stdlib.h>
#include <string.h>
#ifndef SC_SIZE_MAX
#define SC_SIZE_MAX UINT32_MAX
#endif

4
map/sc_map.h
View File

@ -75,8 +75,8 @@
uint32_t sc_map_size_##name(struct sc_map_##name *map); \
void sc_map_clear_##name(struct sc_map_##name *map); \
bool sc_map_put_##name(struct sc_map_##name *map, K key, V val); \
bool sc_map_get_##name(struct sc_map_##name *map, K key, V *value); \
bool sc_map_del_##name(struct sc_map_##name *map, K key, V *value);
bool sc_map_get_##name(struct sc_map_##name *map, K key, V *val); \
bool sc_map_del_##name(struct sc_map_##name *map, K key, V *val);
#define sc_map_foreach(map, K, V) \
for (uint32_t __i = 0, __b = 0; __i < (map)->cap; __i++) \

2
math/math_test.c
View File

@ -14,6 +14,8 @@ void test1()
char *t;
char buf[32];
assert(sc_math_min(199, 299) == 199);
assert(sc_math_max(199, 299) == 299);
assert(sc_math_is_pow2(0) == false);
x = sc_math_to_pow2(0);

4
math/sc_math.h
View File

@ -28,8 +28,8 @@
#include <stddef.h>
#include <stdint.h>
#define sc_math_max(a, b) ((a) > (b) ? (a) : (b))
#define sc_math_min(a, b) ((a) > (b) ? (b) : (a))
#define sc_math_max(a, b) (((a) > (b)) ? (a) : (b))
#define sc_math_min(a, b) (((a) > (b)) ? (b) : (a))
/**
* @param num num

2
memory-map/sc_mmap.c
View File

@ -2,8 +2,6 @@
#include "sc_mmap.h"
#include <errno.h>
#include <fcntl.h>
#include <stdint.h>
#include <string.h>
#include <sys/stat.h>

4
option/sc_option.c
View File

@ -29,7 +29,7 @@
char sc_option_at(struct sc_option *opt, int index, char **value)
{
char id = '?';
int len;
size_t len;
char *pos;
const char *curr, *name;
@ -59,7 +59,7 @@ char sc_option_at(struct sc_option *opt, int index, char **value)
for (int i = 0; i < opt->count; i++) {
curr = opt->argv[index] + 2; // Skip '--'
name = opt->options[i].name;
len = (int) (pos - curr);
len = (pos - curr);
if (name == NULL) {
continue;

10
queue/queue_test.c
View File

@ -151,6 +151,16 @@ void test1(void)
sc_queue_destroy(p);
sc_queue_destroy(p);
assert(sc_queue_create(p, 0) == true);
sc_queue_add_first(p, 100);
sc_queue_add_first(p, 200);
sc_queue_add_first(p, 300);
sc_queue_add_first(p, 400);
sc_queue_add_first(p, 500);
assert(sc_queue_at(p, 0) == 500);
assert(sc_queue_at(p, 4) == 100);
sc_queue_destroy(p);
}
int main(int argc, char *argv[])

8
queue/sc_queue.c
View File

@ -24,10 +24,8 @@
#include "sc_queue.h"
#include <stdbool.h>
#ifndef SC_SIZE_MAX
#define SC_SIZE_MAX SIZE_MAX
#define SC_SIZE_MAX SIZE_MAX
#endif
#define SC_MAX_CAP ((SC_SIZE_MAX - sizeof(struct sc_queue)) / 2ul)
@ -123,9 +121,9 @@ bool sc_queue_expand(void **q, size_t elem_size)
* | |
* Step 0 : | 2 | 3 | - | 1 | // tmp->cap : 4
* Step 1 : | 2 | 3 | - | 1 | - | - | - | - | // realloc
* Step 2 : | 2 | 3 | - | 1 | 1 | - | - | - | // mempcy
* Step 2 : | 2 | 3 | - | 1 | 1 | - | - | - | // memcpy
* Step 3 : | 2 | 2 | 3 | 1 | 1 | - | - | - | // memmove
* Step 4 : | 1 | 2 | 3 | 1 | 1 | - | - | - | // mempcy
* Step 4 : | 1 | 2 | 3 | 1 | 1 | - | - | - | // memcpy
* Step 5 : | 1 | 2 | 3 | - | - | - | - | - | // tmp->last = cap - 1;
* | |
* first last

4
queue/sc_queue.h
View File

@ -154,14 +154,14 @@ bool sc_queue_expand(void **q, size_t elem_size);
#define sc_queue_next(q, i) (((i) + 1) & (sc_queue_meta(q)->cap - 1))
/**
* Returns element at 'i'th position, so regular loops are possible :
* Returns element at index 'i', so regular loops are possible :
*
* for (size_t i = 0; i < sc_queue_size(q); i++) {
* printf("%d" \n, sc_queue_at(q, i));
* }
*
* @param q Queue pointer
* @return element at 'i'th position
* @return element at index i
*/
#define sc_queue_at(q, i) \
(q)[((sc_queue_meta(q)->first) + (i)) & (sc_queue_cap(q) - 1)]

1
rc4/sc_rc4.c
View File

@ -25,7 +25,6 @@
#include "sc_rc4.h"
#include <memory.h>
#include <stdint.h>
void sc_rc4_init(struct sc_rc4 *rc4, const unsigned char rand[256])
{

78
signal/sc_signal.c
View File

@ -24,17 +24,14 @@
#include "sc_signal.h"
#include <signal.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#if defined(_WIN32)
#include <WinSock2.h>
#include <WinSock2.h>
volatile SOCKET sc_signal_shutdown_fd;
#else
volatile sig_atomic_t sc_signal_shutdown_fd;
@ -63,6 +60,8 @@ volatile sig_atomic_t sc_signal_will_shutdown;
(size) == 1 ? va_arg(va, int) : \
0
#define PSIZE sizeof(void*) == sizeof(unsigned long long) ? 3 : 2
int sc_signal_vsnprintf(char *buf, size_t size, const char *fmt, va_list va)
{
size_t len;
@ -98,15 +97,15 @@ int sc_signal_vsnprintf(char *buf, size_t size, const char *fmt, va_list va)
uint64_t u64 = get_uint(va, pos - orig);
do {
digits[31 - (len++)] = (char)('0' + (u64 % 10));
digits[31 - (len++)] = (char) ('0' + (u64 % 10));
} while (u64 /= 10UL);
} else if (*pos == 'd') {
int64_t i64 = get_int(va, pos - orig);
uint64_t u64 = i64 < 0 ? -i64 : i64;
uint64_t u64 = (uint64_t) (i64 < 0 ? -i64 : i64);
do {
digits[31 - (len++)] = (char)('0' + (char)(u64 % 10));
digits[31 - (len++)] = (char) ('0' + (char) (u64 % 10));
} while (u64 /= 10UL);
if (i64 < 0) {
@ -119,10 +118,9 @@ int sc_signal_vsnprintf(char *buf, size_t size, const char *fmt, va_list va)
str = &digits[32 - len];
break;
case 'p': {
char *arr = "0123456789abcdef";
const char *arr = "0123456789abcdef";
len = 0;
int s = (sizeof(void *) == sizeof(unsigned long long)) ? 3 : 2;
uint64_t u64 = get_uint(va, s);
uint64_t u64 = get_uint(va, PSIZE);
do {
digits[31 - (len++)] = arr[u64 % 16];
@ -173,15 +171,15 @@ int sc_signal_snprintf(char *buf, size_t size, const char *fmt, ...)
#if defined(_WIN32)
#define WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN
#include <Ws2tcpip.h>
#include <io.h>
#include <signal.h>
#include <windows.h>
#include <Ws2tcpip.h>
#include <io.h>
#include <signal.h>
#include <windows.h>
#pragma warning(disable : 4996)
#pragma comment(lib, "Ws2_32.lib")
#pragma warning(disable : 4996)
#pragma comment(lib, "Ws2_32.lib")
BOOL WINAPI sc_console_handler(DWORD type)
{
@ -296,7 +294,7 @@ int sc_signal_init()
#else
// clang-format off
// clang-format off
#include <unistd.h>
#ifdef HAVE_BACKTRACE
@ -304,51 +302,51 @@ int sc_signal_init()
static void *sc_instruction(ucontext_t *uc)
{
void* insp = NULL;
void* p = NULL;
#if defined(__APPLE__) && defined(MAC_OS_X_VERSION_10_6)
#if defined(_STRUCT_X86_THREAD_STATE64) && !defined(__i386__)
insp = (void *) uc->uc_mcontext->__ss.__rip;
p = (void *) uc->uc_mcontext->__ss.__rip;
#elif defined(__i386__)
insp = (void *) uc->uc_mcontext->__ss.__eip;
p = (void *) uc->uc_mcontext->__ss.__eip;
#else
insp = (void *) arm_thread_state64_get_pc(uc->uc_mcontext->__ss);
p = (void *) arm_thread_state64_get_pc(uc->uc_mcontext->__ss);
#endif
#elif defined(__linux__)
#if defined(__i386__) || ((defined(__x86_64__)) && defined(__ILP32__))
insp = (void *) uc->uc_mcontext.gregs[REG_EIP];
p = (void *) uc->uc_mcontext.gregs[REG_EIP];
#elif defined(__x86_64__)
insp = (void *) uc->uc_mcontext.gregs[REG_RIP];
p = (void *) uc->uc_mcontext.gregs[REG_RIP];
#elif defined(__ia64__)
insp = (void *) uc->uc_mcontext.sc_ip;
p = (void *) uc->uc_mcontext.sc_ip;
#elif defined(__arm__)
insp = (void *) uc->uc_mcontext.arm_pc;
p = (void *) uc->uc_mcontext.arm_pc;
#elif defined(__aarch64__)
insp = (void *) uc->uc_mcontext.pc;
p = (void *) uc->uc_mcontext.pc;
#endif
#elif defined(__FreeBSD__)
#if defined(__i386__)
insp = (void *) uc->uc_mcontext.mc_eip;
p = (void *) uc->uc_mcontext.mc_eip;
#elif defined(__x86_64__)
insp = (void *) uc->uc_mcontext.mc_rip;
p = (void *) uc->uc_mcontext.mc_rip;
#endif
#elif defined(__OpenBSD__)
#if defined(__i386__)
insp = (void *) uc->sc_eip;
p = (void *) uc->sc_eip;
#elif defined(__x86_64__)
insp = (void *) uc->sc_rip;
p = (void *) uc->sc_rip;
#endif
#elif defined(__NetBSD__)
#if defined(__i386__)
insp = (void *) uc->uc_mcontext.__gregs[_REG_EIP];
p = (void *) uc->uc_mcontext.__gregs[_REG_EIP];
#elif defined(__x86_64__)
insp = (void *) uc->uc_mcontext.__gregs[_REG_RIP];
p = (void *) uc->uc_mcontext.__gregs[_REG_RIP];
#endif
#elif defined(__DragonFly__)
insp = (void *) uc->uc_mcontext.mc_rip;
p = (void *) uc->uc_mcontext.mc_rip;
#endif
return insp;
return p;
}
#endif
@ -384,7 +382,7 @@ static void sc_signal_on_shutdown(int sig)
if (sc_signal_shutdown_fd != -1) {
sc_signal_log(fd, buf, sizeof(buf), "Sending shutdown command. \n");
rc = write(sc_signal_shutdown_fd, (void *) &(int){1}, 1);
rc = (int) write(sc_signal_shutdown_fd, (void *) &(int){1}, 1);
if (rc != 1) {
sc_signal_log(fd, buf, sizeof(buf),
"Failed to send shutdown command, "
@ -400,6 +398,8 @@ static void sc_signal_on_shutdown(int sig)
static void sc_signal_on_fatal(int sig, siginfo_t *info, void *context)
{
(void) info;
int fd = sc_signal_log_fd != -1 ? sc_signal_log_fd : STDERR_FILENO;
char buf[4096], *sig_str;
@ -432,7 +432,7 @@ static void sc_signal_on_fatal(int sig, siginfo_t *info, void *context)
sc_signal_log(fd, buf, sizeof(buf),
"\n----------------- CRASH REPORT ---------------- \n");
#ifdef HAVE_BACKTRACE
#ifdef HAVE_BACKTRACE
void *caller = sc_instruction((ucontext_t *) context);
int trace_size;
void *trace[100];
@ -441,7 +441,7 @@ static void sc_signal_on_fatal(int sig, siginfo_t *info, void *context)
trace_size = backtrace(trace, 100);
backtrace_symbols_fd(trace, trace_size, fd);
#endif
#endif
sc_signal_log(fd, buf, sizeof(buf),
"\n--------------- CRASH REPORT END -------------- \n");
@ -498,5 +498,5 @@ void sc_signal_log(int fd, char *buf, size_t len, char *fmt, ...)
written = sc_signal_vsnprintf(buf, len, fmt, args);
va_end(args);
(void) write(fd, buf, written);
(void) write(fd, buf, (size_t) written);
}

1
signal/signal_test.c
View File

@ -1,7 +1,6 @@
#include "sc_signal.h"
#include <assert.h>
#include <stddef.h>
#include <string.h>
void test1()

33
socket/sc_sock.c
View File

@ -45,6 +45,8 @@
#define SC_EINPROGRESS WSAEINPROGRESS
#define SC_EINTR WSAEINTR
typedef int socklen_t;
static int sc_sock_err()
{
return WSAGetLastError();
@ -77,7 +79,6 @@ int sc_sock_set_blocking(struct sc_sock *sock, bool blocking)
#else
#include <arpa/inet.h>
#include <netdb.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <sys/un.h>
#include <unistd.h>
@ -202,9 +203,9 @@ static int sc_sock_bind_unix(struct sc_sock *sock, const char *host)
static int sc_sock_bind(struct sc_sock *sock, const char *host, const char *prt)
{
const int bf = SC_SOCK_BUF_SIZE;
const int sz = sizeof(bf);
const socklen_t sz = sizeof(bf);
int rc = 0, rv = 0;
int rc, rv = 0;
struct addrinfo *servinfo = NULL;
struct addrinfo hints = {.ai_family = sock->family,
.ai_socktype = SOCK_STREAM};
@ -351,9 +352,9 @@ int sc_sock_connect(struct sc_sock *sock, const char *dest_addr,
const char *source_port)
{
const int bf = SC_SOCK_BUF_SIZE;
const int sz = sizeof(bf);
const socklen_t sz = sizeof(bf);
int rc = 0, rv = SC_SOCK_OK;
int rc, rv = SC_SOCK_OK;
struct addrinfo inf = {.ai_family = AF_UNSPEC, .ai_socktype = SOCK_STREAM};
struct addrinfo *servinfo = NULL, *bindinfo = NULL, *p, *s;
@ -491,7 +492,7 @@ int sc_sock_send(struct sc_sock *sock, char *buf, int len, int flags)
}
retry:
n = send(sock->fdt.fd, buf, len, flags);
n = send(sock->fdt.fd, buf, (size_t) len, flags);
if (n == SC_ERR) {
int err = sc_sock_err();
if (err == SC_EINTR) {
@ -520,7 +521,7 @@ int sc_sock_recv(struct sc_sock *sock, char *buf, int len, int flags)
}
retry:
n = recv(sock->fdt.fd, buf, len, flags);
n = recv(sock->fdt.fd, buf, (size_t) len, flags);
if (n == 0) {
return SC_SOCK_ERROR;
} else if (n == SC_ERR) {
@ -543,7 +544,7 @@ retry:
int sc_sock_accept(struct sc_sock *sock, struct sc_sock *in)
{
const int bf = SC_SOCK_BUF_SIZE;
const int sz = sizeof(bf);
const socklen_t sz = sizeof(bf);
int rc;
sc_sock_int fd;
@ -613,7 +614,7 @@ const char *sc_sock_error(struct sc_sock *sock)
}
static const char *sc_sock_addr(struct sc_sock *sock, int af, void *cp,
char *buf, int len)
char *buf, socklen_t len)
{
const char *dest;
@ -628,7 +629,7 @@ static const char *sc_sock_addr(struct sc_sock *sock, int af, void *cp,
static const char *sc_sock_print_storage(struct sc_sock *sock,
struct sockaddr_storage *storage,
char *buf, int len)
char *buf, size_t len)
{
const char *dst;
struct sockaddr_in *addr;
@ -664,7 +665,7 @@ static const char *sc_sock_print_storage(struct sc_sock *sock,
return buf;
}
const char *sc_sock_local_str(struct sc_sock *sock, char *buf, int len)
const char *sc_sock_local_str(struct sc_sock *sock, char *buf, size_t len)
{
int rc;
struct sockaddr_storage st;
@ -680,7 +681,7 @@ const char *sc_sock_local_str(struct sc_sock *sock, char *buf, int len)
return sc_sock_print_storage(sock, &st, buf, len);
}
const char *sc_sock_remote_str(struct sc_sock *sock, char *buf, int len)
const char *sc_sock_remote_str(struct sc_sock *sock, char *buf, size_t len)
{
int rc;
struct sockaddr_storage st;
@ -696,7 +697,7 @@ const char *sc_sock_remote_str(struct sc_sock *sock, char *buf, int len)
return sc_sock_print_storage(sock, &st, buf, len);
}
void sc_sock_print(struct sc_sock *sock, char *buf, int len)
void sc_sock_print(struct sc_sock *sock, char *buf, size_t len)
{
char l[128];
char r[128];
@ -840,7 +841,7 @@ int sc_sock_pipe_init(struct sc_sock_pipe *p, int type)
}
p->fdt.type = type;
p->fdt.op = 0;
p->fdt.op = SC_SOCK_NONE;
p->fdt.fd = p->fds[0];
return 0;
@ -865,7 +866,7 @@ int sc_sock_pipe_term(struct sc_sock_pipe *p)
return rc;
}
int sc_sock_pipe_write(struct sc_sock_pipe *p, void *data, int len)
int sc_sock_pipe_write(struct sc_sock_pipe *p, void *data, unsigned int len)
{
ssize_t n;
char *b = data;
@ -885,7 +886,7 @@ retry:
return n;
}
int sc_sock_pipe_read(struct sc_sock_pipe *p, void *data, int len)
int sc_sock_pipe_read(struct sc_sock_pipe *p, void *data, unsigned int len)
{
ssize_t n;
char *b = data;

10
socket/sc_sock.h
View File

@ -101,9 +101,9 @@ int sc_sock_send(struct sc_sock* sock, char* buf, int len, int flags);
int sc_sock_recv(struct sc_sock* sock, char* buf, int len, int flags);
const char* sc_sock_error(struct sc_sock* sock);
const char *sc_sock_local_str(struct sc_sock *sock, char *buf, int len);
const char *sc_sock_remote_str(struct sc_sock *sock, char *buf, int len);
void sc_sock_print(struct sc_sock* sock, char* buf, int len);
const char *sc_sock_local_str(struct sc_sock *sock, char *buf, size_t len);
const char *sc_sock_remote_str(struct sc_sock *sock, char *buf, size_t len);
void sc_sock_print(struct sc_sock* sock, char* buf, size_t len);
struct sc_sock_pipe
@ -114,8 +114,8 @@ struct sc_sock_pipe
int sc_sock_pipe_init(struct sc_sock_pipe* pipe, int type);
int sc_sock_pipe_term(struct sc_sock_pipe* pipe);
int sc_sock_pipe_write(struct sc_sock_pipe* pipe, void* data, int len);
int sc_sock_pipe_read(struct sc_sock_pipe* pipe, void* data, int len);
int sc_sock_pipe_write(struct sc_sock_pipe* pipe, void* data, unsigned int len);
int sc_sock_pipe_read(struct sc_sock_pipe* pipe, void* data, unsigned int len);
#define sc_sock_on_error(...)

2
socket/sock_test.c
View File

@ -3,7 +3,6 @@
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#if defined(_WIN32) || defined(_WIN64)
#include <synchapi.h>
@ -371,7 +370,6 @@ void test_pipe(void)
}
#ifdef SC_HAVE_WRAP
#include <unistd.h>
bool fail_close = false;
int __real_close(int fd);

12
string/sc_str.c
View File

@ -25,10 +25,10 @@
#include "sc_str.h"
#include <assert.h>
#include <stdarg.h>
#include <stddef.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stddef.h>
/**
* String with 'length' at the start of the allocated memory
@ -65,7 +65,7 @@ char *sc_str_create(const char *str)
return NULL;
}
return sc_str_create_len(str, size);
return sc_str_create_len(str, (uint32_t) size);
}
char *sc_str_create_len(const char *str, uint32_t len)
@ -105,7 +105,7 @@ char *sc_str_create_va(const char *fmt, va_list va)
return NULL;
}
str->len = rc;
str->len = (uint32_t) rc;
if (rc < sizeof(tmp)) {
memcpy(str->buf, tmp, str->len + 1);
@ -276,7 +276,7 @@ bool sc_str_trim(char **str, const char *list)
}
if (start != *str || end != (*str) + len) {
start = sc_str_create_len(start, end - start);
start = sc_str_create_len(start, (uint32_t) (end - start));
if (start == NULL) {
return false;
}
@ -362,7 +362,7 @@ bool sc_str_replace(char **str, const char *replace, const char *with)
return false;
}
dest->len = size;
dest->len = (uint32_t) size;
tmp = dest->buf;
while (count--) {

9
string/sc_str.h
View File

@ -28,14 +28,13 @@
#include <stdarg.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdlib.h>
#ifdef SC_HAVE_CONFIG_H
#include "sc_config.h"
#include "sc_config.h"
#else
#define sc_str_malloc malloc
#define sc_str_realloc realloc
#define sc_str_free free
#define sc_str_malloc malloc
#define sc_str_realloc realloc
#define sc_str_free free
#endif
/**

1
string/str_test.c
View File

@ -2,6 +2,7 @@
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#ifdef SC_HAVE_WRAP

10
thread/sc_thread.c
View File

@ -109,24 +109,24 @@ int sc_thread_stop(struct sc_thread *thread, void **ret)
int sc_thread_start(struct sc_thread *thread, void *(*fn)(void *), void *arg)
{
int rc;
pthread_attr_t hndl;
pthread_attr_t attr;
rc = pthread_attr_init(&hndl);
rc = pthread_attr_init(&attr);
if (rc != 0) {
strncpy(thread->err, strerror(rc), sizeof(thread->err));
return -1;
}
// This may only fail with EINVAL.
pthread_attr_setdetachstate(&hndl, PTHREAD_CREATE_JOINABLE);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
rc = pthread_create(&thread->id, &hndl, fn, arg);
rc = pthread_create(&thread->id, &attr, fn, arg);
if (rc != 0) {
strncpy(thread->err, strerror(rc), sizeof(thread->err));
}
// This may only fail with EINVAL.
pthread_attr_destroy(&hndl);
pthread_attr_destroy(&attr);
return rc;
}

4
thread/sc_thread.h
View File

@ -55,14 +55,14 @@ struct sc_thread
void sc_thread_init(struct sc_thread* thread);
/**
* @param thread thred
* @param thread thread
* @return '0' on success,
* '-1' on error, call 'sc_thread_err()' for error string.
*/
int sc_thread_term(struct sc_thread* thread);
/**
* @param thread thred
* @param thread thread
* @return '0' on success,
* '-1' on error, call 'sc_thread_err()' for error string.
*/

4
time/sc_time.c
View File

@ -98,8 +98,8 @@ uint64_t sc_time_mono_ms()
rc = clock_gettime(CLOCK_MONOTONIC, &ts);
assert(rc == 0);
return (int64_t)((int64_t) ts.tv_sec * 1000 +
(int64_t) ts.tv_nsec / 1000000);
return (uint64_t)((uint64_t) ts.tv_sec * 1000 +
(uint64_t) ts.tv_nsec / 1000000);
#endif
}

5
timer/sc_timer.c
View File

@ -119,7 +119,8 @@ static bool expand(struct sc_timer *timer)
uint64_t sc_timer_add(struct sc_timer *timer, uint64_t timeout, uint64_t type,
void *data)
{
const size_t pos = (timeout / TICK + timer->head) & (WHEEL_COUNT - 1);
const uint32_t offset = (uint32_t)(timeout / TICK + timer->head);
const uint32_t pos = offset & (WHEEL_COUNT - 1);
uint64_t id;
uint32_t seq, index, wheel_pos;
@ -177,7 +178,7 @@ uint64_t sc_timer_timeout(struct sc_timer *timer, uint64_t timestamp, void *arg,
const uint64_t time = timestamp - timer->timestamp;
uint32_t wheel, base;
uint32_t head = timer->head;
uint32_t wheels = min(time / TICK, WHEEL_COUNT);
uint32_t wheels = (uint32_t) (min(time / TICK, WHEEL_COUNT));
if (wheels == 0) {
return min(TICK - time, TICK);

37
url/sc_url.c
View File

@ -38,14 +38,14 @@ struct sc_url *sc_url_create(const char *str)
int diff;
unsigned long val;
size_t len, full_len, parts_len;
size_t scheme_len = 0, authority_len = 0, userinfo_len = 0;
size_t host_len = 0, port_len = 0, path_len = 0;
size_t scheme_len, authority_len = 0, userinfo_len = 0;
size_t host_len = 0, port_len = 0, path_len;
size_t query_len = 0, fragment_len = 0;
char *scheme = "", *userinfo = "", *host = "", *port = "";
char *path = "", *query = "", *fragment = "";
char *scheme, *userinfo = "", *host = "", *port = "";
char *path, *query = "", *fragment = "";
char *ptr, *dest, *parse_end;
char* pos = (char*) str;
char *pos = (char *) str;
struct sc_url *url;
if (str == NULL || (ptr = strstr(pos, ":")) == NULL) {
@ -126,10 +126,10 @@ struct sc_url *sc_url_create(const char *str)
return NULL;
}
len = snprintf(url->buf, full_len, s1, scheme_len, scheme, authority_len,
authority, userinfo_len, userinfo, host_len, host, port_len,
port, path_len, path, query_len, query, fragment_len,
fragment);
len = (size_t) snprintf(url->buf, full_len, s1, scheme_len, scheme,
authority_len, authority, userinfo_len, userinfo,
host_len, host, port_len, port, path_len, path,
query_len, query, fragment_len, fragment);
assert(len == full_len - 1);
dest = url->buf + strlen(url->buf) + 1;
@ -137,18 +137,19 @@ struct sc_url *sc_url_create(const char *str)
scheme_len -= (scheme_len != 0); // Skip ":"
userinfo_len -= (userinfo_len != 0); // Skip "@"
diff = port_len != 0;
port_len -= diff; // Skip ":"
port += diff; // Skip ":"
port_len -= diff; // Skip ":"
port += diff; // Skip ":"
diff = (query_len != 0);
query_len -= diff; // Skip "?"
query += diff; // Skip "?"
query_len -= diff; // Skip "?"
query += diff; // Skip "?"
diff = (fragment_len != 0);
fragment_len -= diff; // Skip "#"
fragment += diff; // Skip "#"
fragment_len -= diff; // Skip "#"
fragment += diff; // Skip "#"
len = sprintf(dest, s2, scheme_len, scheme, 0, userinfo_len, userinfo, 0,
host_len, host, 0, port_len, port, 0, path_len, path, 0,
query_len, query, 0, fragment_len, fragment, 0);
len = (size_t) sprintf(dest, s2, scheme_len, scheme, 0, userinfo_len,
userinfo, 0, host_len, host, 0, port_len, port, 0,
path_len, path, 0, query_len, query, 0, fragment_len,
fragment, 0);
assert(len == parts_len - 1);
url->str = url->buf;