path: root/swedish.c

/* See LICENSE file for copyright and license details. */
#include "common.h"

/*
 * There are no spaces in Swedish numbers
 *
 * All my life, I've seen Swedish numbers, being written out
 * in letters, completely absent of spaces. Banks, lotteries,
 * brokers commonly write out large numbers in letters, and
 * all of theme write without spaces; however to make it more
 * readable (which isn't really necessary), they do capitalise
 * some letters: for example, I bought by appartment for
 * “TvåmiljonerNittioFemtusen” (2095000) SEK. Actually, this
 * capitalisation is even a bit confusing because you naturally
 * read it as 2000000–90–5000 rather than 2000000–95000.
 * Recently, however, I've seen a non-Swedish style guide for
 * Swedish, that seems to have caught on, claiming that 2095000
 * should be written as “två miljoner nittiofemtusen”. This is
 * of follows completely different rules from the ones used to
 * arrive at “TvåmiljonerNittioFemtusen”, and feels like German.
 * So for some reason, this guide treats “miljon”, “miljard”,
 * and so one as special, nounesque, numbers, and therefore
 * thinks it should be surrounded by spaces. Looking to
 * “Svenska Akademiens ordbok”, we see the spaceless version
 * attested, but we also see the spaced version attested, albiet
 * with lower numbers after “miljon”, we see that “sex miljoner”
 * (actually it uses the older spelling for “miljoner”) attest,
 * but nothing akin to “sex miljoner femhundratusen”. Why would
 * “miljon” and larger numbers be treated separately from smaller
 * numbers, especially considering that in Swedish we regularly
 * combine words? There is only one differences between the larger
 * numbers and the smaller numbers: “miljon” och larger numbers
 * have distinct plural and singular from, whereas the smaller
 * numbers do not. This of couse shouldn't matter: “5 får” is
 * “fem får” not “femfår” (that would be something much more
 * horrific). Something that makes the larger numbers specially
 * is also that you can say for example “en och en halv miljon”,
 * but you cannot say “en och en halv tio”, but you can say
 * “en och en halv tusen”, and arguably “en och en halv hundra”,
 * and therefore you can say ”sex miljoner”, but why then would
 * you write “sex miljoner” but not “sex tusen”? However, you
 * cannot write “en och en halv miljon fyrahundratusen” (probably
 * not even “en och en halv miljon ettusen”, the would be
 * “en och en halv och/plus miljon ettusen”. The conclusion is
 * that 2095000 is properly written as “tvåmiljonernittiofemtusen”.
 * But moreover, if you accept the spaced spelling: what would
 * “en miljard fem miljondelar” mean? It would be completly
 * ambiguous. It could be 1/1005000000, 1000000000/5000000, or
 * 1000000005/1000000. In conclusion: the style that is coherent
 * with the rest of Swedish, is not arbitrary, and is unambiguous
 * it he one without any spaces.
 */


#if defined(__GNUC__)
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wunused-macros"
#endif

#define TYPE_INDEX(F)            (ORDINAL(F) | DENOMINATOR(F))
#define FORM_INDEX(F)            ((PLURAL_FORM(F) | DEFINITE_FORM(F)) / LIBNUMTEXT_N2T_SWEDISH_PLURAL_FORM)

#define CARDINAL(F)              (!ORDINAL(F))
#define ORDINAL(F)               ((F) & LIBNUMTEXT_N2T_SWEDISH_ORDINAL)

#define NUMERATOR(F)             (!DENOMINATOR(F))
#define DENOMINATOR(F)           ((F) & LIBNUMTEXT_N2T_SWEDISH_DENOMINATOR)

#define SINGULAR_FORM(F)         (!PLURAL_FORM(F))
#define PLURAL_FORM(F)           ((F) & LIBNUMTEXT_N2T_SWEDISH_PLURAL_FORM)

#define INDEFINITE_FORM(F)       (!DEFINITE_FORM(F))
#define DEFINITE_FORM(F)         ((F) & LIBNUMTEXT_N2T_SWEDISH_DEFINITE_FORM)

