Skip to content

Instantly share code, notes, and snippets.

@kanatohodets

kanatohodets/gist:b49fd88fc5fb70a2426b Secret

Created January 23, 2014 00:52
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save kanatohodets/b49fd88fc5fb70a2426b to your computer and use it in GitHub Desktop.
Save kanatohodets/b49fd88fc5fb70a2426b to your computer and use it in GitHub Desktop.
Download ZIP
build failure for Moar RC1
Raw
gistfile1.txt
18:49:51 [~/Downloads/MoarVM-2014.01] btyler$ ls
3rdparty CREDITS LICENSE README.markdown build docs src
Artistic2.txt Configure.pl MANIFEST VERSION check.todo lib tools
18:49:51 [~/Downloads/MoarVM-2014.01] btyler$ perl Configure.pl
Welcome to MoarVM!
Configuring native build environment ................... OK
make: make
compile: clang -fno-omit-frame-pointer -fno-optimize-sibling-calls -O1 -D_DARWIN_USE_64_BIT_INODE=1
link: clang -O1 -Wl,-rpath,$(PREFIX)/lib
libs: -lpthread
byte order: little endian
Configuring 3rdparty libs .............................. OK
3rdparty: 3rdparty/dyncall/dyncall/libdyncall_s.a
3rdparty/dyncall/dyncallback/libdyncallback_s.a
3rdparty/dyncall/dynload/libdynload_s.a
3rdparty/libatomic_ops/src/libatomic_ops.a
3rdparty/libtommath/libtommath.a
3rdparty/libuv/libuv.a
3rdparty/linenoise/liblinenoise.a
3rdparty/sha1/libsha1.a
3rdparty/tinymt/libtinymt.a
Generating src/gen/config.c ............................ OK
Generating src/gen/config.h ............................ OK
Generating Makefile .................................... OK
Generating tools/check.mk .............................. OK
Configuration SUCCESS.
Type 'make' to build and 'make help' to see a list of
available make targets.
18:49:53 [~/Downloads/MoarVM-2014.01] btyler$ make
compiling src/main.o
compiling src/core/args.o
compiling src/core/exceptions.o
src/core/exceptions.c:219:11: warning: initializing 'char *' with an expression of type 'MVMuint8 *' (aka 'unsigned char *') converts between pointers
to integer types with different sign [-Wpointer-sign]
char *tmp1 = annot && string_heap_index < cur_frame->static_info->body.cu->body.num_strings
^ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1 warning generated.
compiling src/core/interp.o
compiling src/core/threadcontext.o
compiling src/core/compunit.o
compiling src/core/bytecode.o
src/core/bytecode.c:132:39: warning: passing 'char *' to parameter of type 'MVMuint8 *' (aka 'unsigned char *') converts between pointers to integer
types with different sign [-Wpointer-sign]
MVMuint32 heap_index = read_int32(buffer, offset);
^~~~~~
src/core/bytecode.c:84:39: note: passing argument to parameter 'buffer' here
static MVMuint32 read_int32(MVMuint8 *buffer, size_t offset) {
^
src/core/bytecode.c:216:29: warning: assigning to 'char *' from 'MVMuint8 *' (aka 'unsigned char *') converts between pointers to integer types with
different sign [-Wpointer-sign]
cu_body->serialized = cu_body->data_start + offset;
^ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
src/core/bytecode.c:280:95: warning: passing 'MVMuint8 *' (aka 'unsigned char *') to parameter of type 'const char *' converts between pointers to
integer types with different sign [-Wpointer-sign]
MVM_ASSIGN_REF(tc, cu, strings[i], MVM_string_utf8_decode(tc, tc->instance->VMString, pos, ss));
^~~
src/gc/wb.h:18:20: note: expanded from macro 'MVM_ASSIGN_REF'
void *_r = referenced; \
^
src/strings/utf8.h:1:105: note: passing argument to parameter 'utf8' here
MVM_PUBLIC MVMString * MVM_string_utf8_decode(MVMThreadContext *tc, MVMObject *result_type, const char *utf8, size_t bytes);
^
src/core/bytecode.c:523:96: warning: passing 'MVMuint8 *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer
types with different sign [-Wpointer-sign]
MVM_ASSIGN_REF(tc, static_frame, static_frame_body->cuuid, get_heap_string(tc, cu, rs, pos, 16));
^~~
src/gc/wb.h:18:20: note: expanded from macro 'MVM_ASSIGN_REF'
void *_r = referenced; \
^
src/core/bytecode.c:130:98: note: passing argument to parameter 'buffer' here
static MVMString * get_heap_string(MVMThreadContext *tc, MVMCompUnit *cu, ReaderState *rs, char *buffer, size_t offset) {
^
src/core/bytecode.c:524:95: warning: passing 'MVMuint8 *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer
types with different sign [-Wpointer-sign]
MVM_ASSIGN_REF(tc, static_frame, static_frame_body->name, get_heap_string(tc, cu, rs, pos, 20));
^~~
src/gc/wb.h:18:20: note: expanded from macro 'MVM_ASSIGN_REF'
void *_r = referenced; \
^
src/core/bytecode.c:130:98: note: passing argument to parameter 'buffer' here
static MVMString * get_heap_string(MVMThreadContext *tc, MVMCompUnit *cu, ReaderState *rs, char *buffer, size_t offset) {
^
src/core/bytecode.c:570:63: warning: passing 'MVMuint8 *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer
types with different sign [-Wpointer-sign]
MVMString *name = get_heap_string(tc, cu, rs, pos, 6 * j + 2);
^~~
src/core/bytecode.c:130:98: note: passing argument to parameter 'buffer' here
static MVMString * get_heap_string(MVMThreadContext *tc, MVMCompUnit *cu, ReaderState *rs, char *buffer, size_t offset) {
^
src/core/bytecode.c:778:40: warning: comparison of unsigned expression >= 0 is always true [-Wtautological-compare]
if (sfb->num_annotations && offset >= 0 && offset < sfb->bytecode_size) {
~~~~~~ ^ ~
src/core/bytecode.c:779:18: warning: initializing 'MVMint8 *' (aka 'signed char *') with an expression of type 'MVMuint8 *' (aka 'unsigned char *')
converts between pointers to integer types with different sign [-Wpointer-sign]
MVMint8 *cur_anno = sfb->annotations_data;
^ ~~~~~~~~~~~~~~~~~~~~~
src/core/bytecode.c:781:46: warning: passing 'MVMint8 *' (aka 'signed char *') to parameter of type 'MVMuint8 *' (aka 'unsigned char *') converts
between pointers to integer types with different sign [-Wpointer-sign]
MVMint32 ann_offset = read_int32(cur_anno, 0);
^~~~~~~~
src/core/bytecode.c:84:39: note: passing argument to parameter 'buffer' here
static MVMuint32 read_int32(MVMuint8 *buffer, size_t offset) {
^
src/core/bytecode.c:789:42: warning: passing 'MVMint8 *' (aka 'signed char *') to parameter of type 'MVMuint8 *' (aka 'unsigned char *') converts
between pointers to integer types with different sign [-Wpointer-sign]
ba->bytecode_offset = read_int32(cur_anno, 0);
^~~~~~~~
src/core/bytecode.c:84:39: note: passing argument to parameter 'buffer' here
static MVMuint32 read_int32(MVMuint8 *buffer, size_t offset) {
^
src/core/bytecode.c:790:53: warning: passing 'MVMint8 *' (aka 'signed char *') to parameter of type 'MVMuint8 *' (aka 'unsigned char *') converts
between pointers to integer types with different sign [-Wpointer-sign]
ba->filename_string_heap_index = read_int32(cur_anno, 4);
^~~~~~~~
src/core/bytecode.c:84:39: note: passing argument to parameter 'buffer' here
static MVMuint32 read_int32(MVMuint8 *buffer, size_t offset) {
^
src/core/bytecode.c:791:38: warning: passing 'MVMint8 *' (aka 'signed char *') to parameter of type 'MVMuint8 *' (aka 'unsigned char *') converts
between pointers to integer types with different sign [-Wpointer-sign]
ba->line_number = read_int32(cur_anno, 8);
^~~~~~~~
src/core/bytecode.c:84:39: note: passing argument to parameter 'buffer' here
static MVMuint32 read_int32(MVMuint8 *buffer, size_t offset) {
^
12 warnings generated.
compiling src/core/frame.o
compiling src/core/validation.o
compiling src/core/bytecodedump.o
compiling src/core/threads.o
compiling src/core/ops.o
compiling src/core/hll.o
compiling src/core/loadbytecode.o
compiling src/math/num.o
compiling src/core/coerce.o
src/core/coerce.c:223:15: warning: initializing 'char *' with an expression of type 'MVMuint8 *' (aka 'unsigned char *') converts between pointers to
integer types with different sign [-Wpointer-sign]
char *enc = MVM_string_ascii_encode(tc, s, NULL);
^ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
src/core/coerce.c:230:15: warning: initializing 'char *' with an expression of type 'MVMuint8 *' (aka 'unsigned char *') converts between pointers to
integer types with different sign [-Wpointer-sign]
char *enc = MVM_string_ascii_encode(tc, s, NULL);
^ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2 warnings generated.
compiling src/core/dll.o
compiling src/core/ext.o
compiling src/core/continuation.o
compiling src/gen/config.o
compiling src/gc/orchestrate.o
compiling src/gc/allocation.o
compiling src/gc/worklist.o
compiling src/gc/roots.o
compiling src/io/fileops.o
src/io/fileops.c:646:48: warning: passing 'MVMint64 *' (aka 'long long *') to parameter of type 'MVMuint64 *' (aka 'unsigned long long *') converts
between pointers to integer types with different sign [-Wpointer-sign]
output = MVM_string_encode(tc, str, 0, -1, &output_size, handle->body.encoding_type);
^~~~~~~~~~~~
src/strings/ops.h:83:110: note: passing argument to parameter 'output_size' here
MVMuint8 * MVM_string_encode(MVMThreadContext *tc, MVMString *s, MVMint64 start, MVMint64 length, MVMuint64 *output_size, MVMint64 encoding_flag);
^
src/io/fileops.c:656:40: warning: passing 'MVMuint8 *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types
with different sign [-Wpointer-sign]
uv_buf_t buf = uv_buf_init(output, bytes_written = output_size);
^~~~~~
3rdparty/libuv/include/uv.h:576:38: note: passing argument to parameter 'base' here
UV_EXTERN uv_buf_t uv_buf_init(char* base, unsigned int len);
^
src/io/fileops.c:701:12: warning: assigning to 'MVMuint8 *' (aka 'unsigned char *') from 'MVMint8 *' (aka 'signed char *') converts between pointers to
integer types with different sign [-Wpointer-sign]
output = ((MVMArray *)buffer)->body.slots.i8;
^ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
src/io/fileops.c:707:40: warning: passing 'MVMuint8 *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types
with different sign [-Wpointer-sign]
uv_buf_t buf = uv_buf_init(output, bytes_written = output_size);
^~~~~~
3rdparty/libuv/include/uv.h:576:38: note: passing argument to parameter 'base' here
UV_EXTERN uv_buf_t uv_buf_init(char* base, unsigned int len);
^
src/io/fileops.c:988:47: warning: '&&' within '||' [-Wlogical-op-parentheses]
orig_cstr[1] == ':' && orig_cstr[2] == '\\';
~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~
src/io/fileops.c:988:47: note: place parentheses around the '&&' expression to silence this warning
orig_cstr[1] == ':' && orig_cstr[2] == '\\';
^
( )
5 warnings generated.
compiling src/io/socketops.o
src/io/socketops.c:52:47: warning: incompatible pointer types passing 'struct sockaddr_in *' to parameter of type 'const struct sockaddr *'
[-Wincompatible-pointer-types]
if ((r = uv_tcp_connect(&connect, socket, &dest, NULL)) < 0) {
^~~~~
3rdparty/libuv/include/uv.h:819:53: note: passing argument to parameter 'addr' here
const struct sockaddr* addr,
^
src/io/socketops.c:113:33: warning: incompatible pointer types passing 'struct sockaddr_in *' to parameter of type 'const struct sockaddr *'
[-Wincompatible-pointer-types]
uv_tcp_bind(server, &bind_addr, 0);
^~~~~~~~~~
3rdparty/libuv/include/uv.h:802:50: note: passing argument to parameter 'addr' here
const struct sockaddr* addr,
^
src/io/socketops.c:124:33: warning: incompatible pointer types passing 'struct sockaddr_in *' to parameter of type 'const struct sockaddr *'
[-Wincompatible-pointer-types]
uv_udp_bind(server, &bind_addr, 0);
^~~~~~~~~~
3rdparty/libuv/include/uv.h:931:50: note: passing argument to parameter 'addr' here
const struct sockaddr* addr,
^
src/io/socketops.c:188:59: warning: passing 'MVMint64 *' (aka 'long long *') to parameter of type 'MVMuint64 *' (aka 'unsigned long long *') converts
between pointers to integer types with different sign [-Wpointer-sign]
output = MVM_string_encode(tc, tosend, start, length, &output_size, handle->body.encoding_type);
^~~~~~~~~~~~
src/strings/ops.h:83:110: note: passing argument to parameter 'output_size' here
MVMuint8 * MVM_string_encode(MVMThreadContext *tc, MVMString *s, MVMint64 start, MVMint64 length, MVMuint64 *output_size, MVMint64 encoding_flag);
^
src/io/socketops.c:190:14: warning: assigning to 'char *' from 'MVMuint8 *' (aka 'unsigned char *') converts between pointers to integer types with
different sign [-Wpointer-sign]
buf.base = output;
^ ~~~~~~
src/io/socketops.c:270:5: warning: implicit declaration of function 'gethostname' is invalid in C99 [-Wimplicit-function-declaration]
gethostname(hostname, 65);
^
6 warnings generated.
compiling src/io/dirops.o
compiling src/io/procops.o
compiling src/gc/collect.o
compiling src/gc/gen2.o
compiling src/gc/wb.o
compiling src/6model/reprs.o
compiling src/6model/reprconv.o
compiling src/6model/containers.o
compiling src/6model/reprs/MVMString.o
compiling src/6model/reprs/MVMArray.o
compiling src/6model/reprs/MVMHash.o
compiling src/6model/reprs/MVMCFunction.o
compiling src/6model/reprs/KnowHOWREPR.o
compiling src/6model/reprs/KnowHOWAttributeREPR.o
compiling src/6model/reprs/P6str.o
compiling src/6model/reprs/P6opaque.o
compiling src/6model/reprs/MVMCode.o
compiling src/6model/reprs/MVMOSHandle.o
compiling src/6model/reprs/MVMCompUnit.o
compiling src/6model/reprs/MVMStaticFrame.o
compiling src/6model/reprs/P6int.o
compiling src/6model/reprs/P6num.o
compiling src/6model/reprs/Uninstantiable.o
compiling src/6model/reprs/HashAttrStore.o
compiling src/6model/reprs/MVMThread.o
compiling src/6model/reprs/MVMIter.o
compiling src/6model/reprs/MVMContext.o
compiling src/6model/reprs/SCRef.o
compiling src/6model/reprs/Lexotic.o
compiling src/6model/reprs/MVMCallCapture.o
compiling src/6model/reprs/P6bigint.o
src/6model/reprs/P6bigint.c:120:17: warning: initializing 'const char *' with an expression of type 'MVMuint8 *' (aka 'unsigned char *') converts
between pointers to integer types with different sign [-Wpointer-sign]
const char *buf = MVM_string_ascii_encode(tc, reader->read_str(tc, reader), &output_size);
^ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1 warning generated.
compiling src/6model/reprs/NFA.o
compiling src/6model/reprs/MVMException.o
compiling src/6model/reprs/MVMDLLSym.o
compiling src/6model/reprs/MVMMultiCache.o
compiling src/6model/reprs/MVMContinuation.o
compiling src/6model/6model.o
compiling src/6model/bootstrap.o
compiling src/6model/sc.o
compiling src/6model/serialization.o
compiling src/mast/compiler.o
compiling src/mast/driver.o
src/mast/driver.c:95:16: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
if (fh = fopen(c_filename, "wb+")) {
~~~^~~~~~~~~~~~~~~~~~~~~~~~~~
src/gc/roots.h:20:5: note: expanded from macro 'MVMROOT'
block \
^
src/mast/driver.c:95:16: note: place parentheses around the assignment to silence this warning
if (fh = fopen(c_filename, "wb+")) {
^
(
src/gc/roots.h:20:5: note: expanded from macro 'MVMROOT'
block \
^
src/mast/driver.c:95:16: note: use '==' to turn this assignment into an equality comparison
if (fh = fopen(c_filename, "wb+")) {
^
==
src/gc/roots.h:20:5: note: expanded from macro 'MVMROOT'
block \
^
1 warning generated.
compiling src/strings/ascii.o
compiling src/strings/utf8.o
src/strings/utf8.c:203:31: warning: comparison of constant 239 with expression of type 'const char' is always false
[-Wtautological-constant-out-of-range-compare]
if (bytes >= 3 && utf8[0] == 0xEF && utf8[1] == 0xBB && utf8[0xBF]) {
~~~~~~~ ^ ~~~~
src/strings/utf8.c:203:50: warning: comparison of constant 187 with expression of type 'const char' is always false
[-Wtautological-constant-out-of-range-compare]
if (bytes >= 3 && utf8[0] == 0xEF && utf8[1] == 0xBB && utf8[0xBF]) {
~~~~~~~ ^ ~~~~
2 warnings generated.
compiling src/strings/ops.o
src/strings/ops.c:396:33: warning: '/*' within block comment [-Wcomment]
/* result->body.codes = 0; /* Populate this lazily. */
^
src/strings/ops.c:745:62: warning: passing 'char *' to parameter of type 'MVMuint8 *' (aka 'unsigned char *') converts between pointers to integer types
with different sign [-Wpointer-sign]
return MVM_string_latin1_decode(tc, type_object, Cbuf, byte_length);
^~~~
src/strings/latin1.h:1:94: note: passing argument to parameter 'latin1' here
MVMString * MVM_string_latin1_decode(MVMThreadContext *tc, MVMObject *result_type, MVMuint8 *latin1, size_t bytes);
^
src/strings/ops.c:747:61: warning: passing 'char *' to parameter of type 'MVMuint8 *' (aka 'unsigned char *') converts between pointers to integer types
with different sign [-Wpointer-sign]
return MVM_string_utf16_decode(tc, type_object, Cbuf, byte_length);
^~~~
src/strings/utf16.h:1:93: note: passing argument to parameter 'utf16' here
MVMString * MVM_string_utf16_decode(MVMThreadContext *tc, MVMObject *result_type, MVMuint8 *utf16, size_t bytes);
^
src/strings/ops.c:839:9: warning: passing 'MVMint8 *' (aka 'signed char *') to parameter of type 'char *' converts between pointers to integer types
with different sign [-Wpointer-sign]
((MVMArray *)buf)->body.slots.i8 + ((MVMArray *)buf)->body.start,
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
src/strings/ops.c:735:39: note: passing argument to parameter 'Cbuf' here
MVMObject *type_object, char *Cbuf, MVMint64 byte_length, MVMint64 encoding_flag) {
^
src/strings/ops.c:1072:12: warning: implicit declaration of function 'MVM_unicode_codepoint_has_property_value' is invalid in C99
[-Wimplicit-function-declaration]
return MVM_unicode_codepoint_has_property_value(tc,
^
5 warnings generated.
generating src/strings/unicode.c
compiling src/strings/unicode.o
src/strings/unicode.c:34498:38: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("BasicLatin", bname, 10) == 0 || strncmp("basiclatin", bname, 10) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34498:79: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("BasicLatin", bname, 10) == 0 || strncmp("basiclatin", bname, 10) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34501:44: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Latin1Supplement", bname, 16) == 0 || strncmp("latin1supplement", bname, 16) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34501:91: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Latin1Supplement", bname, 16) == 0 || strncmp("latin1supplement", bname, 16) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34504:42: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("LatinExtendedA", bname, 14) == 0 || strncmp("latinextendeda", bname, 14) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34504:87: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("LatinExtendedA", bname, 14) == 0 || strncmp("latinextendeda", bname, 14) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34507:42: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("LatinExtendedB", bname, 14) == 0 || strncmp("latinextendedb", bname, 14) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34507:87: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("LatinExtendedB", bname, 14) == 0 || strncmp("latinextendedb", bname, 14) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34510:41: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("IPAExtensions", bname, 13) == 0 || strncmp("ipaextensions", bname, 13) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34510:85: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("IPAExtensions", bname, 13) == 0 || strncmp("ipaextensions", bname, 13) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34513:50: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("SpacingModifierLetters", bname, 22) == 0 || strncmp("spacingmodifierletters", bname, 22) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34513:103: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("SpacingModifierLetters", bname, 22) == 0 || strncmp("spacingmodifierletters", bname, 22) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34516:53: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("CombiningDiacriticalMarks", bname, 25) == 0 || strncmp("combiningdiacriticalmarks", bname, 25) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34516:109: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("CombiningDiacriticalMarks", bname, 25) == 0 || strncmp("combiningdiacriticalmarks", bname, 25) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34519:42: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("GreekandCoptic", bname, 14) == 0 || strncmp("greekandcoptic", bname, 14) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34519:87: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("GreekandCoptic", bname, 14) == 0 || strncmp("greekandcoptic", bname, 14) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34522:36: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Cyrillic", bname, 8) == 0 || strncmp("cyrillic", bname, 8) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34522:74: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Cyrillic", bname, 8) == 0 || strncmp("cyrillic", bname, 8) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34525:46: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("CyrillicSupplement", bname, 18) == 0 || strncmp("cyrillicsupplement", bname, 18) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34525:95: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("CyrillicSupplement", bname, 18) == 0 || strncmp("cyrillicsupplement", bname, 18) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34528:36: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Armenian", bname, 8) == 0 || strncmp("armenian", bname, 8) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34528:74: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Armenian", bname, 8) == 0 || strncmp("armenian", bname, 8) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34531:34: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Hebrew", bname, 6) == 0 || strncmp("hebrew", bname, 6) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34531:70: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Hebrew", bname, 6) == 0 || strncmp("hebrew", bname, 6) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34534:34: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Arabic", bname, 6) == 0 || strncmp("arabic", bname, 6) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34534:70: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Arabic", bname, 6) == 0 || strncmp("arabic", bname, 6) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34537:34: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Syriac", bname, 6) == 0 || strncmp("syriac", bname, 6) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34537:70: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Syriac", bname, 6) == 0 || strncmp("syriac", bname, 6) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34540:44: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("ArabicSupplement", bname, 16) == 0 || strncmp("arabicsupplement", bname, 16) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34540:91: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("ArabicSupplement", bname, 16) == 0 || strncmp("arabicsupplement", bname, 16) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34543:34: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Thaana", bname, 6) == 0 || strncmp("thaana", bname, 6) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34543:70: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Thaana", bname, 6) == 0 || strncmp("thaana", bname, 6) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34546:31: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("NKo", bname, 3) == 0 || strncmp("nko", bname, 3) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34546:64: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("NKo", bname, 3) == 0 || strncmp("nko", bname, 3) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34549:37: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Samaritan", bname, 9) == 0 || strncmp("samaritan", bname, 9) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34549:76: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Samaritan", bname, 9) == 0 || strncmp("samaritan", bname, 9) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34552:35: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Mandaic", bname, 7) == 0 || strncmp("mandaic", bname, 7) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34552:72: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Mandaic", bname, 7) == 0 || strncmp("mandaic", bname, 7) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34555:43: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("ArabicExtendedA", bname, 15) == 0 || strncmp("arabicextendeda", bname, 15) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34555:89: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("ArabicExtendedA", bname, 15) == 0 || strncmp("arabicextendeda", bname, 15) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34558:38: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Devanagari", bname, 10) == 0 || strncmp("devanagari", bname, 10) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34558:79: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Devanagari", bname, 10) == 0 || strncmp("devanagari", bname, 10) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34561:35: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Bengali", bname, 7) == 0 || strncmp("bengali", bname, 7) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34561:72: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Bengali", bname, 7) == 0 || strncmp("bengali", bname, 7) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34564:36: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Gurmukhi", bname, 8) == 0 || strncmp("gurmukhi", bname, 8) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34564:74: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Gurmukhi", bname, 8) == 0 || strncmp("gurmukhi", bname, 8) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34567:36: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Gujarati", bname, 8) == 0 || strncmp("gujarati", bname, 8) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34567:74: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Gujarati", bname, 8) == 0 || strncmp("gujarati", bname, 8) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34570:33: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Oriya", bname, 5) == 0 || strncmp("oriya", bname, 5) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34570:68: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Oriya", bname, 5) == 0 || strncmp("oriya", bname, 5) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34573:33: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Tamil", bname, 5) == 0 || strncmp("tamil", bname, 5) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34573:68: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Tamil", bname, 5) == 0 || strncmp("tamil", bname, 5) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34576:34: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Telugu", bname, 6) == 0 || strncmp("telugu", bname, 6) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34576:70: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Telugu", bname, 6) == 0 || strncmp("telugu", bname, 6) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34579:35: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Kannada", bname, 7) == 0 || strncmp("kannada", bname, 7) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34579:72: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Kannada", bname, 7) == 0 || strncmp("kannada", bname, 7) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34582:37: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Malayalam", bname, 9) == 0 || strncmp("malayalam", bname, 9) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34582:76: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Malayalam", bname, 9) == 0 || strncmp("malayalam", bname, 9) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34585:35: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Sinhala", bname, 7) == 0 || strncmp("sinhala", bname, 7) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34585:72: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Sinhala", bname, 7) == 0 || strncmp("sinhala", bname, 7) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34588:32: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Thai", bname, 4) == 0 || strncmp("thai", bname, 4) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34588:66: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Thai", bname, 4) == 0 || strncmp("thai", bname, 4) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34591:31: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Lao", bname, 3) == 0 || strncmp("lao", bname, 3) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34591:64: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Lao", bname, 3) == 0 || strncmp("lao", bname, 3) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34594:35: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Tibetan", bname, 7) == 0 || strncmp("tibetan", bname, 7) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34594:72: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Tibetan", bname, 7) == 0 || strncmp("tibetan", bname, 7) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34597:35: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Myanmar", bname, 7) == 0 || strncmp("myanmar", bname, 7) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34597:72: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Myanmar", bname, 7) == 0 || strncmp("myanmar", bname, 7) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34600:36: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Georgian", bname, 8) == 0 || strncmp("georgian", bname, 8) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34600:74: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Georgian", bname, 8) == 0 || strncmp("georgian", bname, 8) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34603:38: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("HangulJamo", bname, 10) == 0 || strncmp("hanguljamo", bname, 10) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34603:79: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("HangulJamo", bname, 10) == 0 || strncmp("hanguljamo", bname, 10) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34606:36: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Ethiopic", bname, 8) == 0 || strncmp("ethiopic", bname, 8) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34606:74: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Ethiopic", bname, 8) == 0 || strncmp("ethiopic", bname, 8) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34609:46: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("EthiopicSupplement", bname, 18) == 0 || strncmp("ethiopicsupplement", bname, 18) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34609:95: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("EthiopicSupplement", bname, 18) == 0 || strncmp("ethiopicsupplement", bname, 18) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34612:36: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Cherokee", bname, 8) == 0 || strncmp("cherokee", bname, 8) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34612:74: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Cherokee", bname, 8) == 0 || strncmp("cherokee", bname, 8) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34615:62: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("UnifiedCanadianAboriginalSyllabics", bname, 34) == 0 || strncmp("unifiedcanadianaboriginalsyllabics", bname, 34) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34615:127: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("UnifiedCanadianAboriginalSyllabics", bname, 34) == 0 || strncmp("unifiedcanadianaboriginalsyllabics", bname, 34) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34618:33: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Ogham", bname, 5) == 0 || strncmp("ogham", bname, 5) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34618:68: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Ogham", bname, 5) == 0 || strncmp("ogham", bname, 5) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34621:33: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Runic", bname, 5) == 0 || strncmp("runic", bname, 5) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34621:68: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Runic", bname, 5) == 0 || strncmp("runic", bname, 5) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34624:35: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Tagalog", bname, 7) == 0 || strncmp("tagalog", bname, 7) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34624:72: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Tagalog", bname, 7) == 0 || strncmp("tagalog", bname, 7) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34627:35: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Hanunoo", bname, 7) == 0 || strncmp("hanunoo", bname, 7) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34627:72: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Hanunoo", bname, 7) == 0 || strncmp("hanunoo", bname, 7) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34630:33: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Buhid", bname, 5) == 0 || strncmp("buhid", bname, 5) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34630:68: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Buhid", bname, 5) == 0 || strncmp("buhid", bname, 5) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34633:36: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Tagbanwa", bname, 8) == 0 || strncmp("tagbanwa", bname, 8) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34633:74: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Tagbanwa", bname, 8) == 0 || strncmp("tagbanwa", bname, 8) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34636:33: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Khmer", bname, 5) == 0 || strncmp("khmer", bname, 5) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34636:68: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Khmer", bname, 5) == 0 || strncmp("khmer", bname, 5) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34639:37: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Mongolian", bname, 9) == 0 || strncmp("mongolian", bname, 9) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34639:76: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Mongolian", bname, 9) == 0 || strncmp("mongolian", bname, 9) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34642:70: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("UnifiedCanadianAboriginalSyllabicsExtended", bname, 42) == 0 || strncmp("unifiedcanadianaboriginalsyllabicsextended", bn...
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34642:143: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
...strncmp("UnifiedCanadianAboriginalSyllabicsExtended", bname, 42) == 0 || strncmp("unifiedcanadianaboriginalsyllabicsextended", bname, 42) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34645:33: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Limbu", bname, 5) == 0 || strncmp("limbu", bname, 5) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34645:68: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Limbu", bname, 5) == 0 || strncmp("limbu", bname, 5) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34648:33: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("TaiLe", bname, 5) == 0 || strncmp("taile", bname, 5) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34648:68: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("TaiLe", bname, 5) == 0 || strncmp("taile", bname, 5) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34651:37: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("NewTaiLue", bname, 9) == 0 || strncmp("newtailue", bname, 9) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34651:76: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("NewTaiLue", bname, 9) == 0 || strncmp("newtailue", bname, 9) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34654:40: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("KhmerSymbols", bname, 12) == 0 || strncmp("khmersymbols", bname, 12) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34654:83: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("KhmerSymbols", bname, 12) == 0 || strncmp("khmersymbols", bname, 12) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34657:36: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Buginese", bname, 8) == 0 || strncmp("buginese", bname, 8) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34657:74: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Buginese", bname, 8) == 0 || strncmp("buginese", bname, 8) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34660:35: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("TaiTham", bname, 7) == 0 || strncmp("taitham", bname, 7) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34660:72: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("TaiTham", bname, 7) == 0 || strncmp("taitham", bname, 7) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34663:36: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Balinese", bname, 8) == 0 || strncmp("balinese", bname, 8) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34663:74: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Balinese", bname, 8) == 0 || strncmp("balinese", bname, 8) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34666:37: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Sundanese", bname, 9) == 0 || strncmp("sundanese", bname, 9) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34666:76: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Sundanese", bname, 9) == 0 || strncmp("sundanese", bname, 9) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34669:33: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Batak", bname, 5) == 0 || strncmp("batak", bname, 5) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34669:68: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Batak", bname, 5) == 0 || strncmp("batak", bname, 5) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34672:34: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Lepcha", bname, 6) == 0 || strncmp("lepcha", bname, 6) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34672:70: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Lepcha", bname, 6) == 0 || strncmp("lepcha", bname, 6) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34675:35: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("OlChiki", bname, 7) == 0 || strncmp("olchiki", bname, 7) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34675:72: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("OlChiki", bname, 7) == 0 || strncmp("olchiki", bname, 7) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34678:47: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("SundaneseSupplement", bname, 19) == 0 || strncmp("sundanesesupplement", bname, 19) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34678:97: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("SundaneseSupplement", bname, 19) == 0 || strncmp("sundanesesupplement", bname, 19) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34681:43: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("VedicExtensions", bname, 15) == 0 || strncmp("vedicextensions", bname, 15) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34681:89: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("VedicExtensions", bname, 15) == 0 || strncmp("vedicextensions", bname, 15) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34684:46: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("PhoneticExtensions", bname, 18) == 0 || strncmp("phoneticextensions", bname, 18) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34684:95: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("PhoneticExtensions", bname, 18) == 0 || strncmp("phoneticextensions", bname, 18) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34687:56: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("PhoneticExtensionsSupplement", bname, 28) == 0 || strncmp("phoneticextensionssupplement", bname, 28) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34687:115: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("PhoneticExtensionsSupplement", bname, 28) == 0 || strncmp("phoneticextensionssupplement", bname, 28) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34690:63: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("CombiningDiacriticalMarksSupplement", bname, 35) == 0 || strncmp("combiningdiacriticalmarkssupplement", bname, 35) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34690:129: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("CombiningDiacriticalMarksSupplement", bname, 35) == 0 || strncmp("combiningdiacriticalmarkssupplement", bname, 35) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34693:51: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("LatinExtendedAdditional", bname, 23) == 0 || strncmp("latinextendedadditional", bname, 23) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34693:105: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("LatinExtendedAdditional", bname, 23) == 0 || strncmp("latinextendedadditional", bname, 23) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34696:41: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("GreekExtended", bname, 13) == 0 || strncmp("greekextended", bname, 13) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34696:85: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("GreekExtended", bname, 13) == 0 || strncmp("greekextended", bname, 13) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34699:46: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("GeneralPunctuation", bname, 18) == 0 || strncmp("generalpunctuation", bname, 18) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34699:95: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("GeneralPunctuation", bname, 18) == 0 || strncmp("generalpunctuation", bname, 18) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34702:53: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("SuperscriptsandSubscripts", bname, 25) == 0 || strncmp("superscriptsandsubscripts", bname, 25) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34702:109: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("SuperscriptsandSubscripts", bname, 25) == 0 || strncmp("superscriptsandsubscripts", bname, 25) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34705:43: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("CurrencySymbols", bname, 15) == 0 || strncmp("currencysymbols", bname, 15) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34705:89: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("CurrencySymbols", bname, 15) == 0 || strncmp("currencysymbols", bname, 15) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34708:63: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("CombiningDiacriticalMarksforSymbols", bname, 35) == 0 || strncmp("combiningdiacriticalmarksforsymbols", bname, 35) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34708:129: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("CombiningDiacriticalMarksforSymbols", bname, 35) == 0 || strncmp("combiningdiacriticalmarksforsymbols", bname, 35) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34711:45: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("LetterlikeSymbols", bname, 17) == 0 || strncmp("letterlikesymbols", bname, 17) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34711:93: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("LetterlikeSymbols", bname, 17) == 0 || strncmp("letterlikesymbols", bname, 17) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34714:39: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("NumberForms", bname, 11) == 0 || strncmp("numberforms", bname, 11) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34714:81: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("NumberForms", bname, 11) == 0 || strncmp("numberforms", bname, 11) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34717:34: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Arrows", bname, 6) == 0 || strncmp("arrows", bname, 6) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34717:70: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Arrows", bname, 6) == 0 || strncmp("arrows", bname, 6) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34720:49: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("MathematicalOperators", bname, 21) == 0 || strncmp("mathematicaloperators", bname, 21) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34720:101: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("MathematicalOperators", bname, 21) == 0 || strncmp("mathematicaloperators", bname, 21) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34723:50: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("MiscellaneousTechnical", bname, 22) == 0 || strncmp("miscellaneoustechnical", bname, 22) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34723:103: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("MiscellaneousTechnical", bname, 22) == 0 || strncmp("miscellaneoustechnical", bname, 22) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34726:43: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("ControlPictures", bname, 15) == 0 || strncmp("controlpictures", bname, 15) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34726:89: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("ControlPictures", bname, 15) == 0 || strncmp("controlpictures", bname, 15) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34729:55: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("OpticalCharacterRecognition", bname, 27) == 0 || strncmp("opticalcharacterrecognition", bname, 27) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34729:113: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("OpticalCharacterRecognition", bname, 27) == 0 || strncmp("opticalcharacterrecognition", bname, 27) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34732:49: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("EnclosedAlphanumerics", bname, 21) == 0 || strncmp("enclosedalphanumerics", bname, 21) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34732:101: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("EnclosedAlphanumerics", bname, 21) == 0 || strncmp("enclosedalphanumerics", bname, 21) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34735:38: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("BoxDrawing", bname, 10) == 0 || strncmp("boxdrawing", bname, 10) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34735:79: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("BoxDrawing", bname, 10) == 0 || strncmp("boxdrawing", bname, 10) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34738:41: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("BlockElements", bname, 13) == 0 || strncmp("blockelements", bname, 13) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34738:85: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("BlockElements", bname, 13) == 0 || strncmp("blockelements", bname, 13) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34741:43: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("GeometricShapes", bname, 15) == 0 || strncmp("geometricshapes", bname, 15) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34741:89: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("GeometricShapes", bname, 15) == 0 || strncmp("geometricshapes", bname, 15) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34744:48: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("MiscellaneousSymbols", bname, 20) == 0 || strncmp("miscellaneoussymbols", bname, 20) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34744:99: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("MiscellaneousSymbols", bname, 20) == 0 || strncmp("miscellaneoussymbols", bname, 20) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34747:36: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Dingbats", bname, 8) == 0 || strncmp("dingbats", bname, 8) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34747:74: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Dingbats", bname, 8) == 0 || strncmp("dingbats", bname, 8) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34750:61: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("MiscellaneousMathematicalSymbolsA", bname, 33) == 0 || strncmp("miscellaneousmathematicalsymbolsa", bname, 33) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34750:125: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("MiscellaneousMathematicalSymbolsA", bname, 33) == 0 || strncmp("miscellaneousmathematicalsymbolsa", bname, 33) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34753:47: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("SupplementalArrowsA", bname, 19) == 0 || strncmp("supplementalarrowsa", bname, 19) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34753:97: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("SupplementalArrowsA", bname, 19) == 0 || strncmp("supplementalarrowsa", bname, 19) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34756:43: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("BraillePatterns", bname, 15) == 0 || strncmp("braillepatterns", bname, 15) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34756:89: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("BraillePatterns", bname, 15) == 0 || strncmp("braillepatterns", bname, 15) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34759:47: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("SupplementalArrowsB", bname, 19) == 0 || strncmp("supplementalarrowsb", bname, 19) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34759:97: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("SupplementalArrowsB", bname, 19) == 0 || strncmp("supplementalarrowsb", bname, 19) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34762:61: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("MiscellaneousMathematicalSymbolsB", bname, 33) == 0 || strncmp("miscellaneousmathematicalsymbolsb", bname, 33) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34762:125: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("MiscellaneousMathematicalSymbolsB", bname, 33) == 0 || strncmp("miscellaneousmathematicalsymbolsb", bname, 33) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34765:61: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("SupplementalMathematicalOperators", bname, 33) == 0 || strncmp("supplementalmathematicaloperators", bname, 33) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34765:125: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("SupplementalMathematicalOperators", bname, 33) == 0 || strncmp("supplementalmathematicaloperators", bname, 33) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34768:57: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("MiscellaneousSymbolsandArrows", bname, 29) == 0 || strncmp("miscellaneoussymbolsandarrows", bname, 29) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34768:117: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("MiscellaneousSymbolsandArrows", bname, 29) == 0 || strncmp("miscellaneoussymbolsandarrows", bname, 29) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34771:38: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Glagolitic", bname, 10) == 0 || strncmp("glagolitic", bname, 10) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34771:79: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Glagolitic", bname, 10) == 0 || strncmp("glagolitic", bname, 10) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34774:42: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("LatinExtendedC", bname, 14) == 0 || strncmp("latinextendedc", bname, 14) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34774:87: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("LatinExtendedC", bname, 14) == 0 || strncmp("latinextendedc", bname, 14) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34777:34: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Coptic", bname, 6) == 0 || strncmp("coptic", bname, 6) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34777:70: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Coptic", bname, 6) == 0 || strncmp("coptic", bname, 6) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34780:46: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("GeorgianSupplement", bname, 18) == 0 || strncmp("georgiansupplement", bname, 18) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34780:95: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("GeorgianSupplement", bname, 18) == 0 || strncmp("georgiansupplement", bname, 18) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34783:36: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Tifinagh", bname, 8) == 0 || strncmp("tifinagh", bname, 8) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34783:74: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Tifinagh", bname, 8) == 0 || strncmp("tifinagh", bname, 8) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34786:44: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("EthiopicExtended", bname, 16) == 0 || strncmp("ethiopicextended", bname, 16) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34786:91: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("EthiopicExtended", bname, 16) == 0 || strncmp("ethiopicextended", bname, 16) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34789:45: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("CyrillicExtendedA", bname, 17) == 0 || strncmp("cyrillicextendeda", bname, 17) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34789:93: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("CyrillicExtendedA", bname, 17) == 0 || strncmp("cyrillicextendeda", bname, 17) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34792:51: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("SupplementalPunctuation", bname, 23) == 0 || strncmp("supplementalpunctuation", bname, 23) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34792:105: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("SupplementalPunctuation", bname, 23) == 0 || strncmp("supplementalpunctuation", bname, 23) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34795:49: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("CJKRadicalsSupplement", bname, 21) == 0 || strncmp("cjkradicalssupplement", bname, 21) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34795:101: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("CJKRadicalsSupplement", bname, 21) == 0 || strncmp("cjkradicalssupplement", bname, 21) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34798:42: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("KangxiRadicals", bname, 14) == 0 || strncmp("kangxiradicals", bname, 14) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34798:87: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("KangxiRadicals", bname, 14) == 0 || strncmp("kangxiradicals", bname, 14) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34801:60: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("IdeographicDescriptionCharacters", bname, 32) == 0 || strncmp("ideographicdescriptioncharacters", bname, 32) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34801:123: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("IdeographicDescriptionCharacters", bname, 32) == 0 || strncmp("ideographicdescriptioncharacters", bname, 32) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34804:52: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("CJKSymbolsandPunctuation", bname, 24) == 0 || strncmp("cjksymbolsandpunctuation", bname, 24) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34804:107: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("CJKSymbolsandPunctuation", bname, 24) == 0 || strncmp("cjksymbolsandpunctuation", bname, 24) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34807:36: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Hiragana", bname, 8) == 0 || strncmp("hiragana", bname, 8) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34807:74: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Hiragana", bname, 8) == 0 || strncmp("hiragana", bname, 8) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34810:36: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Katakana", bname, 8) == 0 || strncmp("katakana", bname, 8) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34810:74: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Katakana", bname, 8) == 0 || strncmp("katakana", bname, 8) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34813:36: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Bopomofo", bname, 8) == 0 || strncmp("bopomofo", bname, 8) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34813:74: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Bopomofo", bname, 8) == 0 || strncmp("bopomofo", bname, 8) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34816:51: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("HangulCompatibilityJamo", bname, 23) == 0 || strncmp("hangulcompatibilityjamo", bname, 23) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34816:105: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("HangulCompatibilityJamo", bname, 23) == 0 || strncmp("hangulcompatibilityjamo", bname, 23) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34819:34: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Kanbun", bname, 6) == 0 || strncmp("kanbun", bname, 6) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34819:70: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Kanbun", bname, 6) == 0 || strncmp("kanbun", bname, 6) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34822:44: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("BopomofoExtended", bname, 16) == 0 || strncmp("bopomofoextended", bname, 16) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34822:91: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("BopomofoExtended", bname, 16) == 0 || strncmp("bopomofoextended", bname, 16) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34825:38: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("CJKStrokes", bname, 10) == 0 || strncmp("cjkstrokes", bname, 10) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34825:79: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("CJKStrokes", bname, 10) == 0 || strncmp("cjkstrokes", bname, 10) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34828:54: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("KatakanaPhoneticExtensions", bname, 26) == 0 || strncmp("katakanaphoneticextensions", bname, 26) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34828:111: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("KatakanaPhoneticExtensions", bname, 26) == 0 || strncmp("katakanaphoneticextensions", bname, 26) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34831:55: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("EnclosedCJKLettersandMonths", bname, 27) == 0 || strncmp("enclosedcjklettersandmonths", bname, 27) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34831:113: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("EnclosedCJKLettersandMonths", bname, 27) == 0 || strncmp("enclosedcjklettersandmonths", bname, 27) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34834:44: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("CJKCompatibility", bname, 16) == 0 || strncmp("cjkcompatibility", bname, 16) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34834:91: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("CJKCompatibility", bname, 16) == 0 || strncmp("cjkcompatibility", bname, 16) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34837:58: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("CJKUnifiedIdeographsExtensionA", bname, 30) == 0 || strncmp("cjkunifiedideographsextensiona", bname, 30) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34837:119: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("CJKUnifiedIdeographsExtensionA", bname, 30) == 0 || strncmp("cjkunifiedideographsextensiona", bname, 30) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34840:49: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("YijingHexagramSymbols", bname, 21) == 0 || strncmp("yijinghexagramsymbols", bname, 21) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34840:101: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("YijingHexagramSymbols", bname, 21) == 0 || strncmp("yijinghexagramsymbols", bname, 21) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34843:48: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("CJKUnifiedIdeographs", bname, 20) == 0 || strncmp("cjkunifiedideographs", bname, 20) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34843:99: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("CJKUnifiedIdeographs", bname, 20) == 0 || strncmp("cjkunifiedideographs", bname, 20) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34846:39: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("YiSyllables", bname, 11) == 0 || strncmp("yisyllables", bname, 11) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34846:81: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("YiSyllables", bname, 11) == 0 || strncmp("yisyllables", bname, 11) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34849:38: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("YiRadicals", bname, 10) == 0 || strncmp("yiradicals", bname, 10) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34849:79: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("YiRadicals", bname, 10) == 0 || strncmp("yiradicals", bname, 10) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34852:32: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Lisu", bname, 4) == 0 || strncmp("lisu", bname, 4) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34852:66: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Lisu", bname, 4) == 0 || strncmp("lisu", bname, 4) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34855:31: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Vai", bname, 3) == 0 || strncmp("vai", bname, 3) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34855:64: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Vai", bname, 3) == 0 || strncmp("vai", bname, 3) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34858:45: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("CyrillicExtendedB", bname, 17) == 0 || strncmp("cyrillicextendedb", bname, 17) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34858:93: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("CyrillicExtendedB", bname, 17) == 0 || strncmp("cyrillicextendedb", bname, 17) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34861:33: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Bamum", bname, 5) == 0 || strncmp("bamum", bname, 5) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34861:68: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Bamum", bname, 5) == 0 || strncmp("bamum", bname, 5) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34864:47: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("ModifierToneLetters", bname, 19) == 0 || strncmp("modifiertoneletters", bname, 19) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34864:97: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("ModifierToneLetters", bname, 19) == 0 || strncmp("modifiertoneletters", bname, 19) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34867:42: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("LatinExtendedD", bname, 14) == 0 || strncmp("latinextendedd", bname, 14) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34867:87: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("LatinExtendedD", bname, 14) == 0 || strncmp("latinextendedd", bname, 14) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34870:39: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("SylotiNagri", bname, 11) == 0 || strncmp("sylotinagri", bname, 11) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34870:81: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("SylotiNagri", bname, 11) == 0 || strncmp("sylotinagri", bname, 11) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34873:50: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("CommonIndicNumberForms", bname, 22) == 0 || strncmp("commonindicnumberforms", bname, 22) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34873:103: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("CommonIndicNumberForms", bname, 22) == 0 || strncmp("commonindicnumberforms", bname, 22) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34876:35: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Phagspa", bname, 7) == 0 || strncmp("phagspa", bname, 7) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34876:72: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Phagspa", bname, 7) == 0 || strncmp("phagspa", bname, 7) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34879:38: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Saurashtra", bname, 10) == 0 || strncmp("saurashtra", bname, 10) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34879:79: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Saurashtra", bname, 10) == 0 || strncmp("saurashtra", bname, 10) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34882:46: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("DevanagariExtended", bname, 18) == 0 || strncmp("devanagariextended", bname, 18) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34882:95: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("DevanagariExtended", bname, 18) == 0 || strncmp("devanagariextended", bname, 18) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34885:35: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("KayahLi", bname, 7) == 0 || strncmp("kayahli", bname, 7) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34885:72: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("KayahLi", bname, 7) == 0 || strncmp("kayahli", bname, 7) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34888:34: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Rejang", bname, 6) == 0 || strncmp("rejang", bname, 6) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34888:70: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Rejang", bname, 6) == 0 || strncmp("rejang", bname, 6) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34891:47: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("HangulJamoExtendedA", bname, 19) == 0 || strncmp("hanguljamoextendeda", bname, 19) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34891:97: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("HangulJamoExtendedA", bname, 19) == 0 || strncmp("hanguljamoextendeda", bname, 19) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34894:36: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Javanese", bname, 8) == 0 || strncmp("javanese", bname, 8) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34894:74: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Javanese", bname, 8) == 0 || strncmp("javanese", bname, 8) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34897:32: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Cham", bname, 4) == 0 || strncmp("cham", bname, 4) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34897:66: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Cham", bname, 4) == 0 || strncmp("cham", bname, 4) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34900:44: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("MyanmarExtendedA", bname, 16) == 0 || strncmp("myanmarextendeda", bname, 16) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34900:91: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("MyanmarExtendedA", bname, 16) == 0 || strncmp("myanmarextendeda", bname, 16) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34903:35: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("TaiViet", bname, 7) == 0 || strncmp("taiviet", bname, 7) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34903:72: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("TaiViet", bname, 7) == 0 || strncmp("taiviet", bname, 7) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34906:49: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("MeeteiMayekExtensions", bname, 21) == 0 || strncmp("meeteimayekextensions", bname, 21) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34906:101: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("MeeteiMayekExtensions", bname, 21) == 0 || strncmp("meeteimayekextensions", bname, 21) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34909:45: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("EthiopicExtendedA", bname, 17) == 0 || strncmp("ethiopicextendeda", bname, 17) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34909:93: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("EthiopicExtendedA", bname, 17) == 0 || strncmp("ethiopicextendeda", bname, 17) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34912:39: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("MeeteiMayek", bname, 11) == 0 || strncmp("meeteimayek", bname, 11) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34912:81: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("MeeteiMayek", bname, 11) == 0 || strncmp("meeteimayek", bname, 11) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34915:43: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("HangulSyllables", bname, 15) == 0 || strncmp("hangulsyllables", bname, 15) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34915:89: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("HangulSyllables", bname, 15) == 0 || strncmp("hangulsyllables", bname, 15) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34918:47: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("HangulJamoExtendedB", bname, 19) == 0 || strncmp("hanguljamoextendedb", bname, 19) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34918:97: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("HangulJamoExtendedB", bname, 19) == 0 || strncmp("hanguljamoextendedb", bname, 19) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34921:42: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("HighSurrogates", bname, 14) == 0 || strncmp("highsurrogates", bname, 14) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34921:87: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("HighSurrogates", bname, 14) == 0 || strncmp("highsurrogates", bname, 14) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34924:52: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("HighPrivateUseSurrogates", bname, 24) == 0 || strncmp("highprivateusesurrogates", bname, 24) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34924:107: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("HighPrivateUseSurrogates", bname, 24) == 0 || strncmp("highprivateusesurrogates", bname, 24) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34927:41: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("LowSurrogates", bname, 13) == 0 || strncmp("lowsurrogates", bname, 13) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34927:85: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("LowSurrogates", bname, 13) == 0 || strncmp("lowsurrogates", bname, 13) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34930:42: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("PrivateUseArea", bname, 14) == 0 || strncmp("privateusearea", bname, 14) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34930:87: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("PrivateUseArea", bname, 14) == 0 || strncmp("privateusearea", bname, 14) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34933:54: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("CJKCompatibilityIdeographs", bname, 26) == 0 || strncmp("cjkcompatibilityideographs", bname, 26) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34933:111: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("CJKCompatibilityIdeographs", bname, 26) == 0 || strncmp("cjkcompatibilityideographs", bname, 26) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34936:55: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("AlphabeticPresentationForms", bname, 27) == 0 || strncmp("alphabeticpresentationforms", bname, 27) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34936:113: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("AlphabeticPresentationForms", bname, 27) == 0 || strncmp("alphabeticpresentationforms", bname, 27) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34939:52: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("ArabicPresentationFormsA", bname, 24) == 0 || strncmp("arabicpresentationformsa", bname, 24) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34939:107: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("ArabicPresentationFormsA", bname, 24) == 0 || strncmp("arabicpresentationformsa", bname, 24) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34942:46: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("VariationSelectors", bname, 18) == 0 || strncmp("variationselectors", bname, 18) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34942:95: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("VariationSelectors", bname, 18) == 0 || strncmp("variationselectors", bname, 18) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34945:41: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("VerticalForms", bname, 13) == 0 || strncmp("verticalforms", bname, 13) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34945:85: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("VerticalForms", bname, 13) == 0 || strncmp("verticalforms", bname, 13) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34948:46: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("CombiningHalfMarks", bname, 18) == 0 || strncmp("combininghalfmarks", bname, 18) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34948:95: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("CombiningHalfMarks", bname, 18) == 0 || strncmp("combininghalfmarks", bname, 18) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34951:49: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("CJKCompatibilityForms", bname, 21) == 0 || strncmp("cjkcompatibilityforms", bname, 21) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34951:101: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("CJKCompatibilityForms", bname, 21) == 0 || strncmp("cjkcompatibilityforms", bname, 21) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34954:45: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("SmallFormVariants", bname, 17) == 0 || strncmp("smallformvariants", bname, 17) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34954:93: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("SmallFormVariants", bname, 17) == 0 || strncmp("smallformvariants", bname, 17) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34957:52: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("ArabicPresentationFormsB", bname, 24) == 0 || strncmp("arabicpresentationformsb", bname, 24) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34957:107: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("ArabicPresentationFormsB", bname, 24) == 0 || strncmp("arabicpresentationformsb", bname, 24) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34960:54: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("HalfwidthandFullwidthForms", bname, 26) == 0 || strncmp("halfwidthandfullwidthforms", bname, 26) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34960:111: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("HalfwidthandFullwidthForms", bname, 26) == 0 || strncmp("halfwidthandfullwidthforms", bname, 26) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34963:36: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Specials", bname, 8) == 0 || strncmp("specials", bname, 8) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34963:74: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Specials", bname, 8) == 0 || strncmp("specials", bname, 8) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34966:44: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("LinearBSyllabary", bname, 16) == 0 || strncmp("linearbsyllabary", bname, 16) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34966:91: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("LinearBSyllabary", bname, 16) == 0 || strncmp("linearbsyllabary", bname, 16) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34969:44: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("LinearBIdeograms", bname, 16) == 0 || strncmp("linearbideograms", bname, 16) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34969:91: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("LinearBIdeograms", bname, 16) == 0 || strncmp("linearbideograms", bname, 16) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34972:41: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("AegeanNumbers", bname, 13) == 0 || strncmp("aegeannumbers", bname, 13) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34972:85: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("AegeanNumbers", bname, 13) == 0 || strncmp("aegeannumbers", bname, 13) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34975:47: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("AncientGreekNumbers", bname, 19) == 0 || strncmp("ancientgreeknumbers", bname, 19) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34975:97: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("AncientGreekNumbers", bname, 19) == 0 || strncmp("ancientgreeknumbers", bname, 19) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34978:42: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("AncientSymbols", bname, 14) == 0 || strncmp("ancientsymbols", bname, 14) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34978:87: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("AncientSymbols", bname, 14) == 0 || strncmp("ancientsymbols", bname, 14) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34981:40: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("PhaistosDisc", bname, 12) == 0 || strncmp("phaistosdisc", bname, 12) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34981:83: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("PhaistosDisc", bname, 12) == 0 || strncmp("phaistosdisc", bname, 12) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34984:34: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Lycian", bname, 6) == 0 || strncmp("lycian", bname, 6) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34984:70: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Lycian", bname, 6) == 0 || strncmp("lycian", bname, 6) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34987:34: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Carian", bname, 6) == 0 || strncmp("carian", bname, 6) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34987:70: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Carian", bname, 6) == 0 || strncmp("carian", bname, 6) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34990:37: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("OldItalic", bname, 9) == 0 || strncmp("olditalic", bname, 9) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34990:76: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("OldItalic", bname, 9) == 0 || strncmp("olditalic", bname, 9) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34993:34: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Gothic", bname, 6) == 0 || strncmp("gothic", bname, 6) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34993:70: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Gothic", bname, 6) == 0 || strncmp("gothic", bname, 6) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34996:36: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Ugaritic", bname, 8) == 0 || strncmp("ugaritic", bname, 8) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34996:74: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Ugaritic", bname, 8) == 0 || strncmp("ugaritic", bname, 8) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34999:38: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("OldPersian", bname, 10) == 0 || strncmp("oldpersian", bname, 10) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:34999:79: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("OldPersian", bname, 10) == 0 || strncmp("oldpersian", bname, 10) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35002:35: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Deseret", bname, 7) == 0 || strncmp("deseret", bname, 7) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35002:72: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Deseret", bname, 7) == 0 || strncmp("deseret", bname, 7) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35005:35: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Shavian", bname, 7) == 0 || strncmp("shavian", bname, 7) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35005:72: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Shavian", bname, 7) == 0 || strncmp("shavian", bname, 7) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35008:35: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Osmanya", bname, 7) == 0 || strncmp("osmanya", bname, 7) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35008:72: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Osmanya", bname, 7) == 0 || strncmp("osmanya", bname, 7) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35011:44: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("CypriotSyllabary", bname, 16) == 0 || strncmp("cypriotsyllabary", bname, 16) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35011:91: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("CypriotSyllabary", bname, 16) == 0 || strncmp("cypriotsyllabary", bname, 16) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35014:43: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("ImperialAramaic", bname, 15) == 0 || strncmp("imperialaramaic", bname, 15) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35014:89: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("ImperialAramaic", bname, 15) == 0 || strncmp("imperialaramaic", bname, 15) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35017:38: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Phoenician", bname, 10) == 0 || strncmp("phoenician", bname, 10) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35017:79: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Phoenician", bname, 10) == 0 || strncmp("phoenician", bname, 10) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35020:34: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Lydian", bname, 6) == 0 || strncmp("lydian", bname, 6) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35020:70: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Lydian", bname, 6) == 0 || strncmp("lydian", bname, 6) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35023:47: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("MeroiticHieroglyphs", bname, 19) == 0 || strncmp("meroitichieroglyphs", bname, 19) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35023:97: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("MeroiticHieroglyphs", bname, 19) == 0 || strncmp("meroitichieroglyphs", bname, 19) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35026:43: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("MeroiticCursive", bname, 15) == 0 || strncmp("meroiticcursive", bname, 15) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35026:89: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("MeroiticCursive", bname, 15) == 0 || strncmp("meroiticcursive", bname, 15) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35029:38: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Kharoshthi", bname, 10) == 0 || strncmp("kharoshthi", bname, 10) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35029:79: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Kharoshthi", bname, 10) == 0 || strncmp("kharoshthi", bname, 10) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35032:43: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("OldSouthArabian", bname, 15) == 0 || strncmp("oldsoutharabian", bname, 15) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35032:89: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("OldSouthArabian", bname, 15) == 0 || strncmp("oldsoutharabian", bname, 15) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35035:35: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Avestan", bname, 7) == 0 || strncmp("avestan", bname, 7) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35035:72: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Avestan", bname, 7) == 0 || strncmp("avestan", bname, 7) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35038:49: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("InscriptionalParthian", bname, 21) == 0 || strncmp("inscriptionalparthian", bname, 21) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35038:101: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("InscriptionalParthian", bname, 21) == 0 || strncmp("inscriptionalparthian", bname, 21) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35041:48: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("InscriptionalPahlavi", bname, 20) == 0 || strncmp("inscriptionalpahlavi", bname, 20) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35041:99: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("InscriptionalPahlavi", bname, 20) == 0 || strncmp("inscriptionalpahlavi", bname, 20) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35044:37: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("OldTurkic", bname, 9) == 0 || strncmp("oldturkic", bname, 9) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35044:76: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("OldTurkic", bname, 9) == 0 || strncmp("oldturkic", bname, 9) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35047:46: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("RumiNumeralSymbols", bname, 18) == 0 || strncmp("ruminumeralsymbols", bname, 18) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35047:95: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("RumiNumeralSymbols", bname, 18) == 0 || strncmp("ruminumeralsymbols", bname, 18) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35050:34: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Brahmi", bname, 6) == 0 || strncmp("brahmi", bname, 6) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35050:70: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Brahmi", bname, 6) == 0 || strncmp("brahmi", bname, 6) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35053:34: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Kaithi", bname, 6) == 0 || strncmp("kaithi", bname, 6) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35053:70: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Kaithi", bname, 6) == 0 || strncmp("kaithi", bname, 6) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35056:39: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("SoraSompeng", bname, 11) == 0 || strncmp("sorasompeng", bname, 11) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35056:81: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("SoraSompeng", bname, 11) == 0 || strncmp("sorasompeng", bname, 11) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35059:34: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Chakma", bname, 6) == 0 || strncmp("chakma", bname, 6) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35059:70: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Chakma", bname, 6) == 0 || strncmp("chakma", bname, 6) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35062:35: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Sharada", bname, 7) == 0 || strncmp("sharada", bname, 7) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35062:72: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Sharada", bname, 7) == 0 || strncmp("sharada", bname, 7) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35065:33: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Takri", bname, 5) == 0 || strncmp("takri", bname, 5) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35065:68: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Takri", bname, 5) == 0 || strncmp("takri", bname, 5) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35068:37: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Cuneiform", bname, 9) == 0 || strncmp("cuneiform", bname, 9) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35068:76: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Cuneiform", bname, 9) == 0 || strncmp("cuneiform", bname, 9) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35071:58: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("CuneiformNumbersandPunctuation", bname, 30) == 0 || strncmp("cuneiformnumbersandpunctuation", bname, 30) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35071:119: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("CuneiformNumbersandPunctuation", bname, 30) == 0 || strncmp("cuneiformnumbersandpunctuation", bname, 30) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35074:47: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("EgyptianHieroglyphs", bname, 19) == 0 || strncmp("egyptianhieroglyphs", bname, 19) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35074:97: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("EgyptianHieroglyphs", bname, 19) == 0 || strncmp("egyptianhieroglyphs", bname, 19) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35077:43: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("BamumSupplement", bname, 15) == 0 || strncmp("bamumsupplement", bname, 15) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35077:89: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("BamumSupplement", bname, 15) == 0 || strncmp("bamumsupplement", bname, 15) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35080:32: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Miao", bname, 4) == 0 || strncmp("miao", bname, 4) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35080:66: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Miao", bname, 4) == 0 || strncmp("miao", bname, 4) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35083:42: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("KanaSupplement", bname, 14) == 0 || strncmp("kanasupplement", bname, 14) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35083:87: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("KanaSupplement", bname, 14) == 0 || strncmp("kanasupplement", bname, 14) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35086:51: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("ByzantineMusicalSymbols", bname, 23) == 0 || strncmp("byzantinemusicalsymbols", bname, 23) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35086:105: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("ByzantineMusicalSymbols", bname, 23) == 0 || strncmp("byzantinemusicalsymbols", bname, 23) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35089:42: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("MusicalSymbols", bname, 14) == 0 || strncmp("musicalsymbols", bname, 14) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35089:87: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("MusicalSymbols", bname, 14) == 0 || strncmp("musicalsymbols", bname, 14) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35092:55: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("AncientGreekMusicalNotation", bname, 27) == 0 || strncmp("ancientgreekmusicalnotation", bname, 27) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35092:113: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("AncientGreekMusicalNotation", bname, 27) == 0 || strncmp("ancientgreekmusicalnotation", bname, 27) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35095:46: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("TaiXuanJingSymbols", bname, 18) == 0 || strncmp("taixuanjingsymbols", bname, 18) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35095:95: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("TaiXuanJingSymbols", bname, 18) == 0 || strncmp("taixuanjingsymbols", bname, 18) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35098:47: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("CountingRodNumerals", bname, 19) == 0 || strncmp("countingrodnumerals", bname, 19) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35098:97: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("CountingRodNumerals", bname, 19) == 0 || strncmp("countingrodnumerals", bname, 19) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35101:59: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("MathematicalAlphanumericSymbols", bname, 31) == 0 || strncmp("mathematicalalphanumericsymbols", bname, 31) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35101:121: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("MathematicalAlphanumericSymbols", bname, 31) == 0 || strncmp("mathematicalalphanumericsymbols", bname, 31) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35104:63: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("ArabicMathematicalAlphabeticSymbols", bname, 35) == 0 || strncmp("arabicmathematicalalphabeticsymbols", bname, 35) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35104:129: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("ArabicMathematicalAlphabeticSymbols", bname, 35) == 0 || strncmp("arabicmathematicalalphabeticsymbols", bname, 35) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35107:40: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("MahjongTiles", bname, 12) == 0 || strncmp("mahjongtiles", bname, 12) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35107:83: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("MahjongTiles", bname, 12) == 0 || strncmp("mahjongtiles", bname, 12) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35110:39: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("DominoTiles", bname, 11) == 0 || strncmp("dominotiles", bname, 11) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35110:81: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("DominoTiles", bname, 11) == 0 || strncmp("dominotiles", bname, 11) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35113:40: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("PlayingCards", bname, 12) == 0 || strncmp("playingcards", bname, 12) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35113:83: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("PlayingCards", bname, 12) == 0 || strncmp("playingcards", bname, 12) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35116:58: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("EnclosedAlphanumericSupplement", bname, 30) == 0 || strncmp("enclosedalphanumericsupplement", bname, 30) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35116:119: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("EnclosedAlphanumericSupplement", bname, 30) == 0 || strncmp("enclosedalphanumericsupplement", bname, 30) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35119:57: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("EnclosedIdeographicSupplement", bname, 29) == 0 || strncmp("enclosedideographicsupplement", bname, 29) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35119:117: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("EnclosedIdeographicSupplement", bname, 29) == 0 || strncmp("enclosedideographicsupplement", bname, 29) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35122:62: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("MiscellaneousSymbolsAndPictographs", bname, 34) == 0 || strncmp("miscellaneoussymbolsandpictographs", bname, 34) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35122:127: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("MiscellaneousSymbolsAndPictographs", bname, 34) == 0 || strncmp("miscellaneoussymbolsandpictographs", bname, 34) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35125:37: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Emoticons", bname, 9) == 0 || strncmp("emoticons", bname, 9) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35125:76: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Emoticons", bname, 9) == 0 || strncmp("emoticons", bname, 9) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35128:50: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("TransportAndMapSymbols", bname, 22) == 0 || strncmp("transportandmapsymbols", bname, 22) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35128:103: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("TransportAndMapSymbols", bname, 22) == 0 || strncmp("transportandmapsymbols", bname, 22) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35131:45: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("AlchemicalSymbols", bname, 17) == 0 || strncmp("alchemicalsymbols", bname, 17) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35131:93: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("AlchemicalSymbols", bname, 17) == 0 || strncmp("alchemicalsymbols", bname, 17) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35134:58: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("CJKUnifiedIdeographsExtensionB", bname, 30) == 0 || strncmp("cjkunifiedideographsextensionb", bname, 30) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35134:119: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("CJKUnifiedIdeographsExtensionB", bname, 30) == 0 || strncmp("cjkunifiedideographsextensionb", bname, 30) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35137:58: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("CJKUnifiedIdeographsExtensionC", bname, 30) == 0 || strncmp("cjkunifiedideographsextensionc", bname, 30) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35137:119: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("CJKUnifiedIdeographsExtensionC", bname, 30) == 0 || strncmp("cjkunifiedideographsextensionc", bname, 30) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35140:58: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("CJKUnifiedIdeographsExtensionD", bname, 30) == 0 || strncmp("cjkunifiedideographsextensiond", bname, 30) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35140:119: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("CJKUnifiedIdeographsExtensionD", bname, 30) == 0 || strncmp("cjkunifiedideographsextensiond", bname, 30) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35143:64: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("CJKCompatibilityIdeographsSupplement", bname, 36) == 0 || strncmp("cjkcompatibilityideographssupplement", bname, 36) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35143:131: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("CJKCompatibilityIdeographsSupplement", bname, 36) == 0 || strncmp("cjkcompatibilityideographssupplement", bname, 36) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35146:32: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Tags", bname, 4) == 0 || strncmp("tags", bname, 4) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35146:66: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("Tags", bname, 4) == 0 || strncmp("tags", bname, 4) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35149:56: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("VariationSelectorsSupplement", bname, 28) == 0 || strncmp("variationselectorssupplement", bname, 28) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35149:115: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("VariationSelectorsSupplement", bname, 28) == 0 || strncmp("variationselectorssupplement", bname, 28) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35152:56: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("SupplementaryPrivateUseAreaA", bname, 28) == 0 || strncmp("supplementaryprivateuseareaa", bname, 28) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35152:115: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("SupplementaryPrivateUseAreaA", bname, 28) == 0 || strncmp("supplementaryprivateuseareaa", bname, 28) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35155:56: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("SupplementaryPrivateUseAreaB", bname, 28) == 0 || strncmp("supplementaryprivateuseareab", bname, 28) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
src/strings/unicode.c:35155:115: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types with
different sign [-Wpointer-sign]
return strncmp("SupplementaryPrivateUseAreaB", bname, 28) == 0 || strncmp("supplementaryprivateuseareab", bname, 28) == 0;
^~~~~
/usr/include/string.h:84:40: note: passing argument to parameter here
int strncmp(const char *, const char *, size_t);
^
440 warnings generated.
compiling src/strings/latin1.o
compiling src/strings/utf16.o
compiling src/math/bigintops.o
compiling src/moar.o
compiling src/platform/posix/mmap.o
compiling src/platform/posix/time.o
compiling src/platform/posix/sys.o
compiling 3rdparty/sha1/sha1.o
linking 3rdparty/sha1/libsha1.a
compiling 3rdparty/libuv/src/unix/darwin.o
compiling 3rdparty/libuv/src/unix/darwin-proctitle.o
compiling 3rdparty/libuv/src/unix/fsevents.o
compiling 3rdparty/libuv/src/unix/kqueue.o
linking 3rdparty/libuv/libuv.a
compiling 3rdparty/libtommath/bn_error.o
compiling 3rdparty/libtommath/bn_fast_mp_invmod.o
compiling 3rdparty/libtommath/bn_fast_mp_montgomery_reduce.o
compiling 3rdparty/libtommath/bn_fast_s_mp_mul_digs.o
compiling 3rdparty/libtommath/bn_fast_s_mp_mul_high_digs.o
compiling 3rdparty/libtommath/bn_fast_s_mp_sqr.o
compiling 3rdparty/libtommath/bn_mp_2expt.o
compiling 3rdparty/libtommath/bn_mp_abs.o
compiling 3rdparty/libtommath/bn_mp_add.o
compiling 3rdparty/libtommath/bn_mp_add_d.o
compiling 3rdparty/libtommath/bn_mp_addmod.o
compiling 3rdparty/libtommath/bn_mp_and.o
compiling 3rdparty/libtommath/bn_mp_clamp.o
compiling 3rdparty/libtommath/bn_mp_clear.o
compiling 3rdparty/libtommath/bn_mp_clear_multi.o
compiling 3rdparty/libtommath/bn_mp_cmp.o
compiling 3rdparty/libtommath/bn_mp_cmp_d.o
compiling 3rdparty/libtommath/bn_mp_cmp_mag.o
compiling 3rdparty/libtommath/bn_mp_cnt_lsb.o
compiling 3rdparty/libtommath/bn_mp_copy.o
compiling 3rdparty/libtommath/bn_mp_count_bits.o
compiling 3rdparty/libtommath/bn_mp_div.o
compiling 3rdparty/libtommath/bn_mp_div_2.o
compiling 3rdparty/libtommath/bn_mp_div_2d.o
compiling 3rdparty/libtommath/bn_mp_div_3.o
compiling 3rdparty/libtommath/bn_mp_div_d.o
compiling 3rdparty/libtommath/bn_mp_dr_is_modulus.o
compiling 3rdparty/libtommath/bn_mp_dr_reduce.o
compiling 3rdparty/libtommath/bn_mp_dr_setup.o
compiling 3rdparty/libtommath/bn_mp_exch.o
compiling 3rdparty/libtommath/bn_mp_expt_d.o
compiling 3rdparty/libtommath/bn_mp_exptmod.o
compiling 3rdparty/libtommath/bn_mp_exptmod_fast.o
compiling 3rdparty/libtommath/bn_mp_exteuclid.o
compiling 3rdparty/libtommath/bn_mp_fread.o
compiling 3rdparty/libtommath/bn_mp_fwrite.o
compiling 3rdparty/libtommath/bn_mp_gcd.o
compiling 3rdparty/libtommath/bn_mp_get_int.o
compiling 3rdparty/libtommath/bn_mp_get_long.o
compiling 3rdparty/libtommath/bn_mp_grow.o
compiling 3rdparty/libtommath/bn_mp_init.o
compiling 3rdparty/libtommath/bn_mp_init_copy.o
compiling 3rdparty/libtommath/bn_mp_init_multi.o
compiling 3rdparty/libtommath/bn_mp_init_set.o
compiling 3rdparty/libtommath/bn_mp_init_set_int.o
compiling 3rdparty/libtommath/bn_mp_init_size.o
compiling 3rdparty/libtommath/bn_mp_invmod.o
compiling 3rdparty/libtommath/bn_mp_invmod_slow.o
compiling 3rdparty/libtommath/bn_mp_is_square.o
compiling 3rdparty/libtommath/bn_mp_jacobi.o
compiling 3rdparty/libtommath/bn_mp_karatsuba_mul.o
compiling 3rdparty/libtommath/bn_mp_karatsuba_sqr.o
compiling 3rdparty/libtommath/bn_mp_lcm.o
compiling 3rdparty/libtommath/bn_mp_lshd.o
compiling 3rdparty/libtommath/bn_mp_mod.o
compiling 3rdparty/libtommath/bn_mp_mod_2d.o
compiling 3rdparty/libtommath/bn_mp_mod_d.o
compiling 3rdparty/libtommath/bn_mp_montgomery_calc_normalization.o
compiling 3rdparty/libtommath/bn_mp_montgomery_reduce.o
compiling 3rdparty/libtommath/bn_mp_montgomery_setup.o
compiling 3rdparty/libtommath/bn_mp_mul.o
compiling 3rdparty/libtommath/bn_mp_mul_2.o
compiling 3rdparty/libtommath/bn_mp_mul_2d.o
compiling 3rdparty/libtommath/bn_mp_mul_d.o
compiling 3rdparty/libtommath/bn_mp_mulmod.o
compiling 3rdparty/libtommath/bn_mp_n_root.o
compiling 3rdparty/libtommath/bn_mp_neg.o
compiling 3rdparty/libtommath/bn_mp_or.o
compiling 3rdparty/libtommath/bn_mp_prime_fermat.o
compiling 3rdparty/libtommath/bn_mp_prime_is_divisible.o
compiling 3rdparty/libtommath/bn_mp_prime_is_prime.o
compiling 3rdparty/libtommath/bn_mp_prime_miller_rabin.o
compiling 3rdparty/libtommath/bn_mp_prime_next_prime.o
compiling 3rdparty/libtommath/bn_mp_prime_rabin_miller_trials.o
compiling 3rdparty/libtommath/bn_mp_prime_random_ex.o
compiling 3rdparty/libtommath/bn_mp_radix_size.o
compiling 3rdparty/libtommath/bn_mp_radix_smap.o
compiling 3rdparty/libtommath/bn_mp_rand.o
compiling 3rdparty/libtommath/bn_mp_read_radix.o
compiling 3rdparty/libtommath/bn_mp_read_signed_bin.o
compiling 3rdparty/libtommath/bn_mp_read_unsigned_bin.o
compiling 3rdparty/libtommath/bn_mp_reduce.o
compiling 3rdparty/libtommath/bn_mp_reduce_2k.o
compiling 3rdparty/libtommath/bn_mp_reduce_2k_l.o
compiling 3rdparty/libtommath/bn_mp_reduce_2k_setup.o
compiling 3rdparty/libtommath/bn_mp_reduce_2k_setup_l.o
compiling 3rdparty/libtommath/bn_mp_reduce_is_2k.o
compiling 3rdparty/libtommath/bn_mp_reduce_is_2k_l.o
compiling 3rdparty/libtommath/bn_mp_reduce_setup.o
compiling 3rdparty/libtommath/bn_mp_rshd.o
compiling 3rdparty/libtommath/bn_mp_set.o
compiling 3rdparty/libtommath/bn_mp_set_int.o
compiling 3rdparty/libtommath/bn_mp_set_long.o
compiling 3rdparty/libtommath/bn_mp_shrink.o
compiling 3rdparty/libtommath/bn_mp_signed_bin_size.o
compiling 3rdparty/libtommath/bn_mp_sqr.o
compiling 3rdparty/libtommath/bn_mp_sqrmod.o
compiling 3rdparty/libtommath/bn_mp_sqrt.o
compiling 3rdparty/libtommath/bn_mp_sub.o
compiling 3rdparty/libtommath/bn_mp_sub_d.o
compiling 3rdparty/libtommath/bn_mp_submod.o
compiling 3rdparty/libtommath/bn_mp_to_signed_bin.o
compiling 3rdparty/libtommath/bn_mp_to_signed_bin_n.o
compiling 3rdparty/libtommath/bn_mp_to_unsigned_bin.o
compiling 3rdparty/libtommath/bn_mp_to_unsigned_bin_n.o
compiling 3rdparty/libtommath/bn_mp_toom_mul.o
compiling 3rdparty/libtommath/bn_mp_toom_sqr.o
compiling 3rdparty/libtommath/bn_mp_toradix.o
compiling 3rdparty/libtommath/bn_mp_toradix_n.o
compiling 3rdparty/libtommath/bn_mp_unsigned_bin_size.o
compiling 3rdparty/libtommath/bn_mp_xor.o
compiling 3rdparty/libtommath/bn_mp_zero.o
compiling 3rdparty/libtommath/bn_prime_tab.o
compiling 3rdparty/libtommath/bn_reverse.o
compiling 3rdparty/libtommath/bn_s_mp_add.o
compiling 3rdparty/libtommath/bn_s_mp_exptmod.o
compiling 3rdparty/libtommath/bn_s_mp_mul_digs.o
compiling 3rdparty/libtommath/bn_s_mp_mul_high_digs.o
compiling 3rdparty/libtommath/bn_s_mp_sqr.o
compiling 3rdparty/libtommath/bn_s_mp_sub.o
compiling 3rdparty/libtommath/bncore.o
linking 3rdparty/libtommath/libtommath.a
linking 3rdparty/libatomic_ops/src/libatomic_ops.a
checking build system type... x86_64-apple-darwin13.0.0
checking host system type... x86_64-apple-darwin13.0.0
checking target system type... x86_64-apple-darwin13.0.0
checking for a BSD-compatible install... /usr/bin/install -c
checking whether build environment is sane... yes
checking for a thread-safe mkdir -p... ./install-sh -c -d
checking for gawk... no
checking for mawk... no
checking for nawk... no
checking for awk... awk
checking whether make sets $(MAKE)... yes
checking whether make supports nested variables... yes
checking whether to enable maintainer-specific portions of Makefiles... no
checking for style of include used by make... GNU
checking for gcc... clang
checking whether the C compiler works... yes
checking for C compiler default output file name... a.out
checking for suffix of executables...
checking whether we are cross compiling... no
checking for suffix of object files... o
checking whether we are using the GNU C compiler... yes
checking whether clang accepts -g... yes
checking for clang option to accept ISO C89... none needed
checking whether clang understands -c and -o together... yes
checking dependency style of clang... gcc3
checking dependency style of clang... gcc3
checking for ranlib... ranlib
checking how to run the C preprocessor... clang -E
checking for grep that handles long lines and -e... /usr/bin/grep
checking for egrep... /usr/bin/grep -E
checking for ANSI C header files... yes
checking for sys/types.h... yes
checking for sys/stat.h... yes
checking for stdlib.h... yes
checking for string.h... yes
checking for memory.h... yes
checking for strings.h... yes
checking for inttypes.h... yes
checking for stdint.h... yes
checking for unistd.h... yes
checking for stdlib.h... (cached) yes
checking for unistd.h... (cached) yes
checking for sys/param.h... yes
checking for getpagesize... yes
checking for working mmap... yes
checking for PIC compiler flag... -fPIC
checking whether gcc -fPIC causes __PIC__ definition... yes
checking for gcc -Wextra... yes
checking for pthread_self in -lpthread... yes
checking that generated files are newer than configure... done
configure: creating ./config.status
config.status: creating src/Makefile
config.status: creating src/config.h
config.status: executing depfiles commands
config.status: executing default commands
/Applications/Xcode.app/Contents/Developer/usr/bin/make all-am
clang -DHAVE_CONFIG_H -I../src -I../src -fPIC -Wall -Wextra -fno-omit-frame-pointer -fno-optimize-sibling-calls -O1 -D_DARWIN_USE_64_BIT_INODE=1 -DMVM_TRACING=0 -DMVM_CGOTO=0 -MT atomic_ops.o -MD -MP -MF .deps/atomic_ops.Tpo -c -o atomic_ops.o atomic_ops.c
mv -f .deps/atomic_ops.Tpo .deps/atomic_ops.Po
rm -f libatomic_ops.a
ar cru libatomic_ops.a atomic_ops.o
ranlib libatomic_ops.a
compiling 3rdparty/tinymt/tinymt64.o
linking 3rdparty/tinymt/libtinymt.a
linking libmoar.dylib
ld: warning: ld: warning: ignoring file 3rdparty/dyncall/dyncallback/libdyncallback_s.a, file was built for archive which is not the architecture being linked (x86_64): 3rdparty/dyncall/dyncallback/libdyncallback_s.ald: warning: ignoring file 3rdparty/libuv/libuv.a, file was built for archive which is not the architecture being linked (x86_64): 3rdparty/libuv/libuv.a
ignoring file 3rdparty/dyncall/dynload/libdynload_s.a, file was built for archive which is not the architecture being linked (x86_64): 3rdparty/dyncall/dynload/libdynload_s.a
ld: warning:
ld: warning: ignoring file 3rdparty/dyncall/dyncall/libdyncall_s.a, file was built for archive which is not the architecture being linked (x86_64): 3rdparty/dyncall/dyncall/libdyncall_s.aignoring file 3rdparty/linenoise/liblinenoise.a, file was built for archive which is not the architecture being linked (x86_64): 3rdparty/linenoise/liblinenoise.a
Undefined symbols for architecture x86_64:
"_dlFindSymbol", referenced from:
_MVM_dll_find_symbol in dll.o
"_dlFreeLibrary", referenced from:
_MVM_dll_free in dll.o
"_dlLoadLibrary", referenced from:
_MVM_dll_load in dll.o
"_linenoise", referenced from:
_MVM_file_readline_interactive_fh in fileops.o
"_linenoiseHistoryAdd", referenced from:
_MVM_file_readline_interactive_fh in fileops.o
"_uv_accept", referenced from:
_MVM_socket_accept in socketops.o
"_uv_buf_init", referenced from:
_MVM_file_write_fhs in fileops.o
_MVM_file_write_fhb in fileops.o
"_uv_chdir", referenced from:
_MVM_dir_chdir in dirops.o
"_uv_close", referenced from:
_MVM_socket_close in socketops.o
_spawn_on_exit in procops.o
_gc_free in MVMOSHandle.o
"_uv_cwd", referenced from:
_MVM_dir_cwd in dirops.o
"_uv_default_loop", referenced from:
_MVM_tc_create in threadcontext.o
"_uv_fs_chmod", referenced from:
_MVM_file_chmod in fileops.o
"_uv_fs_close", referenced from:
_MVM_cu_map_from_file in compunit.o
_MVM_file_copy in fileops.o
_MVM_file_close_fh in fileops.o
"_uv_fs_fstat", referenced from:
_MVM_file_readall_fh in fileops.o
"_uv_fs_fsync", referenced from:
_MVM_file_sync in fileops.o
"_uv_fs_ftruncate", referenced from:
_MVM_file_truncate in fileops.o
"_uv_fs_lstat", referenced from:
_file_info in fileops.o
_MVM_file_read_fhs in fileops.o
_MVM_file_eof in fileops.o
"_uv_fs_open", referenced from:
_MVM_cu_map_from_file in compunit.o
_MVM_file_copy in fileops.o
_MVM_file_open_fh in fileops.o
"_uv_fs_read", referenced from:
_MVM_file_readline_fh in fileops.o
_MVM_file_read_fhs in fileops.o
_MVM_file_read_fhb in fileops.o
_MVM_file_readall_fh in fileops.o
"_uv_fs_rename", referenced from:
_MVM_file_rename in fileops.o
"_uv_fs_rmdir", referenced from:
_MVM_dir_rmdir in dirops.o
"_uv_fs_sendfile", referenced from:
_MVM_file_copy in fileops.o
"_uv_fs_stat", referenced from:
_MVM_cu_map_from_file in compunit.o
_MVM_file_exists in fileops.o
_MVM_file_copy in fileops.o
"_uv_fs_unlink", referenced from:
_MVM_file_delete in fileops.o
"_uv_fs_write", referenced from:
_MVM_file_write_fhs in fileops.o
_MVM_file_write_fhb in fileops.o
"_uv_guess_handle", referenced from:
_MVM_file_get_stdstream in fileops.o
"_uv_ip4_addr", referenced from:
_MVM_socket_connect in socketops.o
_MVM_socket_bind in socketops.o
"_uv_is_closing", referenced from:
_gc_free in MVMOSHandle.o
"_uv_listen", referenced from:
_MVM_socket_listen in socketops.o
"_uv_loop_delete", referenced from:
_MVM_tc_destroy in threadcontext.o
"_uv_loop_new", referenced from:
_MVM_tc_create in threadcontext.o
"_uv_mutex_destroy", referenced from:
_MVM_vm_destroy_instance in moar.o
"_uv_mutex_init", referenced from:
_MVM_vm_create_instance in moar.o
"_uv_mutex_lock", referenced from:
_MVM_interp_run in interp.o
_deserialize_sc_deps in bytecode.o
_MVM_hll_get_config_for in hll.o
_MVM_hll_enter_compilee_mode in hll.o
_MVM_hll_leave_compilee_mode in hll.o
_MVM_load_bytecode in loadbytecode.o
_MVM_dll_load in dll.o
...
"_uv_mutex_unlock", referenced from:
_MVM_interp_run in interp.o
_deserialize_sc_deps in bytecode.o
_MVM_hll_get_config_for in hll.o
_MVM_hll_enter_compilee_mode in hll.o
_MVM_hll_leave_compilee_mode in hll.o
_MVM_load_bytecode in loadbytecode.o
_MVM_dll_load in dll.o
...
"_uv_pipe_init", referenced from:
_MVM_file_get_stdstream in fileops.o
"_uv_pipe_open", referenced from:
_MVM_file_get_stdstream in fileops.o
"_uv_read_start", referenced from:
_MVM_file_readline_fh in fileops.o
_MVM_file_read_fhs in fileops.o
_MVM_file_read_fhb in fileops.o
_MVM_socket_receive_string in socketops.o
"_uv_read_stop", referenced from:
_readline_on_read in fileops.o
"_uv_ref", referenced from:
_MVM_file_readline_fh in fileops.o
_MVM_proc_shell in procops.o
_MVM_proc_spawn in procops.o
"_uv_run", referenced from:
_MVM_tc_destroy in threadcontext.o
_MVM_file_readline_fh in fileops.o
_MVM_file_write_fhs in fileops.o
_MVM_proc_shell in procops.o
_MVM_proc_spawn in procops.o
"_uv_spawn", referenced from:
_MVM_proc_shell in procops.o
_MVM_proc_spawn in procops.o
"_uv_strerror", referenced from:
_MVM_cu_map_from_file in compunit.o
_file_info in fileops.o
_MVM_file_copy in fileops.o
_MVM_file_rename in fileops.o
_MVM_file_delete in fileops.o
_MVM_file_chmod in fileops.o
_MVM_file_open_fh in fileops.o
...
"_uv_tcp_bind", referenced from:
_MVM_socket_bind in socketops.o
"_uv_tcp_connect", referenced from:
_MVM_socket_connect in socketops.o
"_uv_tcp_init", referenced from:
_MVM_socket_connect in socketops.o
_MVM_socket_bind in socketops.o
_MVM_socket_accept in socketops.o
"_uv_thread_create", referenced from:
_MVM_thread_start in threads.o
"_uv_thread_join", referenced from:
_MVM_thread_join in threads.o
"_uv_tty_init", referenced from:
_MVM_file_get_stdstream in fileops.o
"_uv_udp_bind", referenced from:
_MVM_socket_bind in socketops.o
"_uv_udp_init", referenced from:
_MVM_socket_bind in socketops.o
"_uv_udp_recv_start", referenced from:
_MVM_socket_receive_string in socketops.o
"_uv_unref", referenced from:
_readline_on_read in fileops.o
_MVM_file_write_fhs in fileops.o
_write_cb in fileops.o
_spawn_on_exit in procops.o
"_uv_write", referenced from:
_MVM_file_write_fhs in fileops.o
_MVM_file_write_fhb in fileops.o
_MVM_socket_send_string in socketops.o
ld: symbol(s) not found for architecture x86_64
clang: error: linker command failed with exit code 1 (use -v to see invocation)
make: *** [libmoar.dylib] Error 1
18:50:29 [~/Downloads/MoarVM-2014.01] btyler$
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment