sled

чување 73c80cee9f275444cc60df65dbf0dae860d9e569
родитељ a130cc322d6a5d51d95ed95635e89b3a69d74643
Аутор: Страхиња Радић <contact@strahinja.org>
Датум:   Sun, 10 Mar 2024 16:21:39 +0100

Copy macros for strlcpy and strlcat from poe

Signed-off-by: Страхиња Радић <contact@strahinja.org>

Diffstat:
M
sled.c
 | 
250
+++++++++++++++----------------------------------------------------------------
M
util.h
 | 
22
++++++++++++++++++----

измењених датотека: 2, додавања: 65(+), брисања: 207(-)
diff --git a/sled.c b/sled.c
@@ -203,11 +203,7 @@ dirname(char* path)
 	result = malloc(MAXPATH);
 	memset(result, 0, MAXPATH);
 
-	if (strlcpy(result, path, MAXPATH) >= MAXPATH)
-	{
-		print_error(1, "strlcpy:%d: Overflow", __LINE__);
-		exit(1);
-	}
+	STRLCPY(path, result, MAXPATH);
 	p = result + strlen(result) - 1;
 	if (*p == '/')
 		*p = 0;
@@ -378,13 +374,8 @@ go_to_line_callback(struct DrawState* state)
 		u8_input = calloc(len + 1, UTF8REPMAX);
 		if (!u8_input)
 		{
-			if (strlcpy(state->error, errors[ERR_CANT_ALLOC],
-				    MAXBUFLINE)
-				>= MAXBUFLINE)
-			{
-				print_error(1, "strlcpy:%d: Overflow", __LINE__);
-				exit(1);
-			}
+			STRLCPY(errors[ERR_CANT_ALLOC], state->error,
+				MAXBUFLINE);
 			state->running = 0;
 			return;
 		}
@@ -392,13 +383,8 @@ go_to_line_callback(struct DrawState* state)
 		errno  = 0;
 		lineno = strtoul(u8_input, NULL, 10);
 		if (errno)
-			if (strlcpy(state->error, errors[ERR_INVALID_NUM],
-				    MAXBUFLINE)
-				>= MAXBUFLINE)
-			{
-				print_error(1, "strlcpy:%d: Overflow", __LINE__);
-				exit(1);
-			}
+			STRLCPY(errors[ERR_INVALID_NUM], state->error,
+				MAXBUFLINE);
 		if (!*state->error)
 		{
 			if (lineno > state->rows_count - 1)
@@ -464,13 +450,9 @@ handle_key_event(struct tb_event* ev, struct DrawState* state)
 				    && strchr("0123456789", (const char)ev->ch))
 				|| !IN(state->mode, M_INPUT_NUM))
 				input_insert_char(state, ev->ch);
-			else if (strlcpy(state->error, errors[ERR_INPUT_NONNUM],
-					 MAXBUFLINE)
-				>= MAXBUFLINE)
-			{
-				print_error(1, "strlcpy:%d: Overflow", __LINE__);
-				exit(1);
-			}
+			else
+				STRLCPY(errors[ERR_INPUT_NONNUM], state->error,
+					MAXBUFLINE);
 			return;
 		}
 	}
@@ -487,12 +469,7 @@ handle_key_event(struct tb_event* ev, struct DrawState* state)
 
 	if (IN(state->mode, M_HELP))
 	{
-		if (strlcpy(state->error, errors[ERR_DLG_OPEN], MAXBUFLINE)
-			>= MAXBUFLINE)
-		{
-			print_error(1, "strlcpy:%d: Overflow", __LINE__);
-			exit(1);
-		}
+		STRLCPY(errors[ERR_DLG_OPEN], state->error, MAXBUFLINE);
 		return;
 	}
 
@@ -540,12 +517,7 @@ handle_key_event(struct tb_event* ev, struct DrawState* state)
 		}
 	}
 
-	if (strlcpy(state->error, errors[ERR_UNKNOWN_KEY], MAXBUFLINE)
-		>= MAXBUFLINE)
-	{
-		print_error(1, "strlcpy:%d: Overflow", __LINE__);
-		exit(1);
-	}
+	STRLCPY(errors[ERR_UNKNOWN_KEY], state->error, MAXBUFLINE);
 }
 
 int