#define GENDER(F)                ((F) & UINT32_C(0x00000030))
#define COMMON_GENDER(F)         (GENDER(F) == LIBNUMTEXT_N2T_SWEDISH_COMMON_GENDER)
#define NEUTER_GENDER(F)         (GENDER(F) == LIBNUMTEXT_N2T_SWEDISH_NEUTER_GENDER)
#define MASCULINE_GENDER(F)      (GENDER(F) == LIBNUMTEXT_N2T_SWEDISH_MASCULINE_GENDER)
#define FEMININE_GENDER(F)       (GENDER(F) == LIBNUMTEXT_N2T_SWEDISH_FEMININE_GENDER)

#define EXPLICIT_ONE(F)          (!IMPLICIT_ONE(F))
#define IMPLICIT_ONE(F)          ((F) & LIBNUMTEXT_N2T_SWEDISH_IMPLICIT_ONE)

#define NOT_HYPHENATED(F)        (!HYPHENATED(F))
#define HYPHENATED(F)            ((F) & LIBNUMTEXT_N2T_SWEDISH_HYPHENATED)

#define CASE(F)                  ((F) & UINT32_C(0x00000300))
#define LOWER_CASE(F)            (CASE(F) == LIBNUMTEXT_N2T_SWEDISH_LOWER_CASE)
#define MONEY_CASE(F)            (CASE(F) == LIBNUMTEXT_N2T_SWEDISH_MONEY_CASE)
#define UPPER_CASE(F)            (CASE(F) == LIBNUMTEXT_N2T_SWEDISH_UPPER_CASE)
#define SENTENCE_CASE(F)         (CASE(F) == LIBNUMTEXT_N2T_SWEDISH_SENTENCE_CASE)

#define HYPHENATION(F)           ((F) & UINT32_C(0x00000C00))
#define NO_HYPHENATION(F)        (HYPHENATION(F) == LIBNUMTEXT_N2T_SWEDISH_NO_HYPHENATION)
#define COMPONENT_HYPHENATION(F) (HYPHENATION(F) == LIBNUMTEXT_N2T_SWEDISH_COMPONENT_HYPHENATION)
#define SYLLABLE_HYPHENATION(F)  (HYPHENATION(F) == LIBNUMTEXT_N2T_SWEDISH_SYLLABLE_HYPHENATION)
#define SECONDARY_HYPHENATION(F) (HYPHENATION(F) == LIBNUMTEXT_N2T_SWEDISH_SECONDARY_HYPHENATION)

#define TRIPLETS(F)              ((F) & UINT32_C(0x00003000))
#define REDUCED_TRIPLETS(F)      (TRIPLETS(F) == LIBNUMTEXT_N2T_SWEDISH_REDUCED_TRIPLETS)
#define EXPLICIT_TRIPLETS(F)     (TRIPLETS(F) == LIBNUMTEXT_N2T_SWEDISH_EXPLICIT_TRIPLETS)
#define LATEX_TRIPLETS(F)        (TRIPLETS(F) == LIBNUMTEXT_N2T_SWEDISH_LATEX_TRIPLETS)
#define X_INVALID_TRIPLETS(F)    (TRIPLETS(F) > LIBNUMTEXT_N2T_SWEDISH_LATEX_TRIPLETS)

#define INVALID_BITS(F)          ((F) & (uint32_t)~UINT32_C(0x00003FFF))

#if defined(__GNUC__)
# pragma GCC diagnostic pop
#endif


