Почему strcmp не работает с кириллицей?

[BABLIK]

Всем привет!
Как сравнить 2 русских слова без учёта регистра ?

Вот так работает, но только на английских буквах:

if(!strcmp("pawn","Pawn",true))
{

}  

[ziggi]

Под Windows должно работать. А под Linux не работает потому, что используется стандартная tolower функция, которая работает только для латиницы.

[BABLIK]

Под Windows должно работать. А под Linux не работает потому, что используется стандартная tolower функция, которая работает только для латиницы.

Есть ли другой способ сверить слова ? Чтобы всё работало

[DeimoS]

Можешь попробовать взять функцию memcmp из этой библиотеки

[ziggi]

Есть ли другой способ сверить слова ? Чтобы всё работало

Можно написать свою, исправленные tolower и toupper можешь найти в fixes.inc. Может быть в будущем я это там исправлю сам.

[DeimoS]

Тщательно не тестировал, но вот, как вариант:

  Открыть/закрыть

stock ds_strcmp(const string1[], const string2[], bool:ignorecase=false, length=cellmax) 
{ 
    static 
        str1_len, 
        str2_len, 
        pos, 
        str1_sumbol, 
        str2_sumbol, 
        result; 
    if(ignorecase == true) 
    { 
        str1_len = strlen(string1); 
        str2_len = strlen(string2); 
        result = 0; 
 
        if(length == cellmax) 
        { 
            if(str1_len != str2_len) 
            { 
                if(str1_len > str2_len) 
                    return 1; 
                else 
                    return -1; 
            } 
            else 
                length = str1_len; 
        } 
        else 
        { 
            if(str1_len < length || str2_len < length) 
            { 
                if(str1_len > str2_len) 
                    return 1; 
                else 
                    return -1; 
            } 
        } 
 
        for(pos = length; pos != -1; --pos) 
        { 
            if(string1{0} == 0) 
                str1_sumbol = string1[pos]; 
            else 
                str1_sumbol = string1{pos}; 
 
            if(string2{0} == 0) 
                str2_sumbol = string2[pos]; 
            else 
                str2_sumbol = string2{pos}; 
 
            switch(str1_sumbol) 
            { 
                case 'А'..'Я', 'A'..'Z': 
                    str1_sumbol += ('а' - 'А'); 
                case 'Ё': 
                    str1_sumbol += ('ё' - 'Ё'); 
            } 
            switch(str2_sumbol) 
            { 
                case 'А'..'Я', 'A'..'Z': 
                    str2_sumbol += ('а' - 'А'); 
                case 'Ё': 
                    str2_sumbol += ('ё' - 'Ё'); 
            } 
            if(str1_sumbol != str2_sumbol) 
            { 
                if(str1_sumbol > str2_sumbol) 
                    result = 1; 
                else 
                    result = -1; 
                break; 
            } 
        } 
    } 
    else 
        result = strcmp(string1, string2, ignorecase, length); 
 
    return result; 
}  

 Версия до изменения (не рабочая)

stock ds_strcmp(const string1[], const string2[], bool:ignorecase=false, length=cellmax) 
{ 
    if(ignorecase == true) 
    { 
        static 
            str1_len, 
            str2_len, 
            pos, 
            str1_sumbol, 
            str2_sumbol, 
            result; 
 
        str1_len = strlen(string1); 
        str2_len = strlen(string2); 
        result = 0; 
 
        if(length == cellmax) 
        { 
            if(str1_len != str2_len) 
            { 
                if(str1_len > str2_len) 
                    return 1; 
                else 
                    return -1; 
            } 
            else 
                length = str1_len; 
        } 
        else 
        { 
            if(str1_len < length || str2_len < length) 
            { 
                if(str1_len > str2_len) 
                    return 1; 
                else 
                    return -1; 
            } 
        } 
 
        for(pos = length; pos != -1; --pos) 
        { 
            str1_sumbol = string1[pos]; 
            str2_sumbol = string2[pos]; 
            switch(str1_sumbol) 
            { 
                case 'А'..'Я': 
                    str1_sumbol += ('а' - 'А'); 
                case 'Ё': 
                    str1_sumbol += ('ё' - 'Ё'); 
            } 
            switch(str2_sumbol) 
            { 
                case 'А'..'Я': 
                    str2_sumbol += ('а' - 'А'); 
                case 'Ё': 
                    str2_sumbol += ('ё' - 'Ё'); 
            } 
            if(str1_sumbol != str2_sumbol) 
            { 
                if(str1_sumbol > str2_sumbol) 
                    result = 1; 
                else 
                    result = -1; 
                break; 
            } 
        } 
    } 
    else 
        result = strcmp(string1[], string2[], ignorecase, length); 
 
    return result; 
}  

