iomenu

interactive text selection menu
Log | Files | Refs | README | LICENSE

commit c383bef4af98a82331c2c6e56ff7964e3dbf690b
parent 09d7cdbc37907c01400e2193f4eafba74736aa7d
Author: Josuah Demangeon <josuah.demangeon@gandi.net>
Date:   Tue, 22 Aug 2017 19:48:53 +0200

utf8.[ch]: imported utf8len() and utf8check()

Diffstat:
Miomenu.c | 37+++++++++++++++++++------------------
Dutf.c | 332-------------------------------------------------------------------------------
Dutf.h | 18------------------
Autf8.c | 142+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Autf8.h | 5+++++
5 files changed, 166 insertions(+), 368 deletions(-)

diff --git a/iomenu.c b/iomenu.c @@ -12,9 +12,9 @@ #define CONTINUE 2 /* as opposed to EXIT_SUCCESS and EXIT_FAILURE */ -#define CONTROL(char) (char ^ 0x40) +#define CTL(char) (char ^ 0x40) #define ALT(char) (char + 0x80) -#define ESC(char) (char + 0x80 + 0x80) +#define CSI(char) (char + 0x80 + 0x80) #define MIN(X, Y) (((X) < (Y)) ? (X) : (Y)) static struct winsize ws; @@ -74,7 +74,7 @@ resetterminal(void) int i; /* clear terminal */ - for (i = 0; i < opt['l'] + 1; i++) + for (i = 0; i < rows + 1; i++) fputs("\r\033[K\n", stderr); /* reset cursor position */ @@ -322,61 +322,61 @@ key(void) top: switch (key) { - case CONTROL('C'): + case CTL('C'): return EXIT_FAILURE; - case CONTROL('U'): + case CTL('U'): input[0] = '\0'; filter(); break; - case CONTROL('W'): + case CTL('W'): removeword(); break; case 127: - case CONTROL('H'): /* backspace */ + case CTL('H'): /* backspace */ input[strlen(input) - 1] = '\0'; filter(); break; - case ESC('A'): /* up */ - case CONTROL('P'): + case CSI('A'): /* up */ + case CTL('P'): move(-1); break; - case ESC('B'): /* down */ - case CONTROL('N'): + case CSI('B'): /* down */ + case CTL('N'): move(+1); break; - case ESC('5'): + case CSI('5'): /* page up */ if (fgetc(stdin) != '~') break; /* FALLTHROUGH */ case ALT('v'): movepg(-1); break; - case ESC('6'): + case CSI('6'): /* page down */ if (fgetc(stdin) != '~') break; /* FALLTHROUGH */ - case CONTROL('V'): + case CTL('V'): movepg(+1); break; - case CONTROL('I'): /* tab */ + case CTL('I'): /* tab */ if (linec > 0) strcpy(input, matchv[current]); filter(); break; - case CONTROL('J'): /* enter */ - case CONTROL('M'): + case CTL('J'): /* enter */ + case CTL('M'): printselection(); return EXIT_SUCCESS; case ALT('['): - key = ESC(fgetc(stdin)); + key = CSI(fgetc(stdin)); goto top; case 033: /* escape / alt */ @@ -464,6 +464,7 @@ main(int argc, char *argv[]) input[0] = '\0'; while ((exitcode = key()) == CONTINUE) printscreen(); + printscreen(); resetterminal(); close(ttyfd); diff --git a/utf.c b/utf.c @@ -1,332 +0,0 @@ -/* - * Functions handling UTF-8 strings: - * - * stdin -> buffer -> stdout - * UTF-8 -> rune -> UTF-8 - * char[] -> long[] -> char[] - * - * Thanks to Connor Lane Smith for the idea of combining switches and - * binary masks. - */ - - -#include <stdio.h> -#include <string.h> -#include <stdlib.h> - -#include "utf.h" - - -/* --- lengths -------------------------------------------------------------- */ - - -/* - * Return the number of bytes in rune for the `n` next char in `s`, - * or 0 if ti is misencoded. - */ -int -utflen(char *s, int n) -{ - int len = 1; - int continuation_bytes = - (s[0] & 0x80) == 0x00 ? 0 : /* 0xxxxxxx */ - (s[0] & 0xc0) == 0x80 ? 1 : /* 10xxxxxx */ - (s[0] & 0xe0) == 0xc0 ? 2 : /* 110xxxxx */ - (s[0] & 0xf0) == 0xe0 ? 3 : /* 1110xxxx */ - (s[0] & 0xf8) == 0xf0 ? 4 : /* 11110xxx */ - (s[0] & 0xfc) == 0xf8 ? 5 : /* 111110xx */ - (s[0] & 0xfe) == 0xfc ? 6 : /* 1111110x */ - (s[0] & 0xff) == 0xfe ? 7 : /* 11111110 */ - 8; /* 11111111 */ - - if (continuation_bytes > 6 || continuation_bytes > n) - return 0; - - /* check if continuation bytes are 10xxxxxx and increment `len` */ - switch (continuation_bytes) { /* FALLTHROUGH */ - case 7: if ((s[6] & 0xc0) != 0x80) return 0; else len++; - case 6: if ((s[5] & 0xc0) != 0x80) return 0; else len++; - case 5: if ((s[4] & 0xc0) != 0x80) return 0; else len++; - case 4: if ((s[3] & 0xc0) != 0x80) return 0; else len++; - case 3: if ((s[2] & 0xc0) != 0x80) return 0; else len++; - case 2: if ((s[1] & 0xc0) != 0x80) return 0; else len++; - case 0: return len; - default: return 0; - } -} - - -/* - * Return the number of bytes required to encode `rune` into UTF-8, or - * 0 if rune is too long. - */ -int -runelen(long r) -{ - if (r <= 0x0000007f) return 1; - if (r <= 0x000007ff) return 2; - if (r <= 0x0000ffff) return 3; - if (r <= 0x001fffff) return 4; - if (r <= 0x03ffffff) return 5; - if (r <= 0x7fffffff) return 6; - return 0; -} - - -/* --- conversions ---------------------------------------------------------- */ - - -/* - * Sets `r` to a rune corresponding to the firsts `n` bytes of `s`. - * If `s` is misencoded, the rune is stored as a negative value. - * - * Return the number of bytes read. - */ -int -utftorune(long *r, char *s, int n) -{ - int len = utflen(s, n), i; - - /* first byte */ - switch (len) { - case 1: *r = s[0]; return 1; /* 0xxxxxxx */ - case 2: *r = s[0] & 0x1f; break; /* 110xxxxx */ - case 3: *r = s[0] & 0x0f; break; /* 1110xxxx */ - case 4: *r = s[0] & 0x07; break; /* 11110xxx */ - case 5: *r = s[0] & 0x03; break; /* 111110xx */ - case 6: *r = s[0] & 0x01; break; /* 1111110x */ - default: *r = -(unsigned char) s[0]; return 1; /* misencoded */ - } - - /* continuation bytes */ - for (i = 1; i < len; i++) - *r = (*r << 6) | (s[i] & 0x3f); /* 10xxxxxx */ - - /* overlong sequences */ - if (runelen(*r) != len) { - *r = -(unsigned char) s[0]; - return 1; - } - - return len; -} - - -/* - * Convert the utf char sring `src` of size `n` to a long string - * `dest`. - * - * Return the length of `i`. - */ -size_t -utftorunes(long *runes, char *utf, size_t n) -{ - size_t i, j; - - for (i = 0, j = 0; n > 0; i++) - j += utftorune(runes + i, utf + j, n - j); - - runes[i] = '\0'; - return i; -} - - -/* - * Encode the rune `r` in utf-8 in `s`, null-terminated. - * - * Return the number of bytes written, 0 if `r` is invalid. - */ -int -runetoutf(char *s, long r) -{ - switch (runelen(r)) { - case 1: - s[0] = r; /* 0xxxxxxx */ - s[1] = '\0'; - return 1; - case 2: - s[0] = 0xc0 | (0x1f & (r >> 6)); /* 110xxxxx */ - s[1] = 0x80 | (0x3f & (r)); /* 10xxxxxx */ - s[2] = '\0'; - return 2; - case 3: - s[0] = 0xe0 | (0x0f & (r >> 12)); /* 1110xxxx */ - s[1] = 0x80 | (0x3f & (r >> 6)); /* 10xxxxxx */ - s[2] = 0x80 | (0x3f & (r)); /* 10xxxxxx */ - s[3] = '\0'; - return 3; - case 4: - s[0] = 0xf0 | (0x07 & (r >> 18)); /* 11110xxx */ - s[1] = 0x80 | (0x3f & (r >> 12)); /* 10xxxxxx */ - s[2] = 0x80 | (0x3f & (r >> 6)); /* 10xxxxxx */ - s[3] = 0x80 | (0x3f & (r)); /* 10xxxxxx */ - s[4] = '\0'; - return 4; - case 5: - s[0] = 0xf8 | (0x03 & (r >> 24)); /* 111110xx */ - s[1] = 0x80 | (0x3f & (r >> 18)); /* 10xxxxxx */ - s[2] = 0x80 | (0x3f & (r >> 12)); /* 10xxxxxx */ - s[3] = 0x80 | (0x3f & (r >> 6)); /* 10xxxxxx */ - s[4] = 0x80 | (0x3f & (r)); /* 10xxxxxx */ - s[5] = '\0'; - return 5; - case 6: - s[0] = 0xfc | (0x01 & (r >> 30)); /* 1111110x */ - s[1] = 0x80 | (0x3f & (r >> 24)); /* 10xxxxxx */ - s[2] = 0x80 | (0x3f & (r >> 18)); /* 10xxxxxx */ - s[3] = 0x80 | (0x3f & (r >> 12)); /* 10xxxxxx */ - s[4] = 0x80 | (0x3f & (r >> 6)); /* 10xxxxxx */ - s[5] = 0x80 | (0x3f & (r)); /* 10xxxxxx */ - s[6] = '\0'; - return 6; - default: - s[0] = '\0'; - return 0; - } -} - - -/* - * Fill `s` with a printable representation of `r`. - * - * Return the width of the character. - */ -int -runetoprint(char *s, long r) -{ - if (r < 0) { - return sprintf(s, "[%02x]", (unsigned char) -r); - - } else if (r == 0x7f || r < ' ') { - return sprintf(s, "[%02lx]", r); - - } else if (!runeisprint(r)) { - return sprintf(s, "[%04lx]", r); - - } else { - runetoutf(s, r); - return 1; - } - - return 0; -} - - -/* --- standard library ----------------------------------------------------- */ - - -/* - * Returns 1 if the rune is a printable character and 0 if not. - */ -int -runeisprint(long r) -{ - return !( - (r != '\t' && r < ' ') || /* ascii control */ - (r == 0x7f) || - - (0x80 <= r && r < 0xa0) || /* unicode control */ - - (r > 0x10ffff) || /* outside range */ - - ((r & 0x00fffe) == 0x00fffe) || /* noncharacters */ - (0x00fdd0 <= r && r <= 0x00fdef) || - - (0x00e000 <= r && r <= 0x00f8ff) || /* private use */ - (0x0f0000 <= r && r <= 0x0ffffd) || - (0x100000 <= r && r <= 0x10fffd) || - - (0x00d800 <= r && r <= 0x00dfff) /* surrogates */ - ); -} - - -/* - * Read an utf string from `f` up to the first '\n' character or the - * end of the file. It is stored as a rune array into the newly - * allocated `r`. - * - * Return the length of `r`, or -1 if malloc fails or if the end of - * `f` is reached. - */ -size_t -getrunes(long **r, FILE *f) -{ - size_t slen, rlen = 0, size = BUFSIZ, i; - int c; - char *s; - - if (!(s = malloc(size))) return -1; - for (slen = 0; (c = fgetc(f)) != EOF && (c != '\n'); slen++) { - if (slen > size && !(s = realloc(s, ++size))) return -1; - s[slen] = c; - } - - if (!(*r = malloc(size * sizeof (long)))) return -1; - for (i = 0; i < slen; rlen++) - i += utftorune(*r + rlen, s + i, slen - i); - (*r)[rlen] = '\0'; - - free(s); - if (feof(f)) return -1; else return rlen; -} - - -long * -runescpy(long *dest, long *src) -{ - size_t i; - - for (i = 0; src[i] != '\0'; i++) - dest[i] = src[i]; - dest[i] = '\0'; - - return dest; -} - - -long * -runeschr(long *s, long r) -{ - size_t i; - - for (i = 0; s[i] != '\0'; i++) - if (s[i] == r) return s + i; - - return NULL; -} - - -long * -runescat(long *s1, long *s2) -{ - size_t i, j; - - for (i = 0; s1[i] != '\0'; i++); - for (j = 0; s2[j] != '\0'; j++) - s1[i + j] = s2[j]; - s1[i + j] = '\0'; - - return s1; -} - - -int -main() -{ - char s[BUFSIZ]; - long *r; - int len, i; - - for (len = 0; (len = getrunes(&r, stdin)) >= 0 && !feof(stdin); free(r)) { - for (i = 0; i < len; i++) { - runetoprint(s, r[i]); - fputs(s, stdout); - } - - putchar('\n'); - } - free(r); - - return 0; -} diff --git a/utf.h b/utf.h @@ -1,18 +0,0 @@ -/* lengths */ -int utflen(char *, int); -int runelen(long); - -/* conversions */ -int utftorune(long *, char *, int); -int utftorune(long *, char *, int); -int runetoutf(char *, long); -int runetoprint(char *, long); - - -/* standard library */ - -int runeisprint(long); -size_t getrunes(long **, FILE *); -long * runescpy(long *, long *); -long * runeschr(long *, long); -long * runescat(long *, long *); diff --git a/utf8.c b/utf8.c @@ -0,0 +1,142 @@ +/* + * ASCII all have a leading '0' byte: + * + * 0xxxxxxx + * + * UTF-8(7) have one leading '1' and as many following '1' as there are + * continuation bytes (with leading '1' and '0'). + * + * 0xxxxxxx + * 110xxxxx 10xxxxxx + * 1110xxxx 10xxxxxx 10xxxxxx + * 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx + * 111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx + * 1111110x 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx + * + * There is up to 3 continuation bytes -- up to 4 bytes per runes. + * + * The whole character value is retreived into an 'x' and stored into a + * (long)[]. + * + * Thanks to Connor Lane Smith for the idea of combining switches and + * binary masks. + */ + +#include <stdlib.h> +#include <stdio.h> + +#include "utf8.h" + + +/* + * Return the number of bytes in rune for the `n` next char in `s`, + * or 0 if ti is misencoded. + */ +size_t +utf8len(char *s, int n) +{ + unsigned char *sp = (unsigned char *) s; + int i, len = (*sp < 0x80) ? 1 : /* 0xxxxxxx < 10000000 */ + (*sp < 0xc0) ? 0 : /* 10xxxxxx < 11000000 */ + (*sp < 0xe0) ? 2 : /* 110xxxxx < 11100000 */ + (*sp < 0xf0) ? 3 : /* 1110xxxx < 11110000 */ + (*sp < 0xf8) ? 4 : /* 11110xxx < 11111000 */ + (*sp < 0xfc) ? 5 : /* 111110xx < 11111100 */ + (*sp < 0xfe) ? 6 : /* 1111110x < 11111110 */ + (*sp < 0xff) ? 7 : /* 11111110 < 11111111 */ + 0; + if (len > n) return 0; + + /* check continuation bytes */ + for (sp++, i = 1; i < len; i++, sp++) + if ((*sp & 0xc0) != 0x80) /* 10xxxxxx & 11000000 */ + return 0; + + return len; +} + + +/* + * Return the number of bytes required to encode `rune` into UTF-8, or + * 0 if rune is too long. + */ +size_t +utf8runelen(long r) +{ + return (r <= 0x0000007f) ? 1 : (r <= 0x000007ff) ? 2 : + (r <= 0x0000ffff) ? 3 : (r <= 0x001fffff) ? 4 : + (r <= 0x03ffffff) ? 5 : (r <= 0x7fffffff) ? 6 : 0; +} + + +/* + * Sets 'r' to a rune corresponding to the firsts 'n' bytes of 's'. + * + * Return the number of bytes read or 0 if the string is misencoded. + */ +size_t +utf8torune(long *r, char *s, size_t n) +{ + char mask[] = { 0x7f, 0x1f, 0x0f, 0x07, 0x03, 0x01 }; + size_t i, len = utf8len(s, n); + + if (len == 0 || len > 6 || len > n) + return 0; + + /* first byte */ + *r = *s++ & mask[len - 1]; + + /* continuation bytes */ + for (i = 1; i < len; i++) + *r = (*r << 6) | (*s++ & 0x3f); /* 10xxxxxx */ + + /* overlong sequences */ + if (utf8runelen(*r) != len) + return 0; + + return len; +} + + +/* + * Returns 1 if the rune is a valid unicode code point and 0 if not. + */ +int +utf8runeisunicode(long r) +{ + return !( + (r > 0x10ffff) || /* outside range */ + + ((r & 0x00fffe) == 0x00fffe) || /* noncharacters */ + (0x00fdd0 <= r && r <= 0x00fdef) || + + (0x00e000 <= r && r <= 0x00f8ff) || /* private use */ + (0x0f0000 <= r && r <= 0x0ffffd) || + (0x100000 <= r && r <= 0x10fffd) || + + (0x00d800 <= r && r <= 0x00dfff) /* surrogates */ + ); +} + + +/* + * Return 1 if '*s' is correctly encoded in UTF-8 with allowed Unicode + * code points. + */ +int +utf8check(char *s, size_t len) +{ + size_t shift; + long r = 0; + + while (len > 0) { + shift = utf8torune(&r, s, len); + if (!shift || !utf8runeisunicode(r)) + return 0; + + s += shift; + len -= shift; + } + + return 1; +} diff --git a/utf8.h b/utf8.h @@ -0,0 +1,5 @@ +size_t utf8len(char *, int); +size_t utf8runelen(long); +size_t utf8torune(long *, char *, size_t); +int utf8runeisunicode(long); +int utf8check(char *, size_t);