@@ -743,12 +715,7 @@ load_file(struct DrawState* state, long* lineno, long* col)
 		newchunk[row].text = newtext;
 	}
 
-	if (strlcpy(state->action, actions[ACT_READING], MAXBUFLINE)
-		>= MAXBUFLINE)
-	{
-		print_error(1, "strlcpy:%d: Overflow", __LINE__);
-		exit(1);
-	}
+	STRLCPY(actions[ACT_READING], state->action, MAXBUFLINE);
 
 	redraw_status(state);
 
@@ -947,21 +914,11 @@ reread_file(struct DrawState* state)
 	switch (result)
 	{
 	case LOAD_ERR_CANT_ALLOC:
-		if (strlcpy(state->error, errors[ERR_CANT_ALLOC], MAXBUFLINE)
-			>= MAXBUFLINE)
-		{
-			print_error(1, "strlcpy:%d: Overflow", __LINE__);
-			exit(1);
-		}
+		STRLCPY(errors[ERR_CANT_ALLOC], state->error, MAXBUFLINE);
 		state->running = 0;
 		break;
 	case LOAD_ERR_CANT_OPEN_FILE:
-		if (strlcpy(state->error, errors[ERR_CANT_OPEN], MAXBUFLINE)
-			>= MAXBUFLINE)
-		{
-			print_error(1, "strlcpy:%d: Overflow", __LINE__);
-			exit(1);
-		}
+		STRLCPY(errors[ERR_CANT_OPEN], state->error, MAXBUFLINE);
 		state->running = 0;
 		break;
 	default:;
@@ -992,12 +949,7 @@ save_file(struct DrawState* state)
 	if (!(buf = calloc(MAXBUFLINE, 1)))
 		return SAVE_ERR_CANT_ALLOC;
 
-	if (strlcpy(state->action, actions[ACT_WRITING], MAXBUFLINE)
-		>= MAXBUFLINE)
-	{
-		print_error(1, "strlcpy:%d: Overflow", __LINE__);
-		exit(1);
-	}
+	STRLCPY(actions[ACT_WRITING], state->action, MAXBUFLINE);
 	redraw_status(state);
 
 	errno = 0;
@@ -1123,12 +1075,8 @@ cancel_close(struct DrawState* state)
 	{
 		if (SEL_NOT_EMPTY(state))
 			clear_selection(state);
-		else if (strlcpy(state->error, errors[ERR_EXIT_KEY], MAXBUFLINE)
-			>= MAXBUFLINE)
-		{
-			print_error(1, "strlcpy:%d: Overflow", __LINE__);
-			exit(1);
-		}
+		else
+			STRLCPY(errors[ERR_EXIT_KEY], state->error, MAXBUFLINE);
 	}
 	else
 	{
@@ -1352,12 +1300,7 @@ exit_program(struct DrawState* state)
 	if (state->dirty)
 	{
 		SET(state->mode, M_PROMPT);
-		if (strlcpy(state->prompt, prompt_dirty, MAXBUFLINE)
-			>= MAXBUFLINE)
-		{
-			print_error(1, "strlcpy:%d: Overflow", __LINE__);
-			exit(1);
-		}
+		STRLCPY(prompt_dirty, state->prompt, MAXBUFLINE);
 		state->prompt_callback = quit_callback;
 	}
 	else
@@ -1829,12 +1772,7 @@ paste_from_paste(struct DrawState* state)
 	if (!newtext)
 	{
 		state->running = 0;
-		if (strlcpy(state->error, errors[ERR_CANT_ALLOC], MAXBUFLINE)
-			>= MAXBUFLINE)
-		{
-			print_error(1, "strlcpy:%d: Overflow", __LINE__);
-			exit(1);
-		}
+		STRLCPY(errors[ERR_CANT_ALLOC], state->error, MAXBUFLINE);
 		goto paste_from_paste_cleanup;
 	}
 	u32_strncpy(newtext, line->text, state->coord.col + 1);
@@ -1853,13 +1791,8 @@ paste_from_paste(struct DrawState* state)
 		if (!rest)
 		{
 			state->running = 0;
-			if (strlcpy(state->error, errors[ERR_CANT_ALLOC],
-				    MAXBUFLINE)
-				>= MAXBUFLINE)
-			{
-				print_error(1, "strlcpy:%d: Overflow", __LINE__);
-				exit(1);
-			}
+			STRLCPY(errors[ERR_CANT_ALLOC], state->error,
+				MAXBUFLINE);
 			goto paste_from_paste_cleanup;
 		}
 		u32_strncpy(rest, line->text + state->coord.col, MAXBUFLINE);
@@ -1955,12 +1888,7 @@ reread_or_callback(struct DrawState* state)
 	if (state->dirty)
 	{
 		SET(state->mode, M_PROMPT);
-		if (strlcpy(state->prompt, prompt_reread_dirty, MAXBUFLINE)
-			>= MAXBUFLINE)
-		{
-			print_error(1, "strlcpy:%d: Overflow", __LINE__);
-			exit(1);
-		}
+		STRLCPY(prompt_reread_dirty, state->prompt, MAXBUFLINE);
 		state->prompt_callback = reread_callback;
 	}
 	else
@@ -1978,13 +1906,8 @@ show_go_to_line(struct DrawState* state)
 		if (!(state->input = calloc(MAXINPUT, sizeof(uint32_t))))
 		{
 			state->running = 0;
-			if (strlcpy(state->error, errors[ERR_CANT_ALLOC],
-				    MAXBUFLINE)
-				>= MAXBUFLINE)
-			{
-				print_error(1, "strlcpy:%d: Overflow", __LINE__);
-				exit(1);
-			}
+			STRLCPY(errors[ERR_CANT_ALLOC], state->error,
+				MAXBUFLINE);
 			return 0;
 		}
 	}
@@ -2006,13 +1929,8 @@ show_replace(struct DrawState* state)
 		if (!(state->input = calloc(MAXINPUT, sizeof(uint32_t))))
 		{
 			state->running = 0;
-			if (strlcpy(state->error, errors[ERR_CANT_ALLOC],
-				    MAXBUFLINE)
-				>= MAXBUFLINE)
-			{
-				print_error(1, "strlcpy:%d: Overflow", __LINE__);
-				exit(1);
-			}
+			STRLCPY(errors[ERR_CANT_ALLOC], state->error,
+				MAXBUFLINE);
 			return 0;
 		}
 	}
@@ -2032,13 +1950,8 @@ show_search(struct DrawState* state)
 		if (!(state->search = calloc(MAXINPUT, sizeof(uint32_t))))
 		{
 			state->running = 0;
-			if (strlcpy(state->error, errors[ERR_CANT_ALLOC],
-				    MAXBUFLINE)
-				>= MAXBUFLINE)
-			{
-				print_error(1, "strlcpy:%d: Overflow", __LINE__);
-				exit(1);
-			}
+			STRLCPY(errors[ERR_CANT_ALLOC], state->error,
+				MAXBUFLINE);
 			return 0;
 		}
 	}
@@ -2051,13 +1964,8 @@ show_search(struct DrawState* state)
 		if (!(state->input = calloc(MAXINPUT, sizeof(uint32_t))))
 		{
 			state->running = 0;
-			if (strlcpy(state->error, errors[ERR_CANT_ALLOC],
-				    MAXBUFLINE)
-				>= MAXBUFLINE)
-			{
-				print_error(1, "strlcpy:%d: Overflow", __LINE__);
-				exit(1);
-			}
+			STRLCPY(errors[ERR_CANT_ALLOC], state->error,
+				MAXBUFLINE);
 			return 0;
 		}
 	}
@@ -2077,13 +1985,8 @@ show_search_replace(struct DrawState* state)
 		if (!(state->search = calloc(MAXINPUT, sizeof(uint32_t))))
 		{
 			state->running = 0;
-			if (strlcpy(state->error, errors[ERR_CANT_ALLOC],
-				    MAXBUFLINE)
-				>= MAXBUFLINE)
-			{
-				print_error(1, "strlcpy:%d: Overflow", __LINE__);
-				exit(1);
-			}
+			STRLCPY(errors[ERR_CANT_ALLOC], state->error,
+				MAXBUFLINE);
 			return 0;
 		}
 	}
@@ -2096,13 +1999,8 @@ show_search_replace(struct DrawState* state)
 		if (!(state->input = calloc(MAXINPUT, sizeof(uint32_t))))
 		{
 			state->running = 0;
-			if (strlcpy(state->error, errors[ERR_CANT_ALLOC],
-				    MAXBUFLINE)
-				>= MAXBUFLINE)
-			{
-				print_error(1, "strlcpy:%d: Overflow", __LINE__);
-				exit(1);
-			}
+			STRLCPY(errors[ERR_CANT_ALLOC], state->error,
+				MAXBUFLINE);
 			return 0;
 		}
 	}
@@ -2138,13 +2036,8 @@ simple_insert_line(struct DrawState* state)
 		if (!newchunk)
 		{
 			state->running = 0;
-			if (strlcpy(state->error, errors[ERR_CANT_ALLOC],
-				    MAXBUFLINE)
-				>= MAXBUFLINE)
-			{
-				print_error(1, "strlcpy:%d: Overflow", __LINE__);
-				exit(1);
-			}
+			STRLCPY(errors[ERR_CANT_ALLOC], state->error,
+				MAXBUFLINE);
 			return;
 		}
 		state->buffer = newchunk;
@@ -2157,14 +2050,8 @@ simple_insert_line(struct DrawState* state)
 			if (!newtext)
 			{
 				state->running = 0;
-				if (strlcpy(state->error,
-					    errors[ERR_CANT_ALLOC], MAXBUFLINE)
-					>= MAXBUFLINE)
-				{
-					print_error(1, "strlcpy:%d: Overflow",
-						__LINE__);
-					exit(1);
-				}
+				STRLCPY(errors[ERR_CANT_ALLOC], state->error,
+					MAXBUFLINE);
 				return;
 			}
 			line->text = newtext;
@@ -2259,13 +2146,8 @@ simple_yank(struct DrawState* state)
 		if (!newtext)
 		{
 			state->running = 0;
-			if (strlcpy(state->error, errors[ERR_CANT_ALLOC],
-				    MAXBUFLINE)
-				>= MAXBUFLINE)
-			{
-				print_error(1, "strlcpy:%d: Overflow", __LINE__);
-				exit(1);
-			}
+			STRLCPY(errors[ERR_CANT_ALLOC], state->error,
+				MAXBUFLINE);
 		}
 		newbuf[row].text   = newtext;
 		newbuf[row].length = 0;
