summaryrefslogtreecommitdiff
path: root/src/string_util.c
blob: 2159210d27e42c56d9369c72a0e6400328470af2 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
#include "nitro.h"

extern u32 gPowersOfTen[]; // at 0x20ECB24
extern u16 gDigitTable[];  // at 0x20ECB08

static const u16 EOS = 0xFFFF;

void StringCopy(u16 *dest, const u16 *src)
{
    u16 c = *src;
    while (c != EOS) {
        src++;
        *dest = c;
        c = *src;
        dest++;
    }
    *dest = EOS;
}

u16 *StringCopyN(u16 *dest, const u16 *src, u32 num)
{
    u32 copied = 0;
    if (num > copied) {
        u16 *p = dest;
        do {
            u16 c = *src;
            copied++;
            src++;
            *p = c;
            p++;
        } while (num > copied);
    }
    return dest + num;
}

u32 StringLength(const u16 *s)
{
    u16 c = *s;
    u32 len = 0;
    while (c != EOS) {
        s++;
        c = *s;
        len++;
    }
    return len;
}

BOOL StringNotEqual(const u16 *s1, const u16 *s2)
{
    for (; *s1 == *s2; s1++, s2++) {
        if (*s1 == EOS)
            return FALSE;
    }
    return TRUE;
}

BOOL StringNotEqualN(const u16 *s1, const u16 *s2, u32 num)
{
    u16 c1, c2;
    c2 = *s2;
    c1 = *s1;
    while (c1 == c2) {
        if (num == 0) {
            return FALSE;
        }
        if (*s1 == EOS && *s2 == EOS) {
            return FALSE;
        }
        s1++;
        s2++;
        c2 = *s2;
        c1 = *s1;
        num--;
    }
    return TRUE;
}

u16 *StringFill(u16 *dest, u16 value, u32 num)
{
    u32 copied = 0;
    if (num > copied) {
        u16 *p = dest;
        do {
            copied++;
            *p = value;
            p++;
        } while (copied < num);
    }
    return dest + copied;
}

u16 *StringFillEOS(u16 *dest, u32 num)
{
    return StringFill(dest, EOS, num);
}

enum PrintingMode {
    NORMAL,
    PAD_SPACE,
    PAD_ZEROES
};

const u16 NON_DIGIT = 0xE2;

u16 *ConvertUIntToDecimalString(u16 *dest, u32 value, enum PrintingMode mode, u32 n)
{
    for (u32 x = gPowersOfTen[n]; x != 0; x = x / 10) {
        u16 res = value / x;
        value = value - x * res;
        if (mode == PAD_ZEROES) {
            *dest = res >= 10 ? NON_DIGIT : gDigitTable[res];
            dest++;
        } else if (res != 0 || x == 1) {
            mode = PAD_ZEROES;
            *dest = res >= 10 ? NON_DIGIT : gDigitTable[res];
            dest++;
        } else if (mode == PAD_SPACE) {
            *dest = 1;
            dest++;
        }
    }
    *dest = EOS;
    return dest;
}