static struct digit {
	const char *cardinal_common;
	const char *cardinal_other;
	const char *ordinal_other;
	const char *ordinal_masculine;
	const char *ordinal_suffix;
} digits[] = {
	{"Noll",     NULL, "Noll¦te",  NULL,      NULL},
	{"Ett",      "En", "Förs¦ta",  "Förs¦te", NULL},
	{"Två",      NULL, "An¦dra",   "An¦dre",  NULL},
	{"Tre",      NULL, "Tre¦dje",  NULL,      NULL},
	{"Fy¦ra",    NULL, "Fjär¦de",  NULL,      NULL},
	{"Fem",      NULL, "Fem¦te",   NULL,      NULL},
	{"Sex",      NULL, "Sjät¦te",  NULL,      NULL},
	{"Sju",      NULL, "Sjun¦de",  NULL,      NULL},
	{"Åt¦ta",    NULL, "Åt¦ton",   NULL,      "¦de"},
	{"Nio",      NULL, "Ni¦on",    NULL,      "¦de"},
	{"Tio",      NULL, "Ti¦on",    NULL,      "¦de"},
	{"El¦va",    NULL, "Elf¦te",   NULL,      NULL},
	{"Tolv",     NULL, "Tolf¦te",  NULL,      NULL},
	{"Tret|ton", NULL, "Tret|ton", NULL,      "¦de"},
	{"Fjor|ton", NULL, "Fjor|ton", NULL,      "¦de"},
	{"Fem|ton",  NULL, "Fem|ton",  NULL,      "¦de"},
	{"Sex|ton",  NULL, "Sex|ton",  NULL,      "¦de"},
	{"Sjut|ton", NULL, "Sjut|ton", NULL,      "¦de"},
	{"Ar|ton",   NULL, "Ar|ton",   NULL,      "¦de"},
	{"Nit|ton",  NULL, "Nit|ton",  NULL,      "¦de"}
};

static struct ten {
	const char *cardinal;
	const char *ordinal;
} tens[10] = {
	{NULL,       NULL},
	{NULL,       NULL},
	{"Tju¦go",   "Tju¦gon"},
	{"Tret¦tio", "Tret¦ti¦on"},
	{"Fyr¦tio",  "Fyr¦ti¦on"},
	{"Fem¦tio",  "Fem¦ti¦on"},
	{"Sex¦tio",  "Sex¦ti¦on"},
	{"Sjut¦tio", "Sjut¦ti¦on"},
	{"Åt¦tio",   "Åt¦ti¦on"},
	{"Nit¦tio",  "Nit¦ti¦on"}
};

static struct special_denominator {
	const char *cardinal[4 /* form */];
	const char *ordinal;
} wholes_and_halves[] = {
	{{"Hel",  "He¦la",  "Hel¦an",  "Hel¦or¦na"},  "Hel¦te"},
	{{"Halv", "Hal¦vor", "Halv¦an", "Halv¦or¦na"}, "Half¦te"}
};

static struct denominator_suffix {
	const char *cardinal[4 /* form */];
	const char *ordinal;
} denominator_suffixes = {{"||del",  "||del¦ar",  "||del¦en",  "||del¦ar¦na"},  "||del¦te"};

static const char *signs[2 /* whether + */][4 /* type */] = {
	{"Mi¦nus ", "Mi¦nus-", "Mi¦nus-", "Mi¦nus-"},
	{"Plus ",   "Plus-",   "Plus-",   "Plus-"}
};

static struct great_suffix {
	const char *suffix[2 /* plural? */];
	const char *ordinal_suffix;
} great_suffixes[2 /* times 1000? */] = {
	{{"il¦jon",  "il¦jon¦er"},  "¦te"},
	{{"il¦jard", "il¦jard¦er"}, "<¦e"},
};

static struct great {
	const char *single_digit;
	const char *ones;
	const char *ones_suffixes;
	const char *tens_prefixes;
	const char *tens;
	const char *hundreds_prefixes;
	const char *hundreds;
} greats[] = {
	{NULL,       NULL,          NULL, NULL,  NULL,                NULL,  NULL},
	{"||m",      "||un",        "",   "n",   "||de¦ci",           "nx*", "||cen¦ti"},
	{"||b",      "||duo",       "",   "ms",  "||vi|gin¦ti",       "n",   "||du|cen¦ti"},
	{"||tr",     "||tre",       "s*", "ns",  "||tri|gin¦ta",      "ns",  "||tre|cen¦ti"},
	{"||kvad¦r", "||kvat¦tuor", "",   "ns",  "||kvad¦ra|gin¦ta",  "ns",  "||kvad¦rin|gen¦ti"},
	{"||kvin¦t", "||kvin",      "",   "ns",  "||kvin¦kva|gin¦ta", "ns",  "||kvin|gen¦ti"},
	{"||sex¦t",  "||se",        "sx", "n",   "||sex¦a|gin¦ta",    "n",   "||ses|cen¦ti"},
	{"||sep¦t",  "||sep¦te",    "mn", "n",   "||sep¦tua|gin¦ta",  "n",   "||sep¦tin|gen¦ti"},
	{"||ok¦t",   "||ok¦to",     "",   "mx*", "||ok¦to|gin¦ta",    "mx*", "||ok¦tin|gen|ti"},
	{"||no¦n",   "||no¦ve",     "mn", "",    "||no¦na|gin¦ta",    "",    "||non|gen¦ti"}
};


struct state {
	char *outbuf;
	size_t outbuf_size;
	size_t len;
	uint32_t flags;
	char double_char;
	char first;
	const char *append_for_ordinal;
};


static void
append(struct state *state, const char *appendage)
{
	uint32_t flags = state->flags;
	char hyphen[sizeof("¦x")], *p, a = 0, b = 0;
	int shift;

	for (; *appendage; a = b, b = *appendage++) {
		if (appendage[0] == '|' && appendage[1] == '|') {
			if (NO_HYPHENATION(flags))
				appendage = &appendage[2];
			else
				appendage = &appendage[1];
		} else if (appendage[0] == '|') {
			if (NO_HYPHENATION(flags) || COMPONENT_HYPHENATION(flags)) {
				appendage = &appendage[1];
			}
		} else if (!strncmp(&appendage[appendage[0] == '<'], "¦", sizeof("¦") - 1)) {
			shift = appendage[0] == '<';
			appendage = &appendage[shift];
			appendage = &appendage[sizeof("¦") - 1];
			if (SECONDARY_HYPHENATION(flags))
				p = stpcpy(hyphen, "¦");
			else if (SYLLABLE_HYPHENATION(flags))
				p = stpcpy(hyphen, "|");
			else
				p = NULL;
			if (p) {
				if (shift && state->len <= state->outbuf_size) {
					*p++ = state->outbuf[--state->len];
					*p = '\0';
				}
				for (p = hyphen; *p; p++) {
					if (state->len < state->outbuf_size)
						state->outbuf[state->len] = *p;
					state->len += 1;
				}
			}
		}

		if (state->len >= 2 && state->double_char == appendage[appendage[0] == '|']) {
			if (appendage[0] == '|' && !EXPLICIT_TRIPLETS(flags))
				appendage = &appendage[1];
			if (REDUCED_TRIPLETS(flags)) {
				state->len -= 1;
			} else if (LATEX_TRIPLETS(flags)) {
				if (state->len - 2 < state->outbuf_size)
					state->outbuf[state->len - 2] = '"';
			}
		}

		if (state->len && (HYPHENATED(flags) || HYPHENATION(flags))) {
			if (isupper(appendage[0]) || (appendage[0] == "Å"[0] && appendage[1] == "Å"[1])) {
				if (state->len < state->outbuf_size)
					state->outbuf[state->len] = HYPHENATED(flags) ? '-' : '|';
				state->len += 1;
			}
		}

		if (state->len < state->outbuf_size)
			state->outbuf[state->len] = *appendage;
		state->len += 1;
	}

	state->double_char = a == b ? a : 0;
}


static void
append_final_digit(struct state *state, int digit)
{
	uint32_t f = state->flags;
	struct digit *d = &digits[digit];

	if (ORDINAL(f) || DENOMINATOR(f)) {
		if (MASCULINE_GENDER(f) && d->ordinal_masculine)
			append(state, d->ordinal_masculine);
		else
			append(state, d->ordinal_other);
		state->append_for_ordinal = d->ordinal_suffix;
	} else {
		if (COMMON_GENDER(f) || !d->cardinal_other)
			append(state, d->cardinal_common);
		else
			append(state, d->cardinal_other);
		state->append_for_ordinal = NULL;
	}
}


static void
append_hundreds(struct state *state, int hundreds)
{
	if (hundreds) {
		if (state->first && hundreds == 1 && IMPLICIT_ONE(state->flags)) {
			append(state, "Hun¦dra");
		} else {
			append(state, digits[hundreds].cardinal_common);
			append(state, "||hun¦dra");
		}
		state->append_for_ordinal = "¦de";
		state->first = 0;
	}
}


static void
append_thousands(struct state *state, int ten_thousands, int one_thousands)
{
	if (state->first && ten_thousands == 0 && one_thousands == 1 && IMPLICIT_ONE(state->flags)) {
		append(state, "Tu¦sen");
	} else {
		if (tens[ten_thousands].cardinal)
			append(state, tens[ten_thousands].cardinal);
		else
			one_thousands += ten_thousands * 10;
		if (one_thousands)
			append(state, digits[one_thousands].cardinal_common);
		append(state, "||tu¦sen");
	}
	state->append_for_ordinal = "¦de";
	state->first = 0;
}


PURE static char
get_common_affix(const char *suffixes, const char *prefixes)
{
	const char *s, *p;
	if (suffixes && prefixes)
		for (p = prefixes; *p; p++)
			for (s = suffixes; *s; s++)
				if (*p == *s)
					return *p == '*' ? 's' : *p;
	return '\0';
}


static int
append_great(struct state *state, size_t great_order, size_t great_order_suffix, int plurality)
{
	const char *great_1, *great_1_suffixes, *great_last;
	const char *great_10, *great_10_prefixes;
	const char *great_100, *great_100_prefixes;
	char affix[2] = {[1] = 0};

	if (great_order < 10) {
		append(state, greats[great_order].single_digit);
	} else if (great_order > 999) {
		errno = EDOM;
		return -1;
	} else {
		great_1            = greats[(great_order /   1) % 10].ones;
		great_1_suffixes   = greats[(great_order /   1) % 10].ones_suffixes;
		great_10_prefixes  = greats[(great_order /  10) % 10].tens_prefixes;
		great_10           = greats[(great_order /  10) % 10].tens;
		great_100_prefixes = greats[(great_order / 100) % 10].hundreds_prefixes;
		great_100          = greats[(great_order / 100) % 10].hundreds;
		great_last = NULL;
		if (great_1) {
			append(state, great_1);
			great_last = great_1;
		}
		if (great_10) {
			if ((affix[0] = get_common_affix(great_1_suffixes, great_10_prefixes)))
				append(state, affix);
			append(state, great_10);
			great_last = great_10;
			great_1_suffixes = NULL;
		}
		if (great_100) {
			if ((affix[0] = get_common_affix(great_1_suffixes, great_100_prefixes)))
				append(state, affix);
			append(state, great_100);
			great_last = great_100;
		}
		while (great_last[1])
			great_last = &great_last[1];
		if (*great_last == 'a' || *great_last == 'e' || *great_last == 'i' || *great_last == 'o')
			state->len -= 1;
	}

	append(state, great_suffixes[great_order_suffix].suffix[plurality]);
	state->append_for_ordinal = great_suffixes[great_order_suffix].ordinal_suffix;

	return 0;
}


static void
nul_terminate(struct state *state)
{
	if (state->len < state->outbuf_size)
		state->outbuf[state->len] = '\0';
	else if (state->outbuf_size)
		state->outbuf[state->outbuf_size - 1] = '\0';
	state->len += 1;
}


static void
adjust_case(struct state *state)
{
	char *p = state->outbuf;

	if (!state->outbuf_size)
		return;

	/*
	 * Å   = \xc3\x85
	 * å   = \xc3\xa5
	 * Ä   = \xc3\x84
	 * ä   = \xc3\xa4
	 * Ö   = \xc3\x96
	 * ö   = \xc3\xb6
	 * A-Z = 0x41 - 0x5a
	 * a-z = 0x61 - 0x7a
	 * |   = 0x7c
	 * ¦   = \xc2\xa6
	 * -   = 0x2d
	 *     = 0x20 (space)
	 */
	if (SENTENCE_CASE(state->flags)) {
		p++;
		while (IS_UTF8_CHAR_CONTINUATION(*p))
			p++;
		goto lower_case;

	} else if (UPPER_CASE(state->flags)) {
		for (; *p; p++)
			if (islower(*p) || *p == '\xa5' || *p == '\xa4' || *p == '\xb6')
				*p ^= 0x20;

	} else if (LOWER_CASE(state->flags)) {
	lower_case:
		for (; *p; p++)
			if (isupper(*p) || *p == '\x85')
				*p ^= 0x20;
	}
}


ssize_t
libnumtext_num2text_swedish__(struct common_num2text_params *params, const char *num, size_t num_len, uint32_t flags)
{
	int hundred_thousands, ten_thousands, one_thousands, hundreds, ones;
	int great_plurality;
	size_t great_order, great_order_suffix, small_order;
	int32_t small_num;
	struct state state;

	if (INVALID_BITS(flags) || X_INVALID_TRIPLETS(flags))
		goto einval;
	if (PLURAL_FORM(flags) || DEFINITE_FORM(flags))
		if (!ORDINAL(flags) && !DENOMINATOR(flags))
			goto einval;

	state.outbuf = params->outbuf;
	state.outbuf_size = params->outbuf_size;
	state.len = 0;
	state.flags = flags;
	state.double_char = 0;
	state.first = 1;
	state.append_for_ordinal = NULL;

	if (params->sign_length)
		append(&state, signs[num[0] == '+'][TYPE_INDEX(flags)]);

	num += params->number_offset;
	num_len -= params->number_offset;

	if (num_len == 1 && '1' <= num[0] && num[0] <= '2' && DENOMINATOR(flags)) {
		if (ORDINAL(flags))
			append(&state, wholes_and_halves[num[0] - '1'].ordinal);
		else
			append(&state, wholes_and_halves[num[0] - '1'].cardinal[FORM_INDEX(flags)]);
		goto out;
	}

	while (num_len) {
		num_len -= 1;
		great_order = num_len / 6;
		small_order = num_len % 6;

		great_order_suffix = 0;
		if (great_order && small_order >= 3) {
			small_order -= 3;
			great_order_suffix = 1;
		}

		small_num = 0;
		hundred_thousands = ten_thousands = one_thousands = hundreds = ones = 0;

		switch (small_order) {
		case 5:
			hundred_thousands = *num++ - '0';
			small_num = (int32_t)hundred_thousands;
			num_len--;
			append_hundreds(&state, hundred_thousands);
			FALL_THROUGH
			/* fall through */

		case 4:
			ten_thousands = *num++ - '0';
			small_num *= 10;
			small_num += (int32_t)ten_thousands;
			num_len--;
			FALL_THROUGH
			/* fall through */

		case 3:
			one_thousands = *num++ - '0';
			small_num *= 10;
			small_num += (int32_t)one_thousands;
			num_len--;
			if (small_num)
				append_thousands(&state, ten_thousands, one_thousands);
			FALL_THROUGH
			/* fall through */

		case 2:
			hundreds = *num++ - '0';
			small_num *= 10;
			small_num += (int32_t)hundreds;
			num_len--;
			append_hundreds(&state, hundreds);
			FALL_THROUGH
			/* fall through */

		case 1:
			ones = *num++ - '0';
			small_num *= 10;
			small_num += (int32_t)ones;
			num_len--;
			if (tens[ones].cardinal) {
				if (!great_order && (DENOMINATOR(flags) || ORDINAL(flags)) && *num == '0') {
					append(&state, tens[ones].ordinal);
					state.append_for_ordinal = "¦de";
				} else {
					append(&state, tens[ones].cardinal);
					state.append_for_ordinal = NULL;
				}
				ones = 0;
				state.first = 0;
			} else {
				ones *= 10;
			}
			FALL_THROUGH
			/* fall through */

		case 0:
			small_num *= 10;
			small_num += (int32_t)(*num - '0');
			ones += *num++ - '0';
			if (ones || (state.first && !great_order)) {
				state.append_for_ordinal = NULL;
				if (!great_order)
					append_final_digit(&state, ones);
				else if (digits[ones].cardinal_other)
					append(&state, digits[ones].cardinal_other);
				else
					append(&state, digits[ones].cardinal_common);
				state.first = 0;
			}
			break;
		}

		if (great_order && small_num) {
			great_plurality = (num_len > params->trailing_zeroes || (CARDINAL(flags) && NUMERATOR(flags)));
			great_plurality = (great_plurality && small_num != 1);
			if (append_great(&state, great_order, great_order_suffix, great_plurality))
				return -1;
		}
	}

	if (DENOMINATOR(flags))
		append(&state, ORDINAL(flags) ? denominator_suffixes.ordinal : denominator_suffixes.cardinal[FORM_INDEX(flags)]);
	else if (ORDINAL(flags) && state.append_for_ordinal)
		append(&state, state.append_for_ordinal);

out:
	nul_terminate(&state);
	adjust_case(&state);
	return (ssize_t)state.len;

einval:
	errno = EINVAL;
	return -1;
}

