2042 lines
54 KiB
C
2042 lines
54 KiB
C
|
||
#if !defined(BINARY_TYFUZZ_COLOR_PARSER)
|
||
#include "private.h"
|
||
#include <Elementary.h>
|
||
#include <assert.h>
|
||
#include <math.h>
|
||
#include <limits.h>
|
||
#include "termpty.h"
|
||
#include "backlog.h"
|
||
#include "termiolink.h"
|
||
#include "termio.h"
|
||
#include "sb.h"
|
||
#include "utf8.h"
|
||
#include "theme.h"
|
||
#include "utils.h"
|
||
#else
|
||
#include <assert.h>
|
||
#include <math.h>
|
||
#include <limits.h>
|
||
#include <stdbool.h>
|
||
#include <stdint.h>
|
||
#include <stdlib.h>
|
||
#include <string.h>
|
||
#include "sb.h"
|
||
#define eina_convert_strtod_c strtod
|
||
#ifndef MIN
|
||
# define MIN(x, y) (((x) > (y)) ? (y) : (x))
|
||
#endif
|
||
#ifndef MAX
|
||
# define MAX(x, y) (((x) > (y)) ? (x) : (y))
|
||
#endif
|
||
typedef uint32_t Eina_Unicode;
|
||
typedef bool Eina_Bool;
|
||
#define EINA_TRUE true
|
||
#define EINA_FALSE false
|
||
#endif
|
||
|
||
#if !defined(BINARY_TYFUZZ_COLOR_PARSER)
|
||
__attribute__((const))
|
||
static Eina_Bool
|
||
_isspace_unicode(const int codepoint)
|
||
{
|
||
switch (codepoint)
|
||
{
|
||
case 9: // character tabulation
|
||
return EINA_TRUE;
|
||
case 10: // line feed
|
||
return EINA_TRUE;
|
||
case 11: // line tabulation
|
||
return EINA_TRUE;
|
||
case 12: // form feed
|
||
return EINA_TRUE;
|
||
case 13: // carriage return
|
||
return EINA_TRUE;
|
||
case 32: // space
|
||
return EINA_TRUE;
|
||
case 133: // next line
|
||
return EINA_TRUE;
|
||
case 160: // no-break space
|
||
return EINA_TRUE;
|
||
case 5760: // ogham space mark
|
||
return EINA_TRUE;
|
||
case 6158: // mongolian vowel separator
|
||
return EINA_TRUE;
|
||
case 8192: // en quad
|
||
return EINA_TRUE;
|
||
case 8193: // em quad
|
||
return EINA_TRUE;
|
||
case 8194: // en space
|
||
return EINA_TRUE;
|
||
case 8195: // em space
|
||
return EINA_TRUE;
|
||
case 8196: // three-per-em space
|
||
return EINA_TRUE;
|
||
case 8197: // four-per-em space
|
||
return EINA_TRUE;
|
||
case 8198: // six-per-em space
|
||
return EINA_TRUE;
|
||
case 8199: // figure space
|
||
return EINA_TRUE;
|
||
case 8200: // puncturation space
|
||
return EINA_TRUE;
|
||
case 8201: // thin space
|
||
return EINA_TRUE;
|
||
case 8202: // hair space
|
||
return EINA_TRUE;
|
||
case 8203: // zero width space
|
||
return EINA_TRUE;
|
||
case 8204: // zero width non-joiner
|
||
return EINA_TRUE;
|
||
case 8205: // zero width joiner
|
||
return EINA_TRUE;
|
||
case 8232: // line separator
|
||
return EINA_TRUE;
|
||
case 8233: // paragraph separator
|
||
return EINA_TRUE;
|
||
case 8239: // narrow no-break space
|
||
return EINA_TRUE;
|
||
case 8287: // medium mathematical space
|
||
return EINA_TRUE;
|
||
case 8288: // word joiner
|
||
return EINA_TRUE;
|
||
case 12288: // ideographic space
|
||
return EINA_TRUE;
|
||
case 65279: // zero width non-breaking space
|
||
return EINA_TRUE;
|
||
}
|
||
return EINA_FALSE;
|
||
}
|
||
|
||
|
||
static char *
|
||
_cwd_path_get(const Evas_Object *obj, const char *relpath)
|
||
{
|
||
char cwdpath[PATH_MAX], tmppath[PATH_MAX];
|
||
|
||
if (!termio_cwd_get(obj, cwdpath, sizeof(cwdpath)))
|
||
return NULL;
|
||
|
||
eina_str_join(tmppath, sizeof(tmppath), '/', cwdpath, relpath);
|
||
return strdup(tmppath);
|
||
}
|
||
|
||
static char *
|
||
_home_path_get(const Evas_Object *_obj EINA_UNUSED,
|
||
const char *relpath)
|
||
{
|
||
char tmppath[PATH_MAX], homepath[PATH_MAX];
|
||
|
||
if (!homedir_get(homepath, sizeof(homepath)))
|
||
return NULL;
|
||
|
||
eina_str_join(tmppath, sizeof(tmppath), '/', homepath, relpath);
|
||
return strdup(tmppath);
|
||
}
|
||
|
||
static char *
|
||
_local_path_get(const Evas_Object *obj, const char *relpath)
|
||
{
|
||
if (relpath[0] == '/')
|
||
return strdup(relpath);
|
||
else if (eina_str_has_prefix(relpath, "~/"))
|
||
return _home_path_get(obj, relpath + 2);
|
||
else
|
||
return _cwd_path_get(obj, relpath);
|
||
}
|
||
|
||
/* isalpha() may produce unsigned-integer-overflow
|
||
* runtime error: unsigned integer overflow: 32 - 97 cannot be represented in
|
||
* type 'unsigned int'
|
||
* int isalpha(int c)
|
||
* {
|
||
* return ((unsigned)c|32)-'a' < 26;
|
||
* }
|
||
*/
|
||
#if defined(__clang__)
|
||
__attribute__((no_sanitize("unsigned-integer-overflow")))
|
||
#endif
|
||
Eina_Bool
|
||
link_is_protocol(const char *str)
|
||
{
|
||
const char *p = str;
|
||
int c;
|
||
|
||
if (!str)
|
||
return EINA_FALSE;
|
||
|
||
c = *p;
|
||
if (!isalpha(c))
|
||
return EINA_FALSE;
|
||
|
||
/* Try to follow RFC3986 a bit
|
||
* URI = scheme ":" hier-part [ "?" query ] [ "#" fragment ]
|
||
* hier-part = "//" authority path-abempty
|
||
* [...] other stuff not taken into account
|
||
* scheme = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )
|
||
*/
|
||
|
||
do
|
||
{
|
||
p++;
|
||
c = *p;
|
||
}
|
||
while (isalpha(c) || (c == '.') || (c == '-') || (c == '+'));
|
||
|
||
return (p[0] == ':') && (p[1] == '/') && (p[2] == '/');
|
||
}
|
||
|
||
Eina_Bool
|
||
link_is_url(const char *str)
|
||
{
|
||
if (!str)
|
||
return EINA_FALSE;
|
||
|
||
if (link_is_protocol(str) ||
|
||
casestartswith(str, "www.") ||
|
||
casestartswith(str, "ftp."))
|
||
return EINA_TRUE;
|
||
return EINA_FALSE;
|
||
}
|
||
|
||
Eina_Bool
|
||
link_is_email(const char *str)
|
||
{
|
||
const char *at;
|
||
|
||
if (!str)
|
||
return EINA_FALSE;
|
||
|
||
at = strchr(str, '@');
|
||
if (at && strchr(at + 1, '.'))
|
||
return EINA_TRUE;
|
||
if (casestartswith(str, "mailto:"))
|
||
return EINA_TRUE;
|
||
return EINA_FALSE;
|
||
}
|
||
|
||
Eina_Bool
|
||
link_is_file(const char *str)
|
||
{
|
||
if (!str)
|
||
return EINA_FALSE;
|
||
|
||
switch (str[0])
|
||
{
|
||
case '/':
|
||
return EINA_TRUE;
|
||
case '~':
|
||
if (str[1] == '/')
|
||
return EINA_TRUE;
|
||
return EINA_FALSE;
|
||
case '.':
|
||
if (str[1] == '/')
|
||
return EINA_TRUE;
|
||
else if ((str[1] == '.') && (str[2] == '/'))
|
||
return EINA_TRUE;
|
||
return EINA_FALSE;
|
||
default:
|
||
return EINA_FALSE;
|
||
}
|
||
}
|
||
|
||
static int
|
||
_txt_at(Termpty *ty, int *x, int *y, char *txt, int *txtlenp, int *codepointp)
|
||
{
|
||
Termcell *cells = NULL;
|
||
Termcell cell;
|
||
ssize_t w;
|
||
|
||
cells = termpty_cellrow_get(ty, *y, &w);
|
||
if (!cells || !w)
|
||
goto bad;
|
||
if ((*x >= w))
|
||
goto empty;
|
||
cell = cells[*x];
|
||
if ((cell.codepoint == 0) && (cell.att.dblwidth))
|
||
{
|
||
(*x)--;
|
||
if (*x < 0)
|
||
goto bad;
|
||
cell = cells[*x];
|
||
}
|
||
|
||
if (cell.att.tab_inserted)
|
||
{
|
||
*txtlenp = 1;
|
||
*codepointp = '\t';
|
||
txt[0] = '\t';
|
||
return 0;
|
||
}
|
||
if ((cell.codepoint == 0) || (cell.att.link_id))
|
||
goto empty;
|
||
|
||
*txtlenp = codepoint_to_utf8(cell.codepoint, txt);
|
||
*codepointp = cell.codepoint;
|
||
|
||
return 0;
|
||
|
||
empty:
|
||
txt[0] = '\0';
|
||
*txtlenp = 0;
|
||
*codepointp = 0;
|
||
return 0;
|
||
|
||
bad:
|
||
*txtlenp = 0;
|
||
txt[0] = '\0';
|
||
return -1;
|
||
}
|
||
|
||
static int
|
||
_txt_prev_at(Termpty *ty, int *x, int *y, char *txt, int *txtlenp,
|
||
int *codepointp)
|
||
{
|
||
Termcell *cells = NULL;
|
||
Termcell cell;
|
||
ssize_t w;
|
||
|
||
(*x)--;
|
||
if ((*x) < 0)
|
||
{
|
||
(*y)--;
|
||
*x = ty->w-1;
|
||
cells = termpty_cellrow_get(ty, *y, &w);
|
||
if (!cells || !w)
|
||
goto bad;
|
||
if ((*x) >= w)
|
||
goto empty;
|
||
cell = cells[*x];
|
||
/* Either the cell is in the normal screen and needs to have
|
||
* autowrapped flag or is in the backlog and its length is larger than
|
||
* the screen, spanning multiple lines */
|
||
if (((!cell.att.autowrapped) && (*y) >= 0)
|
||
|| (w < ty->w))
|
||
goto empty;
|
||
}
|
||
else
|
||
{
|
||
cells = termpty_cellrow_get(ty, *y, &w);
|
||
if (!cells || !w)
|
||
goto bad;
|
||
if ((*x) >= w)
|
||
goto empty;
|
||
|
||
cell = cells[*x];
|
||
}
|
||
if ((cell.codepoint == 0) && (cell.att.dblwidth))
|
||
{
|
||
(*x)--;
|
||
if (*x < 0)
|
||
goto bad;
|
||
cell = cells[*x];
|
||
}
|
||
|
||
if (cell.att.tab_last)
|
||
{
|
||
while (*x >= 0 && !cells[*x].att.tab_inserted)
|
||
(*x)--;
|
||
if (*x < 0)
|
||
goto bad;
|
||
*txtlenp = 1;
|
||
*codepointp = '\t';
|
||
txt[0] = '\t';
|
||
return 0;
|
||
}
|
||
if ((cell.codepoint == 0) || (cell.att.link_id))
|
||
goto empty;
|
||
|
||
*txtlenp = codepoint_to_utf8(cell.codepoint, txt);
|
||
*codepointp = cell.codepoint;
|
||
|
||
return 0;
|
||
|
||
empty:
|
||
txt[0] = '\0';
|
||
*txtlenp = 0;
|
||
*codepointp = 0;
|
||
return 0;
|
||
|
||
bad:
|
||
txt[0] = '\0';
|
||
*txtlenp = 0;
|
||
return -1;
|
||
}
|
||
|
||
static int
|
||
_txt_next_at(Termpty *ty, int *x, int *y, char *txt, int *txtlenp,
|
||
int *codepointp)
|
||
{
|
||
Termcell *cells = NULL;
|
||
Termcell cell;
|
||
ssize_t w;
|
||
|
||
(*x)++;
|
||
cells = termpty_cellrow_get(ty, *y, &w);
|
||
if (!cells || !w)
|
||
goto bad;
|
||
if ((*x) >= w)
|
||
{
|
||
(*y)++;
|
||
if ((*x) <= ty->w)
|
||
{
|
||
cell = cells[w-1];
|
||
if (!cell.att.autowrapped)
|
||
goto empty;
|
||
}
|
||
|
||
*x = 0;
|
||
cells = termpty_cellrow_get(ty, *y, &w);
|
||
if (!cells || !w)
|
||
goto bad;
|
||
}
|
||
|
||
cell = cells[*x];
|
||
if ((cell.codepoint == 0) && (cell.att.dblwidth))
|
||
{
|
||
(*x)++;
|
||
if (*x >= w)
|
||
{
|
||
cell = cells[w-1];
|
||
if (!cell.att.autowrapped && w == ty->w)
|
||
goto empty;
|
||
(*y)++;
|
||
*x = 0;
|
||
cells = termpty_cellrow_get(ty, *y, &w);
|
||
if (!cells || !w)
|
||
goto bad;
|
||
}
|
||
goto bad;
|
||
}
|
||
|
||
cell = cells[*x];
|
||
if (cell.att.tab_inserted)
|
||
{
|
||
while (*x < w && !cells[*x].att.tab_last)
|
||
(*x)++;
|
||
if (*x >= w)
|
||
goto bad;
|
||
*txtlenp = 1;
|
||
*codepointp = '\t';
|
||
txt[0] = '\t';
|
||
return 0;
|
||
}
|
||
if ((cell.codepoint == 0) || (cell.att.link_id))
|
||
goto empty;
|
||
|
||
*txtlenp = codepoint_to_utf8(cell.codepoint, txt);
|
||
*codepointp = cell.codepoint;
|
||
|
||
return 0;
|
||
|
||
empty:
|
||
txt[0] = '\0';
|
||
*txtlenp = 0;
|
||
*codepointp = 0;
|
||
return 0;
|
||
|
||
bad:
|
||
*txtlenp = 0;
|
||
txt[0] = '\0';
|
||
return -1;
|
||
}
|
||
|
||
/* returned string must be freed */
|
||
char *
|
||
termio_link_find(const Evas_Object *obj, int cx, int cy,
|
||
int *x1r, int *y1r, int *x2r, int *y2r)
|
||
{
|
||
char *s = NULL;
|
||
int endmatch1 = 0, endmatch2 = 0;
|
||
int x1, x2, y1, y2, w = 0, h = 0, sc;
|
||
Eina_Bool goback = EINA_TRUE,
|
||
goforward = EINA_FALSE,
|
||
escaped = EINA_FALSE;
|
||
struct ty_sb sb = {.buf = NULL, .gap = 0, .len = 0, .alloc = 0};
|
||
Termpty *ty = termio_pty_get(obj);
|
||
int res;
|
||
char txt[8];
|
||
int txtlen = 0;
|
||
int codepoint = 0;
|
||
Eina_Bool was_protocol = EINA_FALSE;
|
||
|
||
EINA_SAFETY_ON_NULL_RETURN_VAL(ty, NULL);
|
||
|
||
x1 = x2 = cx;
|
||
y1 = y2 = cy;
|
||
termio_size_get(obj, &w, &h);
|
||
if ((w <= 0) || (h <= 0)) goto end;
|
||
|
||
sc = termio_scroll_get(obj);
|
||
|
||
termpty_backlog_lock();
|
||
|
||
y1 -= sc;
|
||
y2 -= sc;
|
||
|
||
res = _txt_at(ty, &x1, &y1, txt, &txtlen, &codepoint);
|
||
if ((res != 0) || (txtlen == 0)) goto end;
|
||
if (_isspace_unicode(codepoint))
|
||
goto end;
|
||
res = ty_sb_add(&sb, txt, txtlen);
|
||
if (res < 0) goto end;
|
||
|
||
while (goback)
|
||
{
|
||
int new_x1 = x1, new_y1 = y1;
|
||
|
||
res = _txt_prev_at(ty, &new_x1, &new_y1, txt, &txtlen, &codepoint);
|
||
if ((res != 0) || (txtlen == 0))
|
||
{
|
||
goback = EINA_FALSE;
|
||
goforward = EINA_TRUE;
|
||
break;
|
||
}
|
||
res = ty_sb_prepend(&sb, txt, txtlen);
|
||
if (res < 0) goto end;
|
||
if (_isspace_unicode(codepoint))
|
||
{
|
||
int old_txtlen = txtlen;
|
||
res = _txt_prev_at(ty, &new_x1, &new_y1, txt, &txtlen, &codepoint);
|
||
if ((res != 0) || (txtlen == 0) || (codepoint != '\\'))
|
||
{
|
||
ty_sb_lskip(&sb, old_txtlen);
|
||
goback = EINA_FALSE;
|
||
goforward = EINA_TRUE;
|
||
break;
|
||
}
|
||
}
|
||
switch (codepoint)
|
||
{
|
||
case '"': endmatch1 = endmatch2 = '"'; break;
|
||
case '\'': endmatch1 = endmatch2 = '\''; break;
|
||
case '`': endmatch1 = endmatch2 = '`'; break;
|
||
case '<': endmatch1 = endmatch2 = '>'; break;
|
||
case '[': endmatch1 = endmatch2 = ']'; break;
|
||
case ']': endmatch1 = endmatch2 = '['; break;
|
||
case '{': endmatch1 = endmatch2 = '}'; break;
|
||
case '(': endmatch1 = endmatch2 = ')'; break;
|
||
case '|': endmatch1 = endmatch2 = '|'; break;
|
||
case 0xab: endmatch1 = endmatch2 = 0xbb; break; // french « »
|
||
case 0xbb: endmatch1 = endmatch2 = 0xab; break; // swedish » «
|
||
case 0x2018: endmatch1 = endmatch2 = 0x2019; break; // ‘ ’
|
||
case 0x201b: endmatch1 = endmatch2 = 0x2019; break; // ‛ ’
|
||
case 0x201c: endmatch1 = endmatch2 = 0x201d; break; // “ ”
|
||
case 0x201e: endmatch1 = 0x201c; endmatch2 = 0x201d; break; // „ “”
|
||
case 0x2039: endmatch1 = endmatch2 = 0x203a; break; // ‹›
|
||
case 0x27e6: endmatch1 = endmatch2 = 0x27e7; break; // ⟦ ⟧
|
||
case 0x27e8: endmatch1 = endmatch2 = 0x27e9; break; // ⟨ ⟩
|
||
case 0x2329: endmatch1 = endmatch2 = 0x232a; break; // 〈 〉
|
||
case 0x231c: endmatch1 = 0x231d; endmatch2 = 0x231f; break; // ⌜⌝⌟
|
||
case 0x231e: endmatch1 = 0x231d; endmatch2 = 0x231f; break; // ⌞⌝⌟
|
||
case 0x2308: endmatch1 = 0x2309; endmatch2 = 0x230b; break; // ⌈⌉⌋
|
||
case 0x230a: endmatch1 = 0x2309; endmatch2 = 0x230b; break; // ⌊⌉⌋
|
||
}
|
||
if (endmatch1)
|
||
{
|
||
ty_sb_lskip(&sb, txtlen);
|
||
goback = EINA_FALSE;
|
||
goforward = EINA_TRUE;
|
||
break;
|
||
}
|
||
|
||
if (!link_is_protocol(sb.buf))
|
||
{
|
||
if (was_protocol)
|
||
{
|
||
if (!_isspace_unicode(codepoint))
|
||
endmatch1 = endmatch2 = codepoint;
|
||
ty_sb_lskip(&sb, txtlen);
|
||
goback = EINA_FALSE;
|
||
goforward = EINA_TRUE;
|
||
break;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
was_protocol = EINA_TRUE;
|
||
}
|
||
x1 = new_x1;
|
||
y1 = new_y1;
|
||
}
|
||
|
||
while (goforward)
|
||
{
|
||
int new_x2 = x2, new_y2 = y2;
|
||
/* Check if the previous char is a delimiter */
|
||
res = _txt_next_at(ty, &new_x2, &new_y2, txt, &txtlen, &codepoint);
|
||
if ((res != 0) || (txtlen == 0))
|
||
{
|
||
goforward = EINA_FALSE;
|
||
break;
|
||
}
|
||
/* escaping */
|
||
if (codepoint == '\\')
|
||
{
|
||
x2 = new_x2;
|
||
y2 = new_y2;
|
||
escaped = EINA_TRUE;
|
||
continue;
|
||
}
|
||
if (escaped)
|
||
{
|
||
x2 = new_x2;
|
||
y2 = new_y2;
|
||
escaped = EINA_FALSE;
|
||
}
|
||
|
||
if (_isspace_unicode(codepoint) || (codepoint == endmatch1)
|
||
|| (codepoint == endmatch2))
|
||
{
|
||
goforward = EINA_FALSE;
|
||
break;
|
||
}
|
||
switch (codepoint)
|
||
{
|
||
case '"': goto out;
|
||
case '\'': goto out;
|
||
case '`': goto out;
|
||
case '<': goto out;
|
||
case '>': goto out;
|
||
case '[': goto out;
|
||
case ']': goto out;
|
||
case '{': goto out;
|
||
case '}': goto out;
|
||
case '|': goto out;
|
||
case 0xab: goto out;
|
||
case 0xbb: goto out;
|
||
case 0x2018: goto out;
|
||
case 0x2019: goto out;
|
||
case 0x201b: goto out;
|
||
case 0x201c: goto out;
|
||
case 0x201d: goto out;
|
||
case 0x201e: goto out;
|
||
case 0x2039: goto out;
|
||
case 0x203a: goto out;
|
||
case 0x2308: goto out;
|
||
case 0x2309: goto out;
|
||
case 0x230a: goto out;
|
||
case 0x230b: goto out;
|
||
case 0x231c: goto out;
|
||
case 0x231d: goto out;
|
||
case 0x231e: goto out;
|
||
case 0x231f: goto out;
|
||
case 0x2329: goto out;
|
||
case 0x232a: goto out;
|
||
case 0x27e6: goto out;
|
||
case 0x27e7: goto out;
|
||
case 0x27e8: goto out;
|
||
case 0x27e9: goto out;
|
||
}
|
||
|
||
res = ty_sb_add(&sb, txt, txtlen);
|
||
if (res < 0) goto end;
|
||
|
||
if (!link_is_protocol(sb.buf))
|
||
{
|
||
if (was_protocol)
|
||
{
|
||
ty_sb_rskip(&sb, txtlen);
|
||
goback = EINA_FALSE;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
was_protocol = EINA_TRUE;
|
||
}
|
||
x2 = new_x2;
|
||
y2 = new_y2;
|
||
}
|
||
|
||
out:
|
||
if (sb.len)
|
||
{
|
||
Eina_Bool is_file = link_is_file(sb.buf);
|
||
|
||
if (is_file ||
|
||
link_is_email(sb.buf) ||
|
||
link_is_url(sb.buf))
|
||
{
|
||
if (x1r) *x1r = x1;
|
||
if (y1r) *y1r = y1 + sc;
|
||
if (x2r) *x2r = x2;
|
||
if (y2r) *y2r = y2 + sc;
|
||
|
||
if (is_file && (sb.buf[0] != '/'))
|
||
{
|
||
char *local= _local_path_get(obj, (const char*)sb.buf);
|
||
ty_sb_free(&sb);
|
||
s = local;
|
||
goto end;
|
||
}
|
||
else
|
||
{
|
||
s = ty_sb_steal_buf(&sb);
|
||
}
|
||
|
||
goto end;
|
||
}
|
||
}
|
||
end:
|
||
termpty_backlog_unlock();
|
||
ty_sb_free(&sb);
|
||
return s;
|
||
}
|
||
#endif
|
||
|
||
__attribute__((const))
|
||
static Eina_Bool
|
||
_is_authorized_in_color(const int codepoint)
|
||
{
|
||
switch (codepoint)
|
||
{
|
||
case '\t': return EINA_TRUE;
|
||
case ' ': return EINA_TRUE;
|
||
case '#': return EINA_TRUE;
|
||
case '%': return EINA_TRUE;
|
||
case '(': return EINA_TRUE;
|
||
case '+': return EINA_TRUE;
|
||
case ',': return EINA_TRUE;
|
||
case '.': return EINA_TRUE;
|
||
case '/': return EINA_TRUE;
|
||
case '0': return EINA_TRUE;
|
||
case '1': return EINA_TRUE;
|
||
case '2': return EINA_TRUE;
|
||
case '3': return EINA_TRUE;
|
||
case '4': return EINA_TRUE;
|
||
case '5': return EINA_TRUE;
|
||
case '6': return EINA_TRUE;
|
||
case '7': return EINA_TRUE;
|
||
case '8': return EINA_TRUE;
|
||
case '9': return EINA_TRUE;
|
||
case ':': return EINA_TRUE;
|
||
case 'A': return EINA_TRUE;
|
||
case 'B': return EINA_TRUE;
|
||
case 'C': return EINA_TRUE;
|
||
case 'D': return EINA_TRUE;
|
||
case 'E': return EINA_TRUE;
|
||
case 'F': return EINA_TRUE;
|
||
case 'a': return EINA_TRUE;
|
||
case 'b': return EINA_TRUE;
|
||
case 'c': return EINA_TRUE;
|
||
case 'd': return EINA_TRUE;
|
||
case 'e': return EINA_TRUE;
|
||
case 'f': return EINA_TRUE;
|
||
case 'g': return EINA_TRUE;
|
||
case 'h': return EINA_TRUE;
|
||
case 'l': return EINA_TRUE;
|
||
case 'n': return EINA_TRUE;
|
||
case 'o': return EINA_TRUE;
|
||
case 'r': return EINA_TRUE;
|
||
case 's': return EINA_TRUE;
|
||
case 't': return EINA_TRUE;
|
||
case 'u': return EINA_TRUE;
|
||
}
|
||
return EINA_FALSE;
|
||
}
|
||
|
||
static Eina_Bool
|
||
_parse_hex(const char c, uint8_t *v)
|
||
{
|
||
if (c < '0')
|
||
return EINA_FALSE;
|
||
if (c <= '9')
|
||
{
|
||
*v = c - '0';
|
||
return EINA_TRUE;
|
||
}
|
||
if (c < 'A')
|
||
return EINA_FALSE;
|
||
if (c <= 'F')
|
||
{
|
||
*v = 10 + c - 'A';
|
||
return EINA_TRUE;
|
||
}
|
||
if (c < 'a')
|
||
return EINA_FALSE;
|
||
if (c <= 'f')
|
||
{
|
||
*v = 10 + c - 'a';
|
||
return EINA_TRUE;
|
||
}
|
||
return EINA_FALSE;
|
||
}
|
||
|
||
static Eina_Bool
|
||
_parse_2hex(const char *s, uint8_t *v)
|
||
{
|
||
uint8_t v0, v1;
|
||
if (!_parse_hex(s[0], &v0))
|
||
return EINA_FALSE;
|
||
if (!_parse_hex(s[1], &v1))
|
||
return EINA_FALSE;
|
||
*v = v0 << 4 | v1;
|
||
return EINA_TRUE;
|
||
}
|
||
|
||
static Eina_Bool
|
||
_parse_sharp_color(struct ty_sb *sb,
|
||
uint8_t *rp, uint8_t *gp, uint8_t *bp, uint8_t *ap)
|
||
{
|
||
uint8_t r, g, b, a = 255;
|
||
|
||
/* sharp */
|
||
if (sb->buf[0] != '#')
|
||
return EINA_FALSE;
|
||
ty_sb_lskip(sb, 1);
|
||
switch (sb->len)
|
||
{
|
||
case 3:
|
||
if ((!_parse_hex(sb->buf[0], &r)) ||
|
||
(!_parse_hex(sb->buf[1], &g)) ||
|
||
(!_parse_hex(sb->buf[2], &b)))
|
||
return EINA_FALSE;
|
||
r <<= 4;
|
||
g <<= 4;
|
||
b <<= 4;
|
||
break;
|
||
case 4:
|
||
if ((!_parse_hex(sb->buf[0], &r)) ||
|
||
(!_parse_hex(sb->buf[1], &g)) ||
|
||
(!_parse_hex(sb->buf[2], &b)) ||
|
||
(!_parse_hex(sb->buf[3], &a)))
|
||
return EINA_FALSE;
|
||
r <<= 4;
|
||
g <<= 4;
|
||
b <<= 4;
|
||
a <<= 4;
|
||
break;
|
||
case 6:
|
||
if ((!_parse_2hex(&sb->buf[0], &r)) ||
|
||
(!_parse_2hex(&sb->buf[2], &g)) ||
|
||
(!_parse_2hex(&sb->buf[4], &b)))
|
||
return EINA_FALSE;
|
||
break;
|
||
case 8:
|
||
if ((!_parse_2hex(&sb->buf[0], &r)) ||
|
||
(!_parse_2hex(&sb->buf[2], &g)) ||
|
||
(!_parse_2hex(&sb->buf[4], &b)) ||
|
||
(!_parse_2hex(&sb->buf[6], &a)))
|
||
return EINA_FALSE;
|
||
break;
|
||
default:
|
||
return EINA_FALSE;
|
||
}
|
||
*rp = r;
|
||
*gp = g;
|
||
*bp = b;
|
||
*ap = a;
|
||
return EINA_TRUE;
|
||
}
|
||
|
||
static Eina_Bool
|
||
_parse_uint8(struct ty_sb *sb,
|
||
uint8_t *vp)
|
||
{
|
||
uint16_t v = 0;
|
||
Eina_Bool ret = EINA_FALSE;
|
||
|
||
if (!sb->len) return EINA_FALSE;
|
||
|
||
while (sb->len && v < 255 && sb->buf[0] >= '0' && sb->buf[0] <= '9')
|
||
{
|
||
v = (v * 10) + sb->buf[0] - '0';
|
||
ty_sb_lskip(sb, 1);
|
||
ret = EINA_TRUE;
|
||
}
|
||
if (v > 255)
|
||
return EINA_FALSE;
|
||
|
||
*vp = v;
|
||
return ret;
|
||
}
|
||
|
||
/* isnan() in musl generates ' runtime error: negation of 1 cannot be
|
||
* represented in type 'unsigned long long'
|
||
* under ubsan
|
||
*/
|
||
#if defined(__clang__) && !defined(__GLIBC__)
|
||
__attribute__((no_sanitize("unsigned-integer-overflow")))
|
||
#endif
|
||
static Eina_Bool
|
||
_parse_one_css_rgb_color(struct ty_sb *sb,
|
||
uint8_t *vp,
|
||
Eina_Bool *is_percentp)
|
||
{
|
||
char *endptr_double, *endptr_long;
|
||
double d;
|
||
long int l;
|
||
|
||
if (!sb->len)
|
||
return EINA_FALSE;
|
||
|
||
d = eina_convert_strtod_c(sb->buf, &endptr_double);
|
||
l = (long int)strtol(sb->buf, &endptr_long, 0);
|
||
if (endptr_double == sb->buf || d < 0 || l < 0 || isnan(d))
|
||
return EINA_FALSE;
|
||
if (endptr_double > endptr_long)
|
||
{
|
||
ty_sb_lskip(sb, endptr_double - sb->buf);
|
||
*is_percentp = sb->len && sb->buf[0] == '%';
|
||
if (*is_percentp)
|
||
{
|
||
ty_sb_lskip(sb, 1);
|
||
if (d > 100.0)
|
||
return EINA_FALSE;
|
||
d = (255.0 * d) / 100;
|
||
}
|
||
if (d > 255)
|
||
return EINA_FALSE;
|
||
*vp = round(d);
|
||
}
|
||
else
|
||
{
|
||
ty_sb_lskip(sb, endptr_long - sb->buf);
|
||
*is_percentp = sb->len && sb->buf[0] == '%';
|
||
if (*is_percentp)
|
||
{
|
||
ty_sb_lskip(sb, 1);
|
||
if (l > 100)
|
||
return EINA_FALSE;
|
||
l = (255 * l) / 100;
|
||
}
|
||
if (l > 255)
|
||
return EINA_FALSE;
|
||
*vp = (uint8_t)l;
|
||
}
|
||
return EINA_TRUE;
|
||
}
|
||
|
||
/* isnan() in musl generates ' runtime error: negation of 1 cannot be
|
||
* represented in type 'unsigned long long'
|
||
* under ubsan
|
||
*/
|
||
#if defined(__clang__) && !defined(__GLIBC__)
|
||
__attribute__((no_sanitize("unsigned-integer-overflow")))
|
||
#endif
|
||
static Eina_Bool
|
||
_parse_one_css_alpha(struct ty_sb *sb,
|
||
uint8_t *ap)
|
||
{
|
||
char *endptr_double;
|
||
double d;
|
||
|
||
if (!sb->len)
|
||
return EINA_FALSE;
|
||
|
||
d = eina_convert_strtod_c(sb->buf, &endptr_double);
|
||
if (endptr_double == sb->buf || d < 0 || isnan(d))
|
||
return EINA_FALSE;
|
||
ty_sb_lskip(sb, endptr_double - sb->buf);
|
||
if (sb->len && sb->buf[0] == '%')
|
||
{
|
||
ty_sb_lskip(sb, 1);
|
||
if (d > 100.0)
|
||
return EINA_FALSE;
|
||
d = (255.0 * d) / 100;
|
||
}
|
||
else
|
||
{
|
||
d *= 255.0;
|
||
}
|
||
if (d > 255)
|
||
return EINA_FALSE;
|
||
*ap = round(d);
|
||
return EINA_TRUE;
|
||
}
|
||
|
||
/* isnan() in musl generates ' runtime error: negation of 1 cannot be
|
||
* represented in type 'unsigned long long'
|
||
* under ubsan
|
||
*/
|
||
#if defined(__clang__) && !defined(__GLIBC__)
|
||
__attribute__((no_sanitize("unsigned-integer-overflow")))
|
||
#endif
|
||
/* returns hue between 0 and 1 */
|
||
static Eina_Bool
|
||
_parse_one_hue(struct ty_sb *sb,
|
||
double *dp)
|
||
{
|
||
char *endptr_double;
|
||
double d;
|
||
|
||
if (!sb->len)
|
||
return EINA_FALSE;
|
||
|
||
d = eina_convert_strtod_c(sb->buf, &endptr_double);
|
||
if (endptr_double == sb->buf || d < 0 || isnan(d))
|
||
return EINA_FALSE;
|
||
ty_sb_lskip(sb, endptr_double - sb->buf);
|
||
if (sbstartswith(sb, "turn"))
|
||
{
|
||
ty_sb_lskip(sb, strlen("turn"));
|
||
}
|
||
else if (sbstartswith(sb, "rad"))
|
||
{
|
||
ty_sb_lskip(sb, strlen("rad"));
|
||
d /= 2 * M_PI;
|
||
}
|
||
else if (sbstartswith(sb, "grad"))
|
||
{
|
||
ty_sb_lskip(sb, strlen("grad"));
|
||
d /= 400;
|
||
}
|
||
else if (sbstartswith(sb, "deg") || sb->buf[0] == ',' || sb->buf[0] == ' ')
|
||
{
|
||
if (sbstartswith(sb, "deg"))
|
||
ty_sb_lskip(sb, strlen("deg"));
|
||
d /= 360;
|
||
}
|
||
else
|
||
return EINA_FALSE;
|
||
if (d >= (double)LONG_MAX)
|
||
return EINA_FALSE;
|
||
d = d - (long) d;
|
||
if (d < 0)
|
||
d = 1 + d;
|
||
*dp = d;
|
||
return EINA_TRUE;
|
||
}
|
||
|
||
/* isnan() in musl generates ' runtime error: negation of 1 cannot be
|
||
* represented in type 'unsigned long long'
|
||
* under ubsan
|
||
*/
|
||
#if defined(__clang__) && !defined(__GLIBC__)
|
||
__attribute__((no_sanitize("unsigned-integer-overflow")))
|
||
#endif
|
||
static Eina_Bool
|
||
_parse_one_percent(struct ty_sb *sb,
|
||
double *dp)
|
||
{
|
||
char *endptr_double;
|
||
double d;
|
||
|
||
if (!sb->len)
|
||
return EINA_FALSE;
|
||
|
||
d = eina_convert_strtod_c(sb->buf, &endptr_double);
|
||
if (isnan(d) || endptr_double == sb->buf || d < 0)
|
||
return EINA_FALSE;
|
||
ty_sb_lskip(sb, endptr_double - sb->buf);
|
||
if (!sb->len || sb->buf[0] != '%') return EINA_FALSE;
|
||
ty_sb_lskip(sb, 1);
|
||
if (d > 100.0)
|
||
return EINA_FALSE;
|
||
d /= 100.0;
|
||
*dp = d;
|
||
return EINA_TRUE;
|
||
}
|
||
|
||
|
||
/* From http://en.wikipedia.org/wiki/HSL_color_space */
|
||
static Eina_Bool
|
||
_hsl_to_rgb(double hue, double saturation, double lightness,
|
||
uint8_t *rp, uint8_t *gp, uint8_t *bp)
|
||
{
|
||
double a = saturation * MIN(lightness, 1.0 - lightness);
|
||
double n[3] = {0., 8., 4.};
|
||
double res[3] = {};
|
||
int i;
|
||
|
||
for (i = 0; i < 3; i++)
|
||
{
|
||
double k = fmod(n[i] + 12.0 * hue, 12.);
|
||
double f = lightness - a * MAX(-1, MIN(MIN(k - 3, 9 - k), 1));
|
||
if (f > 1 || f < 0)
|
||
return EINA_FALSE;
|
||
res[i] = f * 255.0;
|
||
}
|
||
|
||
*rp = res[0];
|
||
*gp = res[1];
|
||
*bp = res[2];
|
||
return EINA_TRUE;
|
||
}
|
||
|
||
static Eina_Bool
|
||
_parse_css_hsl_color(struct ty_sb *sb,
|
||
uint8_t *rp, uint8_t *gp, uint8_t *bp, uint8_t *ap)
|
||
{
|
||
uint8_t r = 0, g = 0, b = 0, a = 255;
|
||
double hue, saturation, lightness;
|
||
Eina_Bool is_functional;
|
||
|
||
ty_sb_spaces_ltrim(sb);
|
||
|
||
if (!sbstartswith(sb, "hsl"))
|
||
return EINA_FALSE;
|
||
ty_sb_lskip(sb, 3);
|
||
if (sb->buf[0] == 'a')
|
||
ty_sb_lskip(sb, 1);
|
||
if (!sb->len) return EINA_FALSE;
|
||
ty_sb_spaces_ltrim(sb);
|
||
if (!sb->len || sb->buf[0] != '(')
|
||
return EINA_FALSE;
|
||
ty_sb_lskip(sb, 1);
|
||
if (!sb->len) return EINA_FALSE;
|
||
ty_sb_spaces_ltrim(sb);
|
||
|
||
if (!_parse_one_hue(sb, &hue))
|
||
return EINA_FALSE;
|
||
is_functional = (sb->len && sb->buf[0] == ',');
|
||
if (is_functional)
|
||
{
|
||
ty_sb_lskip(sb, 1);
|
||
}
|
||
ty_sb_spaces_ltrim(sb);
|
||
if (!sb->len) return EINA_FALSE;
|
||
|
||
if (!_parse_one_percent(sb, &saturation))
|
||
return EINA_FALSE;
|
||
ty_sb_spaces_ltrim(sb);
|
||
if (!sb->len) return EINA_FALSE;
|
||
if (is_functional != (sb->buf[0] == ','))
|
||
return EINA_FALSE;
|
||
if (is_functional)
|
||
ty_sb_lskip(sb, 1);
|
||
ty_sb_spaces_ltrim(sb);
|
||
if (!sb->len) return EINA_FALSE;
|
||
|
||
if (!_parse_one_percent(sb, &lightness))
|
||
return EINA_FALSE;
|
||
ty_sb_spaces_ltrim(sb);
|
||
if (!sb->len) return EINA_FALSE;
|
||
if (sb->buf[0] == ')')
|
||
{
|
||
ty_sb_lskip(sb, 1);
|
||
a = 255;
|
||
}
|
||
else
|
||
{
|
||
if ((is_functional && (sb->buf[0] != ',')) ||
|
||
(!is_functional && (sb->buf[0] != '/')))
|
||
return EINA_FALSE;
|
||
if (!sb->len) return EINA_FALSE;
|
||
ty_sb_lskip(sb, 1);
|
||
ty_sb_spaces_ltrim(sb);
|
||
if (!sb->len) return EINA_FALSE;
|
||
if (!_parse_one_css_alpha(sb, &a))
|
||
return EINA_FALSE;
|
||
ty_sb_spaces_ltrim(sb);
|
||
if (sb->buf[0] != ')')
|
||
return EINA_FALSE;
|
||
}
|
||
if (!_hsl_to_rgb(hue, saturation, lightness, &r, &g, &b))
|
||
return EINA_FALSE;
|
||
|
||
*rp = r;
|
||
*gp = g;
|
||
*bp = b;
|
||
*ap = a;
|
||
return EINA_TRUE;
|
||
}
|
||
|
||
|
||
static Eina_Bool
|
||
_parse_css_rgb_color(struct ty_sb *sb,
|
||
uint8_t *rp, uint8_t *gp, uint8_t *bp, uint8_t *ap)
|
||
{
|
||
uint8_t r = 0, g = 0, b = 0, a = 255;
|
||
Eina_Bool must_be_percent, is_percent, is_functional;
|
||
|
||
ty_sb_spaces_ltrim(sb);
|
||
|
||
if (!sbstartswith(sb, "rgb"))
|
||
return EINA_FALSE;
|
||
ty_sb_lskip(sb, 3);
|
||
if (sb->buf[0] == 'a')
|
||
ty_sb_lskip(sb, 1);
|
||
if (!sb->len) return EINA_FALSE;
|
||
ty_sb_spaces_ltrim(sb);
|
||
if (!sb->len || sb->buf[0] != '(')
|
||
return EINA_FALSE;
|
||
ty_sb_lskip(sb, 1);
|
||
if (!sb->len) return EINA_FALSE;
|
||
ty_sb_spaces_ltrim(sb);
|
||
|
||
if (!_parse_one_css_rgb_color(sb, &r, &must_be_percent))
|
||
return EINA_FALSE;
|
||
ty_sb_spaces_ltrim(sb);
|
||
is_functional = (sb->buf[0] == ',');
|
||
if (is_functional)
|
||
ty_sb_lskip(sb, 1);
|
||
ty_sb_spaces_ltrim(sb);
|
||
if (!sb->len) return EINA_FALSE;
|
||
|
||
if (!_parse_one_css_rgb_color(sb, &g, &is_percent))
|
||
return EINA_FALSE;
|
||
if (is_percent != must_be_percent)
|
||
return EINA_FALSE;
|
||
ty_sb_spaces_ltrim(sb);
|
||
if (is_functional != (sb->buf[0] == ','))
|
||
return EINA_FALSE;
|
||
if (is_functional)
|
||
ty_sb_lskip(sb, 1);
|
||
ty_sb_spaces_ltrim(sb);
|
||
if (!sb->len) return EINA_FALSE;
|
||
|
||
if (!_parse_one_css_rgb_color(sb, &b, &is_percent))
|
||
return EINA_FALSE;
|
||
if (is_percent != must_be_percent)
|
||
return EINA_FALSE;
|
||
ty_sb_spaces_ltrim(sb);
|
||
if (sb->buf[0] == ')')
|
||
{
|
||
ty_sb_lskip(sb, 1);
|
||
a = 255;
|
||
}
|
||
else
|
||
{
|
||
if ((is_functional && (sb->buf[0] != ',')) ||
|
||
(!is_functional && (sb->buf[0] != '/')))
|
||
return EINA_FALSE;
|
||
if (!sb->len) return EINA_FALSE;
|
||
ty_sb_lskip(sb, 1);
|
||
ty_sb_spaces_ltrim(sb);
|
||
if (!sb->len) return EINA_FALSE;
|
||
if (!_parse_one_css_alpha(sb, &a))
|
||
return EINA_FALSE;
|
||
ty_sb_spaces_ltrim(sb);
|
||
if (sb->buf[0] != ')')
|
||
return EINA_FALSE;
|
||
}
|
||
|
||
*rp = r;
|
||
*gp = g;
|
||
*bp = b;
|
||
*ap = a;
|
||
return EINA_TRUE;
|
||
}
|
||
|
||
static Eina_Bool
|
||
_parse_edc_color(struct ty_sb *sb,
|
||
uint8_t *rp, uint8_t *gp, uint8_t *bp, uint8_t *ap)
|
||
{
|
||
uint8_t r = 0, g = 0, b = 0, a = 255;
|
||
|
||
ty_sb_spaces_ltrim(sb);
|
||
/* skip color */
|
||
if (sb->len <= 6)
|
||
return EINA_FALSE;
|
||
if (strncmp(sb->buf, "color", 5) != 0)
|
||
return EINA_FALSE;
|
||
ty_sb_lskip(sb, 5);
|
||
if (sb->buf[0] == '2' || sb->buf[0] == '3')
|
||
ty_sb_lskip(sb, 1);
|
||
ty_sb_spaces_ltrim(sb);
|
||
if (sb->buf[0] != ':')
|
||
return EINA_FALSE;
|
||
ty_sb_lskip(sb, 1); /* skip ':' */
|
||
ty_sb_spaces_ltrim(sb);
|
||
|
||
if (!sb->len) return EINA_FALSE;
|
||
if (sb->buf[0] == '#')
|
||
return _parse_sharp_color(sb, rp, gp, bp, ap);
|
||
if (sbstartswith(sb, "rgb"))
|
||
return _parse_css_rgb_color(sb, rp, gp, bp, ap);
|
||
if (sbstartswith(sb, "hsl"))
|
||
return _parse_css_hsl_color(sb, rp, gp, bp, ap);
|
||
|
||
if (!_parse_uint8(sb, &r)) return EINA_FALSE;
|
||
ty_sb_spaces_ltrim(sb);
|
||
if (!_parse_uint8(sb, &g)) return EINA_FALSE;
|
||
ty_sb_spaces_ltrim(sb);
|
||
if (!_parse_uint8(sb, &b)) return EINA_FALSE;
|
||
ty_sb_spaces_ltrim(sb);
|
||
if (!_parse_uint8(sb, &a)) return EINA_FALSE;
|
||
|
||
*rp = r;
|
||
*gp = g;
|
||
*bp = b;
|
||
*ap = a;
|
||
return EINA_TRUE;
|
||
}
|
||
|
||
__attribute__((const))
|
||
static Eina_Bool
|
||
_is_authorized_in_color_sharp(const Eina_Unicode g)
|
||
{
|
||
if (g == '#' ||
|
||
(g >= '0' && g <= '9') ||
|
||
(g >= 'A' && g <= 'F') ||
|
||
(g >= 'a' && g <= 'f'))
|
||
return EINA_TRUE;
|
||
return EINA_FALSE;
|
||
}
|
||
|
||
static Eina_Bool
|
||
_parse_color(struct ty_sb *sb,
|
||
uint8_t *r, uint8_t *g, uint8_t *b, uint8_t *a)
|
||
{
|
||
if (!sb->len)
|
||
goto end;
|
||
|
||
if (sb->buf[0] == '#')
|
||
{
|
||
if (!_parse_sharp_color(sb, r, g, b, a))
|
||
goto end;
|
||
}
|
||
else if (sbstartswith(sb, "color"))
|
||
{
|
||
if (!_parse_edc_color(sb, r, g, b, a))
|
||
goto end;
|
||
}
|
||
else if (sbstartswith(sb, "rgb"))
|
||
{
|
||
if (!_parse_css_rgb_color(sb, r, g, b, a))
|
||
goto end;
|
||
}
|
||
else if (sbstartswith(sb, "hsl"))
|
||
{
|
||
if (!_parse_css_hsl_color(sb, r, g, b, a))
|
||
goto end;
|
||
}
|
||
else
|
||
goto end;
|
||
|
||
return EINA_TRUE;
|
||
|
||
end:
|
||
return EINA_FALSE;
|
||
}
|
||
|
||
#if !defined(BINARY_TYFUZZ_COLOR_PARSER)
|
||
static Eina_Bool
|
||
_sharp_color_find(Termpty *ty, int sc,
|
||
int *x1r, int *y1r, int *x2r, int *y2r,
|
||
uint8_t *rp, uint8_t *gp, uint8_t *bp, uint8_t *ap)
|
||
{
|
||
int x1 = *x1r, y1 = *y1r, x2 = *x2r, y2 = *y2r;
|
||
Eina_Bool goback = EINA_TRUE,
|
||
goforward = EINA_FALSE;
|
||
struct ty_sb sb = {.buf = NULL, .gap = 0, .len = 0, .alloc = 0};
|
||
int res;
|
||
char txt[8];
|
||
int txtlen = 0;
|
||
Eina_Bool found = EINA_FALSE;
|
||
int codepoint;
|
||
uint8_t r, g, b, a = 255;
|
||
|
||
res = _txt_at(ty, &x1, &y1, txt, &txtlen, &codepoint);
|
||
if ((res != 0) || (txtlen == 0))
|
||
goto end;
|
||
if (!_is_authorized_in_color_sharp(codepoint))
|
||
goto end;
|
||
res = ty_sb_add(&sb, txt, txtlen);
|
||
if (res < 0) goto end;
|
||
|
||
while (goback && sb.len <= 9)
|
||
{
|
||
int new_x1 = x1, new_y1 = y1;
|
||
|
||
res = _txt_prev_at(ty, &new_x1, &new_y1, txt, &txtlen, &codepoint);
|
||
if ((res != 0) || (txtlen == 0))
|
||
{
|
||
goback = EINA_FALSE;
|
||
goforward = EINA_TRUE;
|
||
break;
|
||
}
|
||
res = ty_sb_prepend(&sb, txt, txtlen);
|
||
if (res < 0) goto end;
|
||
if (!_is_authorized_in_color_sharp(codepoint))
|
||
{
|
||
ty_sb_lskip(&sb, txtlen);
|
||
goback = EINA_FALSE;
|
||
goforward = EINA_TRUE;
|
||
break;
|
||
}
|
||
|
||
x1 = new_x1;
|
||
y1 = new_y1;
|
||
}
|
||
|
||
while (goforward && sb.len <= 9)
|
||
{
|
||
int new_x2 = x2, new_y2 = y2;
|
||
|
||
/* Check if the previous char is a delimiter */
|
||
res = _txt_next_at(ty, &new_x2, &new_y2, txt, &txtlen, &codepoint);
|
||
if ((res != 0) || (txtlen == 0))
|
||
{
|
||
goforward = EINA_FALSE;
|
||
break;
|
||
}
|
||
|
||
if (!_is_authorized_in_color_sharp(codepoint))
|
||
{
|
||
goforward = EINA_FALSE;
|
||
break;
|
||
}
|
||
|
||
res = ty_sb_add(&sb, txt, txtlen);
|
||
if (res < 0) goto end;
|
||
|
||
x2 = new_x2;
|
||
y2 = new_y2;
|
||
}
|
||
|
||
if (sb.buf[0] == '#')
|
||
{
|
||
if (!_parse_sharp_color(&sb, &r, &g, &b, &a))
|
||
goto end;
|
||
found = EINA_TRUE;
|
||
}
|
||
end:
|
||
ty_sb_free(&sb);
|
||
if (found)
|
||
{
|
||
*rp = r;
|
||
*gp = g;
|
||
*bp = b;
|
||
*ap = a;
|
||
*x1r = x1;
|
||
*y1r = y1 + sc;
|
||
*x2r = x2;
|
||
*y2r = y2 + sc;
|
||
}
|
||
return found;
|
||
}
|
||
|
||
|
||
Eina_Bool
|
||
termio_color_find(const Evas_Object *obj, int cx, int cy,
|
||
int *x1r, int *y1r, int *x2r, int *y2r,
|
||
uint8_t *rp, uint8_t *gp, uint8_t *bp, uint8_t *ap)
|
||
{
|
||
int x1, x2, y1, y2, w = 0, h = 0, sc;
|
||
Eina_Bool goback = EINA_TRUE,
|
||
goforward = EINA_FALSE;
|
||
struct ty_sb sb = {.buf = NULL, .gap = 0, .len = 0, .alloc = 0};
|
||
Termpty *ty = termio_pty_get(obj);
|
||
int res;
|
||
char txt[8];
|
||
int txtlen = 0;
|
||
Eina_Bool found = EINA_FALSE;
|
||
int codepoint;
|
||
uint8_t r, g, b, a = 255;
|
||
|
||
EINA_SAFETY_ON_NULL_RETURN_VAL(ty, EINA_FALSE);
|
||
|
||
x1 = x2 = cx;
|
||
y1 = y2 = cy;
|
||
termio_size_get(obj, &w, &h);
|
||
if ((w <= 0) || (h <= 0)) goto end;
|
||
|
||
sc = termio_scroll_get(obj);
|
||
|
||
termpty_backlog_lock();
|
||
|
||
y1 -= sc;
|
||
y2 -= sc;
|
||
|
||
found = _sharp_color_find(ty, sc, &x1, &y1, &x2, &y2,
|
||
&r, &g, &b, &a);
|
||
if (found)
|
||
goto end;
|
||
|
||
res = _txt_at(ty, &x1, &y1, txt, &txtlen, &codepoint);
|
||
if ((res != 0) || (txtlen == 0))
|
||
goto end;
|
||
if (!_is_authorized_in_color(codepoint))
|
||
goto end;
|
||
res = ty_sb_add(&sb, txt, txtlen);
|
||
if (res < 0) goto end;
|
||
|
||
while (goback)
|
||
{
|
||
int new_x1 = x1, new_y1 = y1;
|
||
|
||
res = _txt_prev_at(ty, &new_x1, &new_y1, txt, &txtlen, &codepoint);
|
||
if ((res != 0) || (txtlen == 0))
|
||
{
|
||
goback = EINA_FALSE;
|
||
goforward = EINA_TRUE;
|
||
break;
|
||
}
|
||
res = ty_sb_prepend(&sb, txt, txtlen);
|
||
if (res < 0) goto end;
|
||
if (!_is_authorized_in_color(codepoint))
|
||
{
|
||
ty_sb_lskip(&sb, txtlen);
|
||
goback = EINA_FALSE;
|
||
goforward = EINA_TRUE;
|
||
break;
|
||
}
|
||
|
||
x1 = new_x1;
|
||
y1 = new_y1;
|
||
if (sbstartswith(&sb, "rgb") ||
|
||
sbstartswith(&sb, "hsl") ||
|
||
sbstartswith(&sb, "color"))
|
||
{
|
||
goback = EINA_FALSE;
|
||
goforward = EINA_TRUE;
|
||
break;
|
||
}
|
||
}
|
||
|
||
while (goforward)
|
||
{
|
||
int new_x2 = x2, new_y2 = y2;
|
||
|
||
/* Check if the previous char is a delimiter */
|
||
res = _txt_next_at(ty, &new_x2, &new_y2, txt, &txtlen, &codepoint);
|
||
if ((res != 0) || (txtlen == 0) ||
|
||
(!_is_authorized_in_color(codepoint) && (codepoint != ')')))
|
||
break;
|
||
|
||
res = ty_sb_add(&sb, txt, txtlen);
|
||
if (res < 0) goto end;
|
||
|
||
x2 = new_x2;
|
||
y2 = new_y2;
|
||
if (codepoint == ')')
|
||
break;
|
||
}
|
||
|
||
/* colors do not span multiple lines (for the moment) */
|
||
if (y1 != y2)
|
||
goto end;
|
||
|
||
/* Trim */
|
||
while (sb.len && (sb.buf[0] == ' ' || sb.buf[0] == '\t'))
|
||
{
|
||
sb.len--;
|
||
sb.buf++;
|
||
sb.gap++;
|
||
x1++;
|
||
}
|
||
while (sb.len && (sb.buf[sb.len-1] == ' ' || sb.buf[sb.len-1] == '\t'))
|
||
{
|
||
sb.len--;
|
||
x2--;
|
||
}
|
||
|
||
if (!_parse_color(&sb, &r, &g, &b, &a))
|
||
goto end;
|
||
|
||
|
||
found = EINA_TRUE;
|
||
|
||
end:
|
||
termpty_backlog_unlock();
|
||
ty_sb_free(&sb);
|
||
if (found)
|
||
{
|
||
if (rp) *rp = r;
|
||
if (gp) *gp = g;
|
||
if (bp) *bp = b;
|
||
if (ap) *ap = a;
|
||
if (x1r) *x1r = x1;
|
||
if (y1r) *y1r = y1 + sc;
|
||
if (x2r) *x2r = x2;
|
||
if (y2r) *y2r = y2 + sc;
|
||
}
|
||
return found;
|
||
}
|
||
|
||
#endif
|
||
#if defined(BINARY_TYTEST)
|
||
int
|
||
tytest_color_parse_hex(void)
|
||
{
|
||
uint8_t v = 42;
|
||
|
||
assert(_parse_hex('3', &v) == EINA_TRUE);
|
||
assert(v == 3);
|
||
|
||
assert(_parse_hex('b', &v) == EINA_TRUE);
|
||
assert(v == 11);
|
||
|
||
assert(_parse_hex('F', &v) == EINA_TRUE);
|
||
assert(v == 15);
|
||
|
||
assert(_parse_hex('@', &v) == EINA_FALSE);
|
||
assert(_parse_hex('#', &v) == EINA_FALSE);
|
||
assert(_parse_hex('G', &v) == EINA_FALSE);
|
||
assert(_parse_hex('_', &v) == EINA_FALSE);
|
||
assert(_parse_hex('g', &v) == EINA_FALSE);
|
||
assert(_parse_hex('~', &v) == EINA_FALSE);
|
||
|
||
return 0;
|
||
}
|
||
|
||
int
|
||
tytest_color_parse_2hex(void)
|
||
{
|
||
uint8_t v = 42;
|
||
|
||
assert(_parse_2hex("03", &v) == EINA_TRUE);
|
||
assert(v == 3);
|
||
|
||
assert(_parse_2hex("aF", &v) == EINA_TRUE);
|
||
assert(v == 175);
|
||
|
||
assert(_parse_2hex("44", &v) == EINA_TRUE);
|
||
assert(v == 68);
|
||
|
||
assert(_parse_2hex("gg", &v) == EINA_FALSE);
|
||
assert(_parse_2hex("@3", &v) == EINA_FALSE);
|
||
assert(_parse_2hex("#3", &v) == EINA_FALSE);
|
||
assert(_parse_2hex("G3", &v) == EINA_FALSE);
|
||
assert(_parse_2hex("_3", &v) == EINA_FALSE);
|
||
assert(_parse_2hex("~3", &v) == EINA_FALSE);
|
||
return 0;
|
||
}
|
||
|
||
int
|
||
tytest_color_parse_sharp(void)
|
||
{
|
||
struct ty_sb sb = {};
|
||
uint8_t r = 0, g = 0, b = 0, a = 0;
|
||
|
||
/* 3 letters */
|
||
assert(TY_SB_ADD(&sb, "#fab") == 0);
|
||
assert(_parse_sharp_color(&sb, &r, &g, &b, &a) == EINA_TRUE);
|
||
assert(r == 240 && g == 160 && b == 176 && a == 255);
|
||
ty_sb_free(&sb);
|
||
|
||
/* 4 letters */
|
||
assert(TY_SB_ADD(&sb, "#2345") == 0);
|
||
assert(_parse_sharp_color(&sb, &r, &g, &b, &a) == EINA_TRUE);
|
||
assert(r == 32 && g == 48 && b == 64 && a == 80);
|
||
ty_sb_free(&sb);
|
||
|
||
/* 6 letters */
|
||
assert(TY_SB_ADD(&sb, "#decfab") == 0);
|
||
assert(_parse_sharp_color(&sb, &r, &g, &b, &a) == EINA_TRUE);
|
||
assert(r == 222 && g == 207 && b == 171 && a == 255);
|
||
ty_sb_free(&sb);
|
||
|
||
/* 8 letters */
|
||
assert(TY_SB_ADD(&sb, "#fabdec86") == 0);
|
||
assert(_parse_sharp_color(&sb, &r, &g, &b, &a) == EINA_TRUE);
|
||
assert(r == 250 && g == 189 && b == 236 && a == 134);
|
||
ty_sb_free(&sb);
|
||
|
||
/* upper case */
|
||
assert(TY_SB_ADD(&sb, "#DECFAB") == 0);
|
||
assert(_parse_sharp_color(&sb, &r, &g, &b, &a) == EINA_TRUE);
|
||
assert(r == 222 && g == 207 && b == 171 && a == 255);
|
||
ty_sb_free(&sb);
|
||
|
||
/* mixed case */
|
||
assert(TY_SB_ADD(&sb, "#fAbDeC") == 0);
|
||
assert(_parse_sharp_color(&sb, &r, &g, &b, &a) == EINA_TRUE);
|
||
assert(r == 250 && g == 189 && b == 236 && a == 255);
|
||
ty_sb_free(&sb);
|
||
|
||
/* Invalid*/
|
||
/* improper start */
|
||
assert(TY_SB_ADD(&sb, "~decfab") == 0);
|
||
assert(_parse_sharp_color(&sb, &r, &g, &b, &a) == EINA_FALSE);
|
||
ty_sb_free(&sb);
|
||
/* improper ending */
|
||
assert(TY_SB_ADD(&sb, "#decfab;") == 0);
|
||
assert(_parse_sharp_color(&sb, &r, &g, &b, &a) == EINA_FALSE);
|
||
ty_sb_free(&sb);
|
||
/* invalid hex */
|
||
assert(TY_SB_ADD(&sb, "#dgc") == 0);
|
||
assert(_parse_sharp_color(&sb, &r, &g, &b, &a) == EINA_FALSE);
|
||
ty_sb_free(&sb);
|
||
assert(TY_SB_ADD(&sb, "#dgca") == 0);
|
||
assert(_parse_sharp_color(&sb, &r, &g, &b, &a) == EINA_FALSE);
|
||
ty_sb_free(&sb);
|
||
assert(TY_SB_ADD(&sb, "#dgcaca") == 0);
|
||
assert(_parse_sharp_color(&sb, &r, &g, &b, &a) == EINA_FALSE);
|
||
ty_sb_free(&sb);
|
||
assert(TY_SB_ADD(&sb, "#dgcacaca") == 0);
|
||
assert(_parse_sharp_color(&sb, &r, &g, &b, &a) == EINA_FALSE);
|
||
ty_sb_free(&sb);
|
||
assert(TY_SB_ADD(&sb, "#dgcacaca") == 0);
|
||
assert(_parse_sharp_color(&sb, &r, &g, &b, &a) == EINA_FALSE);
|
||
ty_sb_free(&sb);
|
||
/* invalid length */
|
||
assert(TY_SB_ADD(&sb, "#a") == 0);
|
||
assert(_parse_sharp_color(&sb, &r, &g, &b, &a) == EINA_FALSE);
|
||
ty_sb_free(&sb);
|
||
assert(TY_SB_ADD(&sb, "#da") == 0);
|
||
assert(_parse_sharp_color(&sb, &r, &g, &b, &a) == EINA_FALSE);
|
||
ty_sb_free(&sb);
|
||
assert(TY_SB_ADD(&sb, "#dadad") == 0);
|
||
assert(_parse_sharp_color(&sb, &r, &g, &b, &a) == EINA_FALSE);
|
||
ty_sb_free(&sb);
|
||
assert(TY_SB_ADD(&sb, "#dadadad") == 0);
|
||
assert(_parse_sharp_color(&sb, &r, &g, &b, &a) == EINA_FALSE);
|
||
ty_sb_free(&sb);
|
||
assert(TY_SB_ADD(&sb, "#dadadadad") == 0);
|
||
assert(_parse_sharp_color(&sb, &r, &g, &b, &a) == EINA_FALSE);
|
||
ty_sb_free(&sb);
|
||
return 0;
|
||
}
|
||
|
||
int
|
||
tytest_color_parse_uint8(void)
|
||
{
|
||
struct ty_sb sb = {};
|
||
uint8_t v = 0;
|
||
|
||
/* 1 digit (with/without ending) */
|
||
assert(TY_SB_ADD(&sb, "3 ") == 0);
|
||
assert(_parse_uint8(&sb, &v) == EINA_TRUE);
|
||
assert(v == 3);
|
||
ty_sb_free(&sb);
|
||
assert(TY_SB_ADD(&sb, "4") == 0);
|
||
assert(_parse_uint8(&sb, &v) == EINA_TRUE);
|
||
assert(v == 4);
|
||
ty_sb_free(&sb);
|
||
|
||
/* 2 digit (with/without ending) */
|
||
assert(TY_SB_ADD(&sb, "12 ") == 0);
|
||
assert(_parse_uint8(&sb, &v) == EINA_TRUE);
|
||
assert(v == 12);
|
||
ty_sb_free(&sb);
|
||
assert(TY_SB_ADD(&sb, "34") == 0);
|
||
assert(_parse_uint8(&sb, &v) == EINA_TRUE);
|
||
assert(v == 34);
|
||
ty_sb_free(&sb);
|
||
|
||
/* 3 digit (with/without ending) */
|
||
assert(TY_SB_ADD(&sb, "123 ") == 0);
|
||
assert(_parse_uint8(&sb, &v) == EINA_TRUE);
|
||
assert(v == 123);
|
||
ty_sb_free(&sb);
|
||
assert(TY_SB_ADD(&sb, "234") == 0);
|
||
assert(_parse_uint8(&sb, &v) == EINA_TRUE);
|
||
assert(v == 234);
|
||
ty_sb_free(&sb);
|
||
|
||
/* ending with semicolon */
|
||
assert(TY_SB_ADD(&sb, "42;") == 0);
|
||
assert(_parse_uint8(&sb, &v) == EINA_TRUE);
|
||
assert(v == 42);
|
||
ty_sb_free(&sb);
|
||
|
||
/* 0 padded */
|
||
assert(TY_SB_ADD(&sb, "012") == 0);
|
||
assert(_parse_uint8(&sb, &v) == EINA_TRUE);
|
||
assert(v == 12);
|
||
ty_sb_free(&sb);
|
||
assert(TY_SB_ADD(&sb, "007") == 0);
|
||
assert(_parse_uint8(&sb, &v) == EINA_TRUE);
|
||
assert(v == 7);
|
||
ty_sb_free(&sb);
|
||
|
||
/* too large */
|
||
assert(TY_SB_ADD(&sb, "256") == 0);
|
||
assert(_parse_uint8(&sb, &v) == EINA_FALSE);
|
||
ty_sb_free(&sb);
|
||
/* too long */
|
||
assert(TY_SB_ADD(&sb, "1234") == 0);
|
||
assert(_parse_uint8(&sb, &v) == EINA_FALSE);
|
||
ty_sb_free(&sb);
|
||
/* not a digit */
|
||
assert(TY_SB_ADD(&sb, "a") == 0);
|
||
assert(_parse_uint8(&sb, &v) == EINA_FALSE);
|
||
ty_sb_free(&sb);
|
||
assert(TY_SB_ADD(&sb, ".") == 0);
|
||
assert(_parse_uint8(&sb, &v) == EINA_FALSE);
|
||
ty_sb_free(&sb);
|
||
|
||
return 0;
|
||
}
|
||
|
||
int
|
||
tytest_color_parse_edc(void)
|
||
{
|
||
struct ty_sb sb = {};
|
||
uint8_t r = 0, g = 0, b = 0, a = 0;
|
||
|
||
/* color */
|
||
assert(TY_SB_ADD(&sb, " color: 51 153 255 32;") == 0);
|
||
assert(_parse_edc_color(&sb, &r, &g, &b, &a) == EINA_TRUE);
|
||
assert(r == 51 && g == 153 && b == 255 && a == 32);
|
||
ty_sb_free(&sb);
|
||
|
||
/* color2 */
|
||
assert(TY_SB_ADD(&sb, " color2: 244 99 93 127;") == 0);
|
||
assert(_parse_edc_color(&sb, &r, &g, &b, &a) == EINA_TRUE);
|
||
assert(r == 244 && g == 99 && b == 93 && a == 127);
|
||
ty_sb_free(&sb);
|
||
|
||
/* color3 */
|
||
assert(TY_SB_ADD(&sb, " color3: 149 181 16 234;") == 0);
|
||
assert(_parse_edc_color(&sb, &r, &g, &b, &a) == EINA_TRUE);
|
||
assert(r == 149 && g == 181 && b == 16 && a == 234);
|
||
ty_sb_free(&sb);
|
||
|
||
/* color: #color */
|
||
assert(TY_SB_ADD(&sb, " color: #3399ff20") == 0);
|
||
assert(_parse_edc_color(&sb, &r, &g, &b, &a) == EINA_TRUE);
|
||
assert(r == 51 && g == 153 && b == 255 && a == 32);
|
||
ty_sb_free(&sb);
|
||
|
||
/* with tabs */
|
||
assert(TY_SB_ADD(&sb, " color\t:\t244\t99\t93\t127\t;") == 0);
|
||
assert(_parse_edc_color(&sb, &r, &g, &b, &a) == EINA_TRUE);
|
||
assert(r == 244 && g == 99 && b == 93 && a == 127);
|
||
ty_sb_free(&sb);
|
||
|
||
/* invalid */
|
||
assert(TY_SB_ADD(&sb, " color: COL;") == 0);
|
||
assert(_parse_edc_color(&sb, &r, &g, &b, &a) == EINA_FALSE);
|
||
ty_sb_free(&sb);
|
||
|
||
return 0;
|
||
}
|
||
|
||
int
|
||
tytest_color_parse_css_rgb(void)
|
||
{
|
||
struct ty_sb sb = {};
|
||
uint8_t r = 0, g = 0, b = 0, a = 0;
|
||
|
||
/* (rgb) Functional syntax */
|
||
assert(TY_SB_ADD(&sb, "rgb(255,1,153)") == 0);
|
||
assert(_parse_css_rgb_color(&sb, &r, &g, &b, &a) == EINA_TRUE);
|
||
assert(r == 255 && g == 1 && b == 153 && a == 255);
|
||
ty_sb_free(&sb);
|
||
|
||
assert(TY_SB_ADD(&sb, "rgb(254, 2, 152)") == 0);
|
||
assert(_parse_css_rgb_color(&sb, &r, &g, &b, &a) == EINA_TRUE);
|
||
assert(r == 254 && g == 2 && b == 152 && a == 255);
|
||
ty_sb_free(&sb);
|
||
|
||
assert(TY_SB_ADD(&sb, "rgb(253, 3, 151.0)") == 0);
|
||
assert(_parse_css_rgb_color(&sb, &r, &g, &b, &a) == EINA_TRUE);
|
||
assert(r == 253 && g == 3 && b == 151 && a == 255);
|
||
ty_sb_free(&sb);
|
||
|
||
/* (rgb) Percents */
|
||
assert(TY_SB_ADD(&sb, "rgb(100%,4%,40%)") == 0);
|
||
assert(_parse_css_rgb_color(&sb, &r, &g, &b, &a) == EINA_TRUE);
|
||
assert(r == 255 && g == 10 && b == 102 && a == 255);
|
||
ty_sb_free(&sb);
|
||
|
||
assert(TY_SB_ADD(&sb, "rgb(50%, 0%, 60%)") == 0);
|
||
assert(_parse_css_rgb_color(&sb, &r, &g, &b, &a) == EINA_TRUE);
|
||
assert(r == 127 && g == 0 && b == 153 && a == 255);
|
||
ty_sb_free(&sb);
|
||
|
||
/* (rgb) ERROR! Don't mix numbers and percentages. */
|
||
assert(TY_SB_ADD(&sb, "rgb(100%, 0, 60%)") == 0);
|
||
assert(_parse_css_rgb_color(&sb, &r, &g, &b, &a) == EINA_FALSE);
|
||
ty_sb_free(&sb);
|
||
|
||
/* (rgb) Functional syntax with alpha value */
|
||
assert(TY_SB_ADD(&sb, "rgb(254, 1, 150, 0)") == 0);
|
||
assert(_parse_css_rgb_color(&sb, &r, &g, &b, &a) == EINA_TRUE);
|
||
assert(r == 254 && g == 1 && b == 150 && a == 0);
|
||
ty_sb_free(&sb);
|
||
assert(TY_SB_ADD(&sb, "rgb(253, 2, 149, 1)") == 0);
|
||
assert(_parse_css_rgb_color(&sb, &r, &g, &b, &a) == EINA_TRUE);
|
||
assert(r == 253 && g == 2 && b == 149 && a == 255);
|
||
ty_sb_free(&sb);
|
||
assert(TY_SB_ADD(&sb, "rgb(252, 3, 148, 50%)") == 0);
|
||
assert(_parse_css_rgb_color(&sb, &r, &g, &b, &a) == EINA_TRUE);
|
||
assert(r == 252 && g == 3 && b == 148 && a == 128);
|
||
ty_sb_free(&sb);
|
||
|
||
/* (rgb) Whitespace syntax */
|
||
assert(TY_SB_ADD(&sb, "rgb(255 0 153)") == 0);
|
||
assert(_parse_css_rgb_color(&sb, &r, &g, &b, &a) == EINA_TRUE);
|
||
assert(r == 255 && g == 0 && b == 153 && a == 255);
|
||
ty_sb_free(&sb);
|
||
assert(TY_SB_ADD(&sb, "rgb(254 1 152 / 0)") == 0);
|
||
assert(_parse_css_rgb_color(&sb, &r, &g, &b, &a) == EINA_TRUE);
|
||
assert(r == 254 && g == 1 && b == 152 && a == 0);
|
||
ty_sb_free(&sb);
|
||
assert(TY_SB_ADD(&sb, "rgb(253 2 151 / 100%)") == 0);
|
||
assert(_parse_css_rgb_color(&sb, &r, &g, &b, &a) == EINA_TRUE);
|
||
assert(r == 253 && g == 2 && b == 151 && a == 255);
|
||
ty_sb_free(&sb);
|
||
|
||
/* (rgb) Functional syntax with floats value */
|
||
assert(TY_SB_ADD(&sb, "rgb(255, 0, 153.6, 1)") == 0);
|
||
assert(_parse_css_rgb_color(&sb, &r, &g, &b, &a) == EINA_TRUE);
|
||
assert(r == 255 && g == 0 && b == 154 && a == 255);
|
||
ty_sb_free(&sb);
|
||
assert(TY_SB_ADD(&sb, "rgb(1e2, .5e1, .5e0, +.25e2%)") == 0);
|
||
assert(_parse_css_rgb_color(&sb, &r, &g, &b, &a) == EINA_TRUE);
|
||
assert(r == 100 && g == 5 && b == 1 && a == 64);
|
||
ty_sb_free(&sb);
|
||
|
||
/* (rgba) Functional syntax */
|
||
assert(TY_SB_ADD(&sb, "rgba(51, 170, 51, .1)") == 0); /* 10% opaque green */
|
||
assert(_parse_css_rgb_color(&sb, &r, &g, &b, &a) == EINA_TRUE);
|
||
assert(r == 51 && g == 170 && b == 51 && a == 26);
|
||
ty_sb_free(&sb);
|
||
assert(TY_SB_ADD(&sb, "rgba(50, 171, 52, .4)") == 0); /* 40% opaque green */
|
||
assert(_parse_css_rgb_color(&sb, &r, &g, &b, &a) == EINA_TRUE);
|
||
assert(r == 50 && g == 171 && b == 52 && a == 102);
|
||
ty_sb_free(&sb);
|
||
assert(TY_SB_ADD(&sb, "rgba(49, 172, 53, .7)") == 0); /* 70% opaque green */
|
||
assert(_parse_css_rgb_color(&sb, &r, &g, &b, &a) == EINA_TRUE);
|
||
assert(r == 49 && g == 172 && b == 53 && a == 179);
|
||
ty_sb_free(&sb);
|
||
assert(TY_SB_ADD(&sb, "rgba(48, 173, 54, 1)") == 0); /* full opaque green */
|
||
assert(_parse_css_rgb_color(&sb, &r, &g, &b, &a) == EINA_TRUE);
|
||
assert(r == 48 && g == 173 && b == 54 && a == 255);
|
||
ty_sb_free(&sb);
|
||
|
||
/* (rgba) Whitespace syntax */
|
||
assert(TY_SB_ADD(&sb, "rgba(51 170 51 / 0.4)") == 0); /* 40% opaque green */
|
||
assert(_parse_css_rgb_color(&sb, &r, &g, &b, &a) == EINA_TRUE);
|
||
assert(r == 51 && g == 170 && b == 51 && a == 102);
|
||
ty_sb_free(&sb);
|
||
assert(TY_SB_ADD(&sb, "rgba(50 171 50 / 70%)") == 0); /* 40% opaque green */
|
||
assert(_parse_css_rgb_color(&sb, &r, &g, &b, &a) == EINA_TRUE);
|
||
assert(r == 50 && g == 171 && b == 50 && a == 179);
|
||
ty_sb_free(&sb);
|
||
/* (rgba) ERROR! invalid alpha */
|
||
assert(TY_SB_ADD(&sb, "rgba(51 170 51 / 40)") == 0);
|
||
assert(_parse_css_rgb_color(&sb, &r, &g, &b, &a) == EINA_FALSE);
|
||
ty_sb_free(&sb);
|
||
|
||
/* (rgba) Functional syntax with floats value */
|
||
assert(TY_SB_ADD(&sb, "rgba(255, 0, 153.6, 1)") == 0);
|
||
assert(_parse_css_rgb_color(&sb, &r, &g, &b, &a) == EINA_TRUE);
|
||
assert(r == 255 && g == 0 && b == 154 && a == 255);
|
||
ty_sb_free(&sb);
|
||
assert(TY_SB_ADD(&sb, "rgba(1e2, .5e1, .5e0, +.25e2%)") == 0);
|
||
assert(_parse_css_rgb_color(&sb, &r, &g, &b, &a) == EINA_TRUE);
|
||
assert(r == 100 && g == 5 && b == 1 && a == 64);
|
||
ty_sb_free(&sb);
|
||
|
||
return 0;
|
||
}
|
||
|
||
int
|
||
tytest_color_parse_css_hsl(void)
|
||
{
|
||
struct ty_sb sb = {};
|
||
uint8_t r = 0, g = 0, b = 0, a = 0;
|
||
|
||
|
||
/* These examples all specify the same color: a lavender. */
|
||
assert(TY_SB_ADD(&sb, "hsl(270,60%,70%)") == 0);
|
||
assert(_parse_css_hsl_color(&sb, &r, &g, &b, &a) == EINA_TRUE);
|
||
assert(r == 178 && g == 132 && b == 224 && a == 255);
|
||
ty_sb_free(&sb);
|
||
r = g = b = a = 0;
|
||
|
||
assert(TY_SB_ADD(&sb, "hsl(270, 60%, 70%)") == 0);
|
||
assert(_parse_css_hsl_color(&sb, &r, &g, &b, &a) == EINA_TRUE);
|
||
assert(r == 178 && g == 132 && b == 224 && a == 255);
|
||
ty_sb_free(&sb);
|
||
r = g = b = a = 0;
|
||
|
||
assert(TY_SB_ADD(&sb, "hsl(270 60% 70%)") == 0);
|
||
assert(_parse_css_hsl_color(&sb, &r, &g, &b, &a) == EINA_TRUE);
|
||
assert(r == 178 && g == 132 && b == 224 && a == 255);
|
||
ty_sb_free(&sb);
|
||
r = g = b = a = 0;
|
||
|
||
assert(TY_SB_ADD(&sb, "hsl(270deg, 60%, 70%)") == 0);
|
||
assert(_parse_css_hsl_color(&sb, &r, &g, &b, &a) == EINA_TRUE);
|
||
assert(r == 178 && g == 132 && b == 224 && a == 255);
|
||
ty_sb_free(&sb);
|
||
r = g = b = a = 0;
|
||
|
||
assert(TY_SB_ADD(&sb, "hsl(4.71239rad, 60%, 70%)") == 0);
|
||
assert(_parse_css_hsl_color(&sb, &r, &g, &b, &a) == EINA_TRUE);
|
||
assert(r == 178 && g == 132 && b == 224 && a == 255);
|
||
ty_sb_free(&sb);
|
||
r = g = b = a = 0;
|
||
|
||
assert(TY_SB_ADD(&sb, "hsl(300grad, 60%, 70%)") == 0);
|
||
assert(_parse_css_hsl_color(&sb, &r, &g, &b, &a) == EINA_TRUE);
|
||
assert(r == 178 && g == 132 && b == 224 && a == 255);
|
||
ty_sb_free(&sb);
|
||
r = g = b = a = 0;
|
||
|
||
assert(TY_SB_ADD(&sb, "hsl(.75turn, 60%, 70%)") == 0);
|
||
assert(_parse_css_hsl_color(&sb, &r, &g, &b, &a) == EINA_TRUE);
|
||
assert(r == 178 && g == 132 && b == 224 && a == 255);
|
||
ty_sb_free(&sb);
|
||
r = g = b = a = 0;
|
||
|
||
|
||
/* These examples all specify the same color: a lavender that is 15% opaque. */
|
||
assert(TY_SB_ADD(&sb, "hsl(270, 60%, 50%, .15)") == 0);
|
||
assert(_parse_css_hsl_color(&sb, &r, &g, &b, &a) == EINA_TRUE);
|
||
assert(r == 127 && g == 51 && b == 204 && a == 38);
|
||
ty_sb_free(&sb);
|
||
r = g = b = a = 0;
|
||
|
||
assert(TY_SB_ADD(&sb, "hsl(270, 60%, 50%, 15%)") == 0);
|
||
assert(_parse_css_hsl_color(&sb, &r, &g, &b, &a) == EINA_TRUE);
|
||
assert(r == 127 && g == 51 && b == 204 && a == 38);
|
||
ty_sb_free(&sb);
|
||
r = g = b = a = 0;
|
||
|
||
assert(TY_SB_ADD(&sb, "hsl(270 60% 50% / .15)") == 0);
|
||
assert(_parse_css_hsl_color(&sb, &r, &g, &b, &a) == EINA_TRUE);
|
||
assert(r == 127 && g == 51 && b == 204 && a == 38);
|
||
ty_sb_free(&sb);
|
||
r = g = b = a = 0;
|
||
|
||
assert(TY_SB_ADD(&sb, "hsl(270 60% 50% / 15%)") == 0);
|
||
assert(_parse_css_hsl_color(&sb, &r, &g, &b, &a) == EINA_TRUE);
|
||
assert(r == 127 && g == 51 && b == 204 && a == 38);
|
||
ty_sb_free(&sb);
|
||
r = g = b = a = 0;
|
||
|
||
|
||
/* Different shades */
|
||
assert(TY_SB_ADD(&sb, "hsla(240, 100%, 50%, .05)") == 0);
|
||
assert(_parse_css_hsl_color(&sb, &r, &g, &b, &a) == EINA_TRUE);
|
||
assert(r == 0 && g == 0 && b == 255 && a == 13);
|
||
ty_sb_free(&sb);
|
||
r = g = b = a = 0;
|
||
|
||
assert(TY_SB_ADD(&sb, "hsla(240, 100%, 50%, .4)") == 0);
|
||
assert(_parse_css_hsl_color(&sb, &r, &g, &b, &a) == EINA_TRUE);
|
||
assert(r == 0 && g == 0 && b == 255 && a == 102);
|
||
ty_sb_free(&sb);
|
||
r = g = b = a = 0;
|
||
|
||
assert(TY_SB_ADD(&sb, "hsla(240, 100%, 50%, .7)") == 0);
|
||
assert(_parse_css_hsl_color(&sb, &r, &g, &b, &a) == EINA_TRUE);
|
||
assert(r == 0 && g == 0 && b == 255 && a == 179);
|
||
ty_sb_free(&sb);
|
||
r = g = b = a = 0;
|
||
|
||
assert(TY_SB_ADD(&sb, "hsla(240, 100%, 50%, 1)") == 0);
|
||
assert(_parse_css_hsl_color(&sb, &r, &g, &b, &a) == EINA_TRUE);
|
||
assert(r == 0 && g == 0 && b == 255 && a == 255);
|
||
ty_sb_free(&sb);
|
||
r = g = b = a = 0;
|
||
|
||
/* Whitespace syntax */
|
||
assert(TY_SB_ADD(&sb, "hsla(240 100% 50% / .05)") == 0);
|
||
assert(_parse_css_hsl_color(&sb, &r, &g, &b, &a) == EINA_TRUE);
|
||
assert(r == 0 && g == 0 && b == 255 && a == 13);
|
||
ty_sb_free(&sb);
|
||
r = g = b = a = 0;
|
||
|
||
/* Percentage value for alpha */
|
||
assert(TY_SB_ADD(&sb, "hsla(240 100% 50% / 5%)") == 0);
|
||
assert(_parse_css_hsl_color(&sb, &r, &g, &b, &a) == EINA_TRUE);
|
||
assert(r == 0 && g == 0 && b == 255 && a == 13);
|
||
ty_sb_free(&sb);
|
||
r = g = b = a = 0;
|
||
|
||
return 0;
|
||
}
|
||
#endif
|
||
#if defined(BINARY_TYFUZZ_COLOR_PARSER)
|
||
int
|
||
LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
|
||
{
|
||
struct ty_sb sb = {};
|
||
uint8_t r, g, b, a;
|
||
|
||
assert(!ty_sb_add(&sb, (const char*)data, size));
|
||
_parse_color(&sb, &r, &g, &b, &a);
|
||
ty_sb_free(&sb);
|
||
return 0;
|
||
}
|
||
#endif
|