mirror of
https://github.com/Cloudef/bemenu
synced 2024-11-23 17:32:11 +01:00
271 lines
7.0 KiB
C
271 lines
7.0 KiB
C
#include "internal.h"
|
||
#define _XOPEN_SOURCE 700
|
||
#include <wchar.h>
|
||
#include <stdlib.h>
|
||
#include <string.h>
|
||
#include <ctype.h>
|
||
#include <assert.h>
|
||
|
||
/**
|
||
* Portable strdup.
|
||
*
|
||
* @param string C "string" to copy.
|
||
* @return Copy of the given C "string".
|
||
*/
|
||
char* _bmStrdup(const char *string)
|
||
{
|
||
assert(string);
|
||
|
||
size_t len = strlen(string);
|
||
if (len == 0)
|
||
return NULL;
|
||
|
||
void *copy = calloc(1, len + 1);
|
||
if (copy == NULL)
|
||
return NULL;
|
||
|
||
return (char *)memcpy(copy, string, len);
|
||
}
|
||
|
||
/**
|
||
* Portable case-insensitive strcmp.
|
||
*
|
||
* @param hay C "string" to match against.
|
||
* @param needle C "string" to match.
|
||
* @return Less than, equal to or greater than zero if hay is lexicographically less than, equal to or greater than needle.
|
||
*/
|
||
int _bmStrupcmp(const char *hay, const char *needle)
|
||
{
|
||
size_t len, len2;
|
||
|
||
if ((len = strlen(hay)) != (len2 = strlen(needle)))
|
||
return hay[len] - needle[len2];
|
||
|
||
return _bmStrnupcmp(hay, needle, len);
|
||
}
|
||
|
||
/**
|
||
* Portable case-insensitive strncmp.
|
||
*
|
||
* @param hay C "string" to match against.
|
||
* @param needle C "string" to match.
|
||
* @return Less than, equal to or greater than zero if hay is lexicographically less than, equal to or greater than needle.
|
||
*/
|
||
int _bmStrnupcmp(const char *hay, const char *needle, size_t len)
|
||
{
|
||
size_t i = 0;
|
||
unsigned char a = 0, b = 0;
|
||
|
||
const unsigned char *p1 = (const unsigned char*)hay;
|
||
const unsigned char *p2 = (const unsigned char*)needle;
|
||
|
||
for (i = 0; len > 0; --len, ++i)
|
||
if ((a = toupper(*p1++)) != (b = toupper(*p2++)))
|
||
return a - b;
|
||
|
||
return a - b;
|
||
}
|
||
|
||
/**
|
||
* Portable case-insensitive strstr.
|
||
*
|
||
* @param hay C "string" to substring against.
|
||
* @param needle C "string" to substring.
|
||
*/
|
||
char* _bmStrupstr(const char *hay, const char *needle)
|
||
{
|
||
size_t i, r = 0, p = 0, len, len2;
|
||
|
||
if ((len = strlen(hay)) < (len2 = strlen(needle)))
|
||
return NULL;
|
||
|
||
if (!_bmStrnupcmp(hay, needle, len2))
|
||
return (char*)hay;
|
||
|
||
for (i = 0; i < len; ++i) {
|
||
if (p == len2)
|
||
return (char*)hay + r;
|
||
|
||
if (toupper(hay[i]) == toupper(needle[p++])) {
|
||
if (!r)
|
||
r = i;
|
||
} else {
|
||
if (r)
|
||
i = r;
|
||
r = p = 0;
|
||
}
|
||
}
|
||
|
||
return (p == len2 ? (char*)hay + r : NULL);
|
||
}
|
||
|
||
/**
|
||
* Determite columns needed to display UTF8 string.
|
||
*
|
||
* @param string C "string" to determite.
|
||
* @return Number of columns, or -1 on failure.
|
||
*/
|
||
int _bmUtf8StringScreenWidth(const char *string)
|
||
{
|
||
assert(string);
|
||
|
||
int num_char = mbstowcs(NULL, string, 0) + 1;
|
||
wchar_t *wstring = malloc((num_char + 1) * sizeof (wstring[0]));
|
||
|
||
if (mbstowcs(wstring, string, num_char) == (size_t)(-1)) {
|
||
free(wstring);
|
||
return strlen(string);
|
||
}
|
||
|
||
int length = wcswidth(wstring, num_char);
|
||
free(wstring);
|
||
return length;
|
||
}
|
||
|
||
/**
|
||
* Figure out how many bytes to shift to next UTF8 rune.
|
||
*
|
||
* @param string C "string" which contains the runes.
|
||
* @param start Offset where to figure out next rune. (cursor)
|
||
* @return Number of bytes to next UTF8 rune.
|
||
*/
|
||
size_t _bmUtf8RuneNext(const char *string, size_t start)
|
||
{
|
||
assert(string);
|
||
|
||
size_t len = strlen(string), i = start;
|
||
if (len == 0 || len <= i || !*string)
|
||
return 0;
|
||
|
||
while (++i < len && (string[i] & 0xc0) == 0x80);
|
||
return i - start;
|
||
}
|
||
|
||
/**
|
||
* Figure out how many bytes to shift to previous UTF8 rune.
|
||
*
|
||
* @param string C "string" which contains the runes.
|
||
* @param start Offset where to figure out previous rune. (cursor)
|
||
* @return Number of bytes to previous UTF8 rune.
|
||
*/
|
||
size_t _bmUtf8RunePrev(const char *string, size_t start)
|
||
{
|
||
assert(string);
|
||
|
||
size_t len = strlen(string), i = start;
|
||
if (i == 0 || len < start || !*string)
|
||
return 0;
|
||
|
||
while (--i > 0 && (string[i] & 0xc0) == 0x80);
|
||
return start - i;
|
||
}
|
||
|
||
/**
|
||
* Figure out how many columns are needed to display UTF8 rune.
|
||
*
|
||
* @param rune Buffer which contains the rune.
|
||
* @param u8len Byte length of the rune.
|
||
* @return Number of columns, or -1 on failure.
|
||
*/
|
||
size_t _bmUtf8RuneWidth(const char *rune, unsigned int u8len)
|
||
{
|
||
assert(rune);
|
||
char mb[5] = { 0, 0, 0, 0, 0 };
|
||
memcpy(mb, rune, (u8len > 4 ? 4 : u8len));
|
||
return _bmUtf8StringScreenWidth(mb);
|
||
}
|
||
|
||
/**
|
||
* Remove previous UTF8 rune from buffer.
|
||
*
|
||
* @param string Null terminated C "string".
|
||
* @param start Start offset where to delete from. (cursor)
|
||
* @param outRuneWidth Reference to size_t, return number of columns for removed rune, or -1 on failure.
|
||
* @return Number of bytes removed from buffer.
|
||
*/
|
||
size_t _bmUtf8RuneRemove(char *string, size_t start, size_t *outRuneWidth)
|
||
{
|
||
assert(string);
|
||
|
||
if (outRuneWidth)
|
||
*outRuneWidth = 0;
|
||
|
||
size_t len = strlen(string), oldStart = start;
|
||
if (len == 0 || len < start || !*string)
|
||
return 0;
|
||
|
||
start -= _bmUtf8RunePrev(string, start);
|
||
|
||
if (outRuneWidth)
|
||
*outRuneWidth = _bmUtf8RuneWidth(string + start, oldStart - start);
|
||
|
||
memmove(string + start, string + oldStart, len - oldStart);
|
||
string[len - (oldStart - start)] = 0;
|
||
return (oldStart - start);
|
||
}
|
||
|
||
/**
|
||
* Insert UTF8 rune to buffer.
|
||
*
|
||
* @param string Null terminated C "string".
|
||
* @param bufSize Size of the buffer.
|
||
* @param start Start offset where to insert to. (cursor)
|
||
* @param rune Buffer to insert to string.
|
||
* @param u8len Byte length of the rune.
|
||
* @param outRuneWidth Reference to size_t, return number of columns for inserted rune, or -1 on failure.
|
||
* @return Number of bytes inserted to buffer.
|
||
*/
|
||
size_t _bmUtf8RuneInsert(char *string, size_t bufSize, size_t start, const char *rune, unsigned int u8len, size_t *outRuneWidth)
|
||
{
|
||
assert(string);
|
||
|
||
if (outRuneWidth)
|
||
*outRuneWidth = 0;
|
||
|
||
size_t len = strlen(string);
|
||
if (len + u8len >= bufSize)
|
||
return 0;
|
||
|
||
if (u8len == 1 && iscntrl(*rune))
|
||
return 0;
|
||
|
||
char *str = string + start;
|
||
memmove(str + u8len, str, len - start);
|
||
memcpy(str, rune, u8len);
|
||
|
||
if (outRuneWidth)
|
||
*outRuneWidth = _bmUtf8RuneWidth(rune, u8len);
|
||
return u8len;
|
||
}
|
||
|
||
/**
|
||
* Insert unicode character to UTF8 buffer.
|
||
*
|
||
* @param string Null terminated C "string".
|
||
* @param bufSize Size of the buffer.
|
||
* @param start Start offset where to insert to. (cursor)
|
||
* @param unicode Unicode character to insert.
|
||
* @param outRuneWidth Reference to size_t, return number of columns for inserted rune, or -1 on failure.
|
||
* @return Number of bytes inserted to buffer.
|
||
*/
|
||
size_t _bmUnicodeInsert(char *string, size_t bufSize, size_t start, unsigned int unicode, size_t *outRuneWidth)
|
||
{
|
||
assert(string);
|
||
|
||
char u8len = ((unicode < 0x80) ? 1 : ((unicode < 0x800) ? 2 : ((unicode < 0x10000) ? 3 : 4)));
|
||
char mb[5] = { 0, 0, 0, 0 };
|
||
|
||
if (u8len == 1) {
|
||
mb[0] = unicode;
|
||
} else {
|
||
size_t i, j;
|
||
for (i = j = u8len; j > 1; --j) mb[j - 1] = 0x80 | (0x3F & (unicode >> ((i - j) * 6)));
|
||
mb[0] = (~0) << (8 - i);
|
||
mb[0] |= (unicode >> (i * 6 - 6));
|
||
}
|
||
|
||
return _bmUtf8RuneInsert(string, bufSize, start, mb, u8len, outRuneWidth);
|
||
}
|
||
|
||
/* vim: set ts=8 sw=4 tw=0 :*/
|