ufold

ufold.c (6920B)

---

 /* This program is licensed under the terms of GNU GPL v3 or (at your option)
  * any later version. Copyright (C) 2021-2024  Страхиња Радић.
  * See the file LICENSE for exact copyright and license details. */
 
 #include <errno.h>
 #include <stdarg.h>
 #include <stdio.h>
 #include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include "defs.h"
 #include "utf8.h"
 #include "version.h"
 
 #define COPYRIGHT                                                            \
 	("  This program is licensed under the terms of GNU GPL v3"          \
 	 " or (at your option)\n"                                            \
 	 "  any later version. Copyright (C) 2021-2024  Strahinya Radich.\n" \
 	 "  See the file LICENSE for exact copyright and license "           \
 	 "details.")
 
 char filename[MAXPATH];
 
 int
 usage(void)
 {
 	printf("Usage:\t%s -h | --help | -V | --full-version | -v | --version\n"
 	       "\t%s [-s | --spaces] [-w | --width=<cols>] [file]\n",
 		PROGRAMNAME, PROGRAMNAME);
 	return 0;
 }
 
 int
 error(const int code, const char* fmt, ...)
 {
 	char buf[MAXBUF];
 	va_list args;
 	va_start(args, fmt);
 	vsnprintf(buf, sizeof(buf), fmt, args);
 	va_end(args);
 	fprintf(stderr, "%s:%s: %s\n", PROGRAMNAME,
 		*filename ? filename : "(stdin)", buf);
 	return code;
 }
 
 int
 version(const int full)
 {
 	printf("%s %s, built on %s\n", PROGRAMNAME, VERSION, DATE);
 	if (full)
 		puts(COPYRIGHT);
 	return 0;
 }
 
 int
 starts_with(const char* s, const char* with)
 {
 	while (*s && *s == *with)
 	{
 		if (*s != *with)
 			return 0;
 		s++;
 		with++;
 	}
 	return *with == 0;
 }
 
 void
 fold_line_spaces(const u8* line, const int width)
 {
 	if (!line)
 		return;
 
 	/*
 	 * Idea:
 	 * 1. store characters in token until line is exhausted
 	 * 2. when ' ' or end of line is encountered:
 	 *    2,1, if token length > width, see if current column is 0:
 	 *         2.1.1. if it isn't, output newline and go to 2.1.2.
 	 *         2.1.2. (if it is) output chunks of length "width" until the
 	 *                end of token, then reset token
 	 *    2.2. if token length <= width, see if token length + current
 	 *         column exceed width
 	 *         2.2.1. if they do, output newline and go to 2.2.2.
 	 *         2.2.2. (if they don't) output token
 	 * 3. go to 1. unless line is exhausted
 	 */
 	const u8* pline = line;
 	u32 uch		= 0;
 	u32 token[MAXINPUTBUF];
 	u32* ptoken = NULL;
 	u8 u8ch[7];
 	size_t u8ch_len = 0;
 	size_t delta	= 0;
 	size_t len	= 0;
 	size_t col	= 0;
 
 	*token = 0;
 	ptoken = token;
 	/* 1. */
 	while (1)
 	{
 		u8_char_to_u32(&uch, pline, &len);
 		if (!len)
 			return;
 		*ptoken++ = uch;
 		pline += len;
 
 		/* 2. */
 		if (uch == (u32)L' ' || !uch)
 		{
 			if (ptoken - token > width)
 			{
 				/* 2.1. */
 				if (col > 0)
 				{
 					/* 2.1.1. */
 					printf("\n");
 					col = 0;
 				}
 
 				/* 2.1.2. */
 				*ptoken = 0;
 				ptoken	= token;
 				while (*ptoken)
 				{
 					u8ch_len
 						= u32_char_to_u8(u8ch, *ptoken);
 					if (!u8ch_len)
 						return;
 					u8ch[u8ch_len] = 0;
 
 					if (*ptoken == (u32)L'\t')
 						delta = 8 - (col % 8);
 					else
 						delta = 1;
 
 					if (col + delta > width)
 					{
 						printf("\n");
 						col = 0;
 						if (*ptoken == (u32)'\t')
 							delta = 8;
 						else
 							delta = 1;
 					}
 					printf("%s", u8ch);
 					col += delta;
 					ptoken += u8ch_len;
 				}
 				*token = 0;
 				ptoken = token;
 			}
 			else
 			{
 				/* 2.2. */
 				if (ptoken - token + col > width)
 				{
 					/* 2.2.1. */
 					printf("\n");
 					col = 0;
 				}
 
 				/* 2.2.2. */
 				*ptoken = 0;
 				ptoken	= token;
 				while (*ptoken)
 				{
 					u8ch_len
 						= u32_char_to_u8(u8ch, *ptoken);
 					if (!u8ch_len)
 						return;
 					u8ch[u8ch_len] = 0;
 
 					if (*ptoken == (u32)L'\t')
 						delta = 8 - (col % 8);
 					else
 						delta = 1;
 
 					printf("%s", u8ch);
 					col += delta;
 					ptoken++;
 				}
 				*token = 0;
 				ptoken = token;
 			}
 		}
 
 		/* 3. */
 		if (!uch)
 			break;
 	}
 }
 
 void
 fold_line_normal(const u8* line, const int width)
 {
 	if (!line)
 		return;
 
 	const u8* pline	      = line;
 	const u8* pline_inner = NULL;
 	u32 uch;
 	u8 u8_char[7];
 	u8* pu8_char = NULL;
 	size_t uch_len;
 	size_t delta = 0;
 	size_t col   = 0;
 
 	while (*pline)
 	{
 		/* convert only to get byte length */
 		u8_char_to_u32(&uch, pline, &uch_len);
 		if (!uch_len)
 			return;
 
 		pline_inner = pline;
 		pu8_char    = u8_char;
 		while (*pline_inner && pline_inner < pline + uch_len)
 			*pu8_char++ = *pline_inner++;
 		*pu8_char = 0;
 
 		if (uch == (u32)L'\t')
 			delta = 8 - (col % 8);
 		else
 			delta = 1;
 
 		if (col + delta > width)
 		{
 			printf("\n");
 			col = 0;
 			if (uch == (u32)L'\t')
 				delta = 8;
 			else
 				delta = 1;
 		}
 
 		printf("%s", u8_char);
 		col += delta;
 		pline += uch_len;
 	}
 }
 
 int
 main(int argc, char** argv)
 {
 	int argn     = 1;
 	char* carg   = NULL;
 	char** earg  = NULL;
 	int spaces   = 0;
 	int in_width = 0;
 	long width   = 80;
 	char width_buf[MAXBUF];
 
 	*filename = 0;
 	while (argn < argc)
 	{
 		carg = *(argv + argn);
 		if (!strcmp(carg, "-s") || !strcmp(carg, "--spaces"))
 			spaces = 1;
 		else if (!strcmp(carg, "-h") || !strcmp(carg, "--help"))
 			return usage();
 		else if (!strcmp(carg, "-V") || !strcmp(carg, "--full-version"))
 			return version(1);
 		else if (!strcmp(carg, "-v") || !strcmp(carg, "--version"))
 			return version(0);
 		else if (!strcmp(carg, "-w"))
 			in_width = 1;
 		else if (starts_with(carg, "--width="))
 		{
 			char* pcarg = carg + strlen("--width=");
 			strncpy(width_buf, pcarg, MAXBUF);
 			errno = 0;
 			earg  = &pcarg;
 			width = strtol(width_buf, earg, 10);
 			if (errno == ERANGE || errno == EINVAL
 				|| (**earg && *pcarg))
 				return error(EINVAL,
 					"Invalid numerical value "
 					"for --width: %s",
 					pcarg);
 			in_width = 0;
 		}
 		else if (in_width)
 		{
 			errno = 0;
 			earg  = &carg;
 			width = strtol(carg, earg, 10);
 			if (errno == ERANGE || errno == EINVAL
 				|| (**earg && *carg))
 				return error(EINVAL,
 					"Invalid numerical value "
 					"for -w: %s",
 					carg);
 			in_width = 0;
 		}
 		else if (starts_with(carg, "--width"))
 			return error(EINVAL,
 				"Parameter --width requires an "
 				"argument");
 		else if (*carg == '-' && *(carg + 1) != 0)
 			return usage();
 		else
 			strncpy(filename, carg, MAXPATH);
 		argn++;
 	}
 
 	if (width < 1)
 		return error(EINVAL, "Width too small");
 
 	if (!*filename)
 	{
 		filename[0] = '-';
 		filename[1] = 0;
 	}
 
 	FILE* input = NULL;
 	if (!*filename || (*filename == '-' && !*(filename + 1)))
 		input = stdin;
 	else
 		input = fopen(filename, "rt");
 	if (!input)
 		return error(errno, "Cannot open file");
 
 	char line[MAXINPUTBUF];
 	while (!feof(input))
 	{
 		if (!fgets(line, MAXINPUTBUF, input))
 		{
 			if (!feof(input))
 				return error(errno, "Error reading file");
 			else
 				break;
 		}
 		char* eol = strchr(line, '\n');
 		if (eol)
 			*eol = 0;
 		if (spaces)
 			fold_line_spaces((const u8*)line, width);
 		else
 			fold_line_normal((const u8*)line, width);
 		printf("\n");
 	}
 
 	fclose(input);
 	return 0;
 }