@@ -2343,42 +2225,22 @@ write_file(struct DrawState* state)
 	switch (result)
 	{
 	case SAVE_ERR_CANT_ALLOC:
-		if (strlcpy(state->error, errors[ERR_CANT_ALLOC], MAXBUFLINE)
-			>= MAXBUFLINE)
-		{
-			print_error(1, "strlcpy:%d: Overflow", __LINE__);
-			exit(1);
-		}
+		STRLCPY(errors[ERR_CANT_ALLOC], state->error, MAXBUFLINE);
 		state->running = 0;
 		break;
 	case SAVE_ERR_CANT_OPEN_FILE:
-		if (strlcpy(state->error, errors[ERR_CANT_SAVE], MAXBUFLINE)
-			>= MAXBUFLINE)
-		{
-			print_error(1, "strlcpy:%d: Overflow", __LINE__);
-			exit(1);
-		}
+		STRLCPY(errors[ERR_CANT_SAVE], state->error, MAXBUFLINE);
 		state->running = 0;
 		break;
 	case SAVE_ERR_CANT_COPY_FILE:
-		if (strlcpy(state->error, errors[ERR_CANT_COPY], MAXBUFLINE)
-			>= MAXBUFLINE)
-		{
-			print_error(1, "strlcpy:%d: Overflow", __LINE__);
-			exit(1);
-		}
+		STRLCPY(errors[ERR_CANT_COPY], state->error, MAXBUFLINE);
 		state->running = 0;
 		break;
 	case SAVE_ERR_CANT_READLINK:
 	case SAVE_ERR_CANT_STAT_FILE:
 	case SAVE_ERR_CANT_SYMLINK:
 	case SAVE_ERR_CANT_UNLINK:
-		if (strlcpy(state->error, strerror(errno), MAXBUFLINE)
-			>= MAXBUFLINE)
-		{
-			print_error(1, "strlcpy:%d: Overflow", __LINE__);
-			exit(1);
-		}
+		STRLCPY(strerror(errno), state->error, MAXBUFLINE);
 		state->running = 0;
 		break;
 	case SAVE_ERR_NONE:
@@ -2521,21 +2383,9 @@ main(int argc, char** argv)
 
 		/* Backup filename is the target file + suffix if the file to
 		 * write is a symlink, otherwise file + suffix */
-		if (strlcpy(state.backup_filename,
-			    state.rfn_len > 0 ? state.real_filename
-					      : state.filename,
-			    MAXPATH)
-			>= MAXPATH)
-		{
-			print_error(1, "strlcpy:%d: Overflow", __LINE__);
-			exit(1);
-		}
-		if (strlcat(state.backup_filename, backup_suffix, MAXPATH)
-			>= MAXPATH)
-		{
-			print_error(1, "strlcat:%d: Overflow", __LINE__);
-			exit(1);
-		}
+		STRLCPY(state.rfn_len > 0 ? state.real_filename : state.filename,
+			state.backup_filename, MAXPATH);
+		STRLCAT(backup_suffix, state.backup_filename, MAXPATH);
 #ifdef __OpenBSD__
 		if (unveil(state.backup_filename, "rwc") < 0)
 		{
@@ -2639,13 +2489,7 @@ init_termbox:
 		if (!draw(&state))
 		{
 			state.running = 0;
-			if (strlcpy(state.error, errors[ERR_CANT_ALLOC],
-				    MAXBUFLINE)
-				>= MAXBUFLINE)
-			{
-				print_error(1, "strlcpy:%d: Overflow", __LINE__);
-				exit(1);
-			}
+			STRLCPY(errors[ERR_CANT_ALLOC], state.error, MAXBUFLINE);
 		}
 		tb_present();
 		result = tb_poll_event(&ev);
diff --git a/util.h b/util.h
@@ -8,6 +8,24 @@
 #define LEN(x)	  (sizeof(x) / sizeof(x[0]))
 #define MAX(a, b) ((a > b) ? a : b)
 #define MIN(a, b) ((a < b) ? a : b)
+#define STRLCAT(tail, head, totallen)                                     \
+	do                                                                \
+	{                                                                 \
+		if (strlcat(head, tail, totallen) >= totallen)            \
+		{                                                         \
+			print_error(1, "strlcat:%d: Overflow", __LINE__); \
+			exit(1);                                          \
+		}                                                         \
+	} while (0)
+#define STRLCPY(from, to, tolen)                                          \
+	do                                                                \
+	{                                                                 \
+		if (strlcpy(to, from, tolen) >= tolen)                    \
+		{                                                         \
+			print_error(1, "strlcpy:%d: Overflow", __LINE__); \
+			exit(1);                                          \
+		}                                                         \
+	} while (0)
 
 enum {
 	UNKNOWN_MODE,
@@ -49,12 +67,8 @@ enum { ACT_WRITING, ACT_READING };
 
 extern int utlerrno;
 
-#ifndef strlcpy
 size_t strlcpy(char* dst, const char* src, size_t dsize);
-#endif
-#ifndef strlcat
 size_t strlcat(char* dst, const char* src, size_t dsize);
-#endif
 
 size_t u8_string_to_unicode(uint32_t* us, const char* s, const size_t max);
 size_t unicode_string_to_u8(char* s, const uint32_t* us, const size_t max);