Проблем с передачей массивов нет, ибо изменение регистра происходит в отдельных переменных.
Если всё будет работать как надо, можно попробовать извратиться над оптимизацией

[VVWVV]

Тщательно не тестировал, но вот, как вариант:

  Открыть/закрыть

stock ds_strcmp(const string1[], const string2[], bool:ignorecase=false, length=cellmax)
{
    if(ignorecase == true)
    {
        static
            str1_len,
            str2_len,
            pos,
            str1_sumbol,
            str2_sumbol,
            result;

        str1_len = strlen(string1);
        str2_len = strlen(string2);
        result = 0;

        if(length == cellmax)
        {
            if(str1_len != str2_len)
            {
                if(str1_len > str2_len)
                    return 1;
                else
                    return -1;
            }
            else
                length = str1_len;
        }
        else
        {
            if(str1_len < length || str2_len < length)
            {
                if(str1_len > str2_len)
                    return 1;
                else
                    return -1;
            }
        }

        for(pos = length; pos != -1; --pos)
        {
            str1_sumbol = string1[pos];
            str2_sumbol = string2[pos];
            switch(str1_sumbol)
            {
                case 'А'..'Я':
                    str1_sumbol += ('а' - 'А');
                case 'Ё':
                    str1_sumbol += ('ё' - 'Ё');
            }
            switch(str2_sumbol)
            {
                case 'А'..'Я':
                    str2_sumbol += ('а' - 'А');
                case 'Ё':
                    str2_sumbol += ('ё' - 'Ё');
            }
            if(str1_sumbol != str2_sumbol)
            {
                if(str1_sumbol > str2_sumbol)
                    result = 1;
                else
                    result = -1;
                break;
            }
        }
    }
    else
        result = strcmp(string1[], string2[], ignorecase, length);

    return result;
}  

Проблем с передачей массивов нет, ибо изменение регистра происходит в отдельных переменных.
Если всё будет работать как надо, можно попробовать извратиться над оптимизацией

Нужно вынести из if-блока, ибо будут ошибки:

static
			str1_len,
			str2_len,
			pos,
			str1_sumbol,
			str2_sumbol,
			result;

Нужно убрать скобки.

result = strcmp(string1[], string2[], ignorecase, length);

С русскими буквами работает. Кстати, ты не добавил поддержку букв латинского алфавита и упакованных строк.

[DeimoS]

Поддержка латинского алфавита изначально была, а вот потом я почему-то решил, что там она не нужна
За остальные замечания тоже спасибо. Нативный strcmp и переменные правил уже на форуме и как-то не углядел, что будут ошибки :(

Как вариант, так:

  Открыть/закрыть

stock ds_strcmp(const string1[], const string2[], bool:ignorecase=false, length=cellmax)
{
    static
        str1_len,
        str2_len,
        pos,
        str1_sumbol,
        str2_sumbol,
        result;
    if(ignorecase == true)
    {
        str1_len = strlen(string1);
        str2_len = strlen(string2);
        result = 0;

        if(length == cellmax)
        {
            if(str1_len != str2_len)
            {
                if(str1_len > str2_len)
                    return 1;
                else
                    return -1;
            }
            else
                length = str1_len;
        }
        else
        {
            if(str1_len < length || str2_len < length)
            {
                if(str1_len > str2_len)
                    return 1;
                else
                    return -1;
            }
        }

        for(pos = length; pos != -1; --pos)
        {
            if(string1{0} == 0)
                str1_sumbol = string1[pos];
            else
                str1_sumbol = string1{pos};

            if(string2{0} == 0)
                str2_sumbol = string2[pos];
            else
                str2_sumbol = string2{pos};

            switch(str1_sumbol)
            {
                case 'А'..'Я', 'A'..'Z':
                    str1_sumbol += ('а' - 'А');
                case 'Ё':
                    str1_sumbol += ('ё' - 'Ё');
            }
            switch(str2_sumbol)
            {
                case 'А'..'Я', 'A'..'Z':
                    str2_sumbol += ('а' - 'А');
                case 'Ё':
                    str2_sumbol += ('ё' - 'Ё');
            }
            if(str1_sumbol != str2_sumbol)
            {
                if(str1_sumbol > str2_sumbol)
                    result = 1;
                else
                    result = -1;
                break;
            }
        }
    }
    else
        result = strcmp(string1, string2, ignorecase, length);

    return result;
}  

Но я бы, в идеале, избавился от постоянных проверок, запакована ли строка, но для этого придётся для каждого случая свой цикл создать (ну или может я какой-то другой вариант упускаю)