#undef TYPE_INDEX
#undef FORM_INDEX
#undef CARDINAL
#undef ORDINAL
#undef NUMERATOR
#undef DENOMINATOR
#undef SINGULAR_FORM
#undef PLURAL_FORM
#undef INDEFINITE_FORM
#undef DEFINITE_FORM
#undef GENDER
#undef COMMON_GENDER
#undef NEUTER_GENDER
#undef MASCULINE_GENDER
#undef FEMININE_GENDER
#undef EXPLICIT_ONE
#undef IMPLICIT_ONE
#undef NOT_HYPHENATED
#undef HYPHENATED
#undef CASE
#undef LOWER_CASE
#undef MONEY_CASE
#undef UPPER_CASE
#undef SENTENCE_CASE
#undef HYPHENATION
#undef NO_HYPHENATION
#undef COMPONENT_HYPHENATION
#undef SYLLABLE_HYPHENATION
#undef SECONDARY_HYPHENATION
#undef TRIPLETS
#undef REDUCED_TRIPLETS
#undef EXPLICIT_TRIPLETS
#undef LATEX_TRIPLETS
#undef X_INVALID_TRIPLETS
#undef INVALID_BITS



#define GENDER(F)                ((F) & UINT32_C(0x00000003))
#define MASCULINE_GENDER(F)      (GENDER(F) == LIBNUMTEXT_C2O_SWEDISH_MASCULINE_GENDER)
#define UPPER_CASE(F)            ((F) & LIBNUMTEXT_C2O_SWEDISH_UPPER_CASE)
#define INVALID_BITS(F)          ((F) & (uint32_t)~UINT32_C(0x00000007))

ssize_t
libnumtext_card2ord_swedish__(char *outbuf, size_t outbuf_size, const char *num, size_t num_len, uint32_t flags)
{
	size_t i = 0, length = 0;
	char last_digit;

	if (INVALID_BITS(flags))
		goto einval;

	if (num_len) {
		if (num[0] == '+' || num[0] == '-')
			i += 1;
		else if (IS_UNICODE_MINUS(num, num_len))
			i += sizeof(UNICODE_MINUS) - 1;
	}

	while (i < num_len) {
		if (isdigit(num[i]))
			length = i += 1;
		else if (IS_UNICODE_NBSP(&num[i], num_len - i))
			i += sizeof(UNICODE_NBSP) - 1;
		else if (num[i] != ' ' && num[i] != '\'' && num[i] != '.')
			goto einval;
	}

	if (!length)
		goto einval;

	last_digit = num[length - 1];

	memcpy(outbuf, num, length < outbuf_size ? length : outbuf_size);
	if (length < outbuf_size)
		outbuf[length] = ':';
	length += 1;

	if (length < outbuf_size) {
		if (MASCULINE_GENDER(flags) || last_digit == '0' || last_digit > '2')
			outbuf[length] = UPPER_CASE(flags) ? 'E' : 'e';
		else
			outbuf[length] = UPPER_CASE(flags) ? 'A' : 'a';
	}
	length += 1;

	if (outbuf_size)
		outbuf[length < outbuf_size ? length : outbuf_size] = '\0';
	length += 1;

	return (ssize_t)length;

einval:
	errno = EINVAL;
	return -1;
}

#undef GENDER
#undef MASCULINE_GENDER
#undef UPPER_CASE
#undef INVALID_BITS