Changeset - r11372:b4fee729e4f8
[Not reviewed]
master
0 3 0
smatz - 16 years ago 2009-03-15 16:31:16
smatz@openttd.org
(svn r15727) -Codechange: apply coding style to namegen arrays
-Fix (r1307): missing comma in _name_original_english_4
3 files changed with 347 insertions and 347 deletions:
0 comments (0 inline, 0 general)
src/namegen.cpp
Show inline comments
 
@@ -45,20 +45,20 @@ static byte MakeEnglishOriginalTownName(
 
	strecpy(buf, "", last);
 

	
 
	/* optional first segment */
 
	i = SeedChanceBias(0, lengthof(name_original_english_1), seed, 50);
 
	i = SeedChanceBias(0, lengthof(_name_original_english_1), seed, 50);
 
	if (i >= 0)
 
		strecat(buf, name_original_english_1[i], last);
 
		strecat(buf, _name_original_english_1[i], last);
 

	
 
	/* mandatory middle segments */
 
	strecat(buf, name_original_english_2[SeedChance(4,  lengthof(name_original_english_2), seed)], last);
 
	strecat(buf, name_original_english_3[SeedChance(7,  lengthof(name_original_english_3), seed)], last);
 
	strecat(buf, name_original_english_4[SeedChance(10, lengthof(name_original_english_4), seed)], last);
 
	strecat(buf, name_original_english_5[SeedChance(13, lengthof(name_original_english_5), seed)], last);
 
	strecat(buf, _name_original_english_2[SeedChance(4,  lengthof(_name_original_english_2), seed)], last);
 
	strecat(buf, _name_original_english_3[SeedChance(7,  lengthof(_name_original_english_3), seed)], last);
 
	strecat(buf, _name_original_english_4[SeedChance(10, lengthof(_name_original_english_4), seed)], last);
 
	strecat(buf, _name_original_english_5[SeedChance(13, lengthof(_name_original_english_5), seed)], last);
 

	
 
	/* optional last segment */
 
	i = SeedChanceBias(15, lengthof(name_original_english_6), seed, 60);
 
	i = SeedChanceBias(15, lengthof(_name_original_english_6), seed, 60);
 
	if (i >= 0)
 
		strecat(buf, name_original_english_6[i], last);
 
		strecat(buf, _name_original_english_6[i], last);
 

	
 
	if (buf[0] == 'C' && (buf[1] == 'e' || buf[1] == 'i'))
 
		buf[0] = 'K';
 
@@ -86,28 +86,28 @@ static byte MakeEnglishAdditionalTownNam
 
	strecpy(buf, "", last);
 

	
 
	/* optional first segment */
 
	i = SeedChanceBias(0, lengthof(name_additional_english_prefix), seed, 50);
 
	i = SeedChanceBias(0, lengthof(_name_additional_english_prefix), seed, 50);
 
	if (i >= 0)
 
		strecat(buf, name_additional_english_prefix[i], last);
 
		strecat(buf, _name_additional_english_prefix[i], last);
 

	
 
	if (SeedChance(3, 20, seed) >= 14) {
 
		strecat(buf, name_additional_english_1a[SeedChance(6, lengthof(name_additional_english_1a), seed)], last);
 
		strecat(buf, _name_additional_english_1a[SeedChance(6, lengthof(_name_additional_english_1a), seed)], last);
 
	} else {
 
		strecat(buf, name_additional_english_1b1[SeedChance(6, lengthof(name_additional_english_1b1), seed)], last);
 
		strecat(buf, name_additional_english_1b2[SeedChance(9, lengthof(name_additional_english_1b2), seed)], last);
 
		strecat(buf, _name_additional_english_1b1[SeedChance(6, lengthof(_name_additional_english_1b1), seed)], last);
 
		strecat(buf, _name_additional_english_1b2[SeedChance(9, lengthof(_name_additional_english_1b2), seed)], last);
 
		if (SeedChance(11, 20, seed) >= 4) {
 
			strecat(buf, name_additional_english_1b3a[SeedChance(12, lengthof(name_additional_english_1b3a), seed)], last);
 
			strecat(buf, _name_additional_english_1b3a[SeedChance(12, lengthof(_name_additional_english_1b3a), seed)], last);
 
		} else {
 
			strecat(buf, name_additional_english_1b3b[SeedChance(12, lengthof(name_additional_english_1b3b), seed)], last);
 
			strecat(buf, _name_additional_english_1b3b[SeedChance(12, lengthof(_name_additional_english_1b3b), seed)], last);
 
		}
 
	}
 

	
 
	strecat(buf, name_additional_english_2[SeedChance(14, lengthof(name_additional_english_2), seed)], last);
 
	strecat(buf, _name_additional_english_2[SeedChance(14, lengthof(_name_additional_english_2), seed)], last);
 

	
 
	/* optional last segment */
 
	i = SeedChanceBias(15, lengthof(name_additional_english_3), seed, 60);
 
	i = SeedChanceBias(15, lengthof(_name_additional_english_3), seed, 60);
 
	if (i >= 0)
 
		strecat(buf, name_additional_english_3[i], last);
 
		strecat(buf, _name_additional_english_3[i], last);
 

	
 
	ReplaceWords("Cunt", "East", buf);
 
	ReplaceWords("Slag", "Pits", buf);
 
@@ -129,33 +129,33 @@ static byte MakeAustrianTownName(char *b
 
	strecpy(buf, "", last);
 

	
 
	/* Bad, Maria, Gross, ... */
 
	i = SeedChanceBias(0, lengthof(name_austrian_a1), seed, 15);
 
	if (i >= 0) strecat(buf, name_austrian_a1[i], last);
 
	i = SeedChanceBias(0, lengthof(_name_austrian_a1), seed, 15);
 
	if (i >= 0) strecat(buf, _name_austrian_a1[i], last);
 

	
 
	i = SeedChance(4, 6, seed);
 
	if (i >= 4) {
 
		/* Kaisers-kirchen */
 
		strecat(buf, name_austrian_a2[SeedChance( 7, lengthof(name_austrian_a2), seed)], last);
 
		strecat(buf, name_austrian_a3[SeedChance(13, lengthof(name_austrian_a3), seed)], last);
 
		strecat(buf, _name_austrian_a2[SeedChance( 7, lengthof(_name_austrian_a2), seed)], last);
 
		strecat(buf, _name_austrian_a3[SeedChance(13, lengthof(_name_austrian_a3), seed)], last);
 
	} else if (i >= 2) {
 
		/* St. Johann */
 
		strecat(buf, name_austrian_a5[SeedChance( 7, lengthof(name_austrian_a5), seed)], last);
 
		strecat(buf, name_austrian_a6[SeedChance( 9, lengthof(name_austrian_a6), seed)], last);
 
		strecat(buf, _name_austrian_a5[SeedChance( 7, lengthof(_name_austrian_a5), seed)], last);
 
		strecat(buf, _name_austrian_a6[SeedChance( 9, lengthof(_name_austrian_a6), seed)], last);
 
		j = 1; // More likely to have a " an der " or " am "
 
	} else {
 
		/* Zell */
 
		strecat(buf, name_austrian_a4[SeedChance( 7, lengthof(name_austrian_a4), seed)], last);
 
		strecat(buf, _name_austrian_a4[SeedChance( 7, lengthof(_name_austrian_a4), seed)], last);
 
	}
 

	
 
	i = SeedChance(1, 6, seed);
 
	if (i >= 4 - j) {
 
		/* an der Donau (rivers) */
 
		strecat(buf, name_austrian_f1[SeedChance(4, lengthof(name_austrian_f1), seed)], last);
 
		strecat(buf, name_austrian_f2[SeedChance(5, lengthof(name_austrian_f2), seed)], last);
 
		strecat(buf, _name_austrian_f1[SeedChance(4, lengthof(_name_austrian_f1), seed)], last);
 
		strecat(buf, _name_austrian_f2[SeedChance(5, lengthof(_name_austrian_f2), seed)], last);
 
	} else if (i >= 2 - j) {
 
		/* am Dachstein (mountains) */
 
		strecat(buf, name_austrian_b1[SeedChance(4, lengthof(name_austrian_b1), seed)], last);
 
		strecat(buf, name_austrian_b2[SeedChance(5, lengthof(name_austrian_b2), seed)], last);
 
		strecat(buf, _name_austrian_b1[SeedChance(4, lengthof(_name_austrian_b1), seed)], last);
 
		strecat(buf, _name_austrian_b2[SeedChance(5, lengthof(_name_austrian_b2), seed)], last);
 
	}
 

	
 
	return 0;
 
@@ -173,31 +173,31 @@ static byte MakeGermanTownName(char *buf
 

	
 
	/* optional prefix */
 
	if (seed_derivative == 12 || seed_derivative == 19) {
 
		i = SeedChance(2, lengthof(name_german_pre), seed);
 
		strecat(buf, name_german_pre[i], last);
 
		i = SeedChance(2, lengthof(_name_german_pre), seed);
 
		strecat(buf, _name_german_pre[i], last);
 
	}
 

	
 
	/* mandatory middle segments including option of hardcoded name */
 
	i = SeedChance(3, lengthof(name_german_real) + lengthof(name_german_1), seed);
 
	if (i < lengthof(name_german_real)) {
 
		strecat(buf, name_german_real[i], last);
 
	i = SeedChance(3, lengthof(_name_german_real) + lengthof(_name_german_1), seed);
 
	if (i < lengthof(_name_german_real)) {
 
		strecat(buf, _name_german_real[i], last);
 
	} else {
 
		strecat(buf, name_german_1[i - lengthof(name_german_real)], last);
 
		strecat(buf, _name_german_1[i - lengthof(_name_german_real)], last);
 

	
 
		i = SeedChance(5, lengthof(name_german_2), seed);
 
		strecat(buf, name_german_2[i], last);
 
		i = SeedChance(5, lengthof(_name_german_2), seed);
 
		strecat(buf, _name_german_2[i], last);
 
	}
 

	
 
	/* optional suffix */
 
	if (seed_derivative == 24) {
 
		i = SeedChance(9,
 
			lengthof(name_german_4_an_der) + lengthof(name_german_4_am), seed);
 
		if (i < lengthof(name_german_4_an_der)) {
 
			strecat(buf, name_german_3_an_der[0], last);
 
			strecat(buf, name_german_4_an_der[i], last);
 
			lengthof(_name_german_4_an_der) + lengthof(_name_german_4_am), seed);
 
		if (i < lengthof(_name_german_4_an_der)) {
 
			strecat(buf, _name_german_3_an_der[0], last);
 
			strecat(buf, _name_german_4_an_der[i], last);
 
		} else {
 
			strecat(buf, name_german_3_am[0], last);
 
			strecat(buf, name_german_4_am[i - lengthof(name_german_4_an_der)], last);
 
			strecat(buf, _name_german_3_am[0], last);
 
			strecat(buf, _name_german_4_am[i - lengthof(_name_german_4_an_der)], last);
 
		}
 
	}
 
	return 0;
 
@@ -205,20 +205,20 @@ static byte MakeGermanTownName(char *buf
 

	
 
static byte MakeSpanishTownName(char *buf, uint32 seed, const char *last)
 
{
 
	strecpy(buf, name_spanish_real[SeedChance(0, lengthof(name_spanish_real), seed)], last);
 
	strecpy(buf, _name_spanish_real[SeedChance(0, lengthof(_name_spanish_real), seed)], last);
 
	return 0;
 
}
 

	
 
static byte MakeFrenchTownName(char *buf, uint32 seed, const char *last)
 
{
 
	strecpy(buf, name_french_real[SeedChance(0, lengthof(name_french_real), seed)], last);
 
	strecpy(buf, _name_french_real[SeedChance(0, lengthof(_name_french_real), seed)], last);
 
	return 0;
 
}
 

	
 
static byte MakeSillyTownName(char *buf, uint32 seed, const char *last)
 
{
 
	strecpy(buf, name_silly_1[SeedChance( 0, lengthof(name_silly_1), seed)], last);
 
	strecat(buf, name_silly_2[SeedChance(16, lengthof(name_silly_2), seed)], last);
 
	strecpy(buf, _name_silly_1[SeedChance( 0, lengthof(_name_silly_1), seed)], last);
 
	strecat(buf, _name_silly_2[SeedChance(16, lengthof(_name_silly_2), seed)], last);
 
	return 0;
 
}
 

	
 
@@ -230,20 +230,20 @@ static byte MakeSwedishTownName(char *bu
 
	strecpy(buf, "", last);
 

	
 
	/* optional first segment */
 
	i = SeedChanceBias(0, lengthof(name_swedish_1), seed, 50);
 
	i = SeedChanceBias(0, lengthof(_name_swedish_1), seed, 50);
 
	if (i >= 0)
 
		strecat(buf, name_swedish_1[i], last);
 
		strecat(buf, _name_swedish_1[i], last);
 

	
 
	/* mandatory middle segments including option of hardcoded name */
 
	if (SeedChance(4, 5, seed) >= 3) {
 
		strecat(buf, name_swedish_2[SeedChance( 7, lengthof(name_swedish_2), seed)], last);
 
		strecat(buf, _name_swedish_2[SeedChance( 7, lengthof(_name_swedish_2), seed)], last);
 
	} else {
 
		strecat(buf, name_swedish_2a[SeedChance( 7, lengthof(name_swedish_2a), seed)], last);
 
		strecat(buf, name_swedish_2b[SeedChance(10, lengthof(name_swedish_2b), seed)], last);
 
		strecat(buf, name_swedish_2c[SeedChance(13, lengthof(name_swedish_2c), seed)], last);
 
		strecat(buf, _name_swedish_2a[SeedChance( 7, lengthof(_name_swedish_2a), seed)], last);
 
		strecat(buf, _name_swedish_2b[SeedChance(10, lengthof(_name_swedish_2b), seed)], last);
 
		strecat(buf, _name_swedish_2c[SeedChance(13, lengthof(_name_swedish_2c), seed)], last);
 
	}
 

	
 
	strecat(buf, name_swedish_3[SeedChance(16, lengthof(name_swedish_3), seed)], last);
 
	strecat(buf, _name_swedish_3[SeedChance(16, lengthof(_name_swedish_3), seed)], last);
 

	
 
	return 0;
 
}
 
@@ -256,18 +256,18 @@ static byte MakeDutchTownName(char *buf,
 
	strecpy(buf, "", last);
 

	
 
	/* optional first segment */
 
	i = SeedChanceBias(0, lengthof(name_dutch_1), seed, 50);
 
	i = SeedChanceBias(0, lengthof(_name_dutch_1), seed, 50);
 
	if (i >= 0)
 
		strecat(buf, name_dutch_1[i], last);
 
		strecat(buf, _name_dutch_1[i], last);
 

	
 
	/* mandatory middle segments including option of hardcoded name */
 
	if (SeedChance(6, 9, seed) > 4) {
 
		strecat(buf, name_dutch_2[SeedChance( 9, lengthof(name_dutch_2), seed)], last);
 
		strecat(buf, _name_dutch_2[SeedChance( 9, lengthof(_name_dutch_2), seed)], last);
 
	} else {
 
		strecat(buf, name_dutch_3[SeedChance( 9, lengthof(name_dutch_3), seed)], last);
 
		strecat(buf, name_dutch_4[SeedChance(12, lengthof(name_dutch_4), seed)], last);
 
		strecat(buf, _name_dutch_3[SeedChance( 9, lengthof(_name_dutch_3), seed)], last);
 
		strecat(buf, _name_dutch_4[SeedChance(12, lengthof(_name_dutch_4), seed)], last);
 
	}
 
	strecat(buf, name_dutch_5[SeedChance(15, lengthof(name_dutch_5), seed)], last);
 
	strecat(buf, _name_dutch_5[SeedChance(15, lengthof(_name_dutch_5), seed)], last);
 

	
 
	return 0;
 
}
 
@@ -279,14 +279,14 @@ static byte MakeFinnishTownName(char *bu
 

	
 
	/* Select randomly if town name should consists of one or two parts. */
 
	if (SeedChance(0, 15, seed) >= 10) {
 
		strecat(buf, name_finnish_real[SeedChance(2, lengthof(name_finnish_real), seed)], last);
 
		strecat(buf, _name_finnish_real[SeedChance(2, lengthof(_name_finnish_real), seed)], last);
 
	} else if (SeedChance(0, 15, seed) >= 5) {
 
		/* A two-part name by combining one of name_finnish_1 + "la"/"lä"
 
		 * The reason for not having the contents of name_finnish_{1,2} in the same table is
 
		 * that the ones in name_finnish_2 are not good for this purpose. */
 
		uint sel = SeedChance( 0, lengthof(name_finnish_1), seed);
 
		/* A two-part name by combining one of _name_finnish_1 + "la"/"lä"
 
		 * The reason for not having the contents of _name_finnish_{1,2} in the same table is
 
		 * that the ones in _name_finnish_2 are not good for this purpose. */
 
		uint sel = SeedChance( 0, lengthof(_name_finnish_1), seed);
 
		char *end;
 
		strecat(buf, name_finnish_1[sel], last);
 
		strecat(buf, _name_finnish_1[sel], last);
 
		end = &buf[strlen(buf)-1];
 
		if (*end == 'i')
 
			*end = 'e';
 
@@ -298,16 +298,16 @@ static byte MakeFinnishTownName(char *bu
 
			strecat(buf, "lä", last);
 
		}
 
	} else {
 
		/* A two-part name by combining one of name_finnish_{1,2} + name_finnish_3.
 
		 * Why aren't name_finnish_{1,2} just one table? See above. */
 
		/* A two-part name by combining one of _name_finnish_{1,2} + _name_finnish_3.
 
		 * Why aren't _name_finnish_{1,2} just one table? See above. */
 
		uint sel = SeedChance(2,
 
			lengthof(name_finnish_1) + lengthof(name_finnish_2), seed);
 
		if (sel >= lengthof(name_finnish_1)) {
 
			strecat(buf, name_finnish_2[sel - lengthof(name_finnish_1)], last);
 
			lengthof(_name_finnish_1) + lengthof(_name_finnish_2), seed);
 
		if (sel >= lengthof(_name_finnish_1)) {
 
			strecat(buf, _name_finnish_2[sel - lengthof(_name_finnish_1)], last);
 
		} else {
 
			strecat(buf, name_finnish_1[sel], last);
 
			strecat(buf, _name_finnish_1[sel], last);
 
		}
 
		strecat(buf, name_finnish_3[SeedChance(10, lengthof(name_finnish_3), seed)], last);
 
		strecat(buf, _name_finnish_3[SeedChance(10, lengthof(_name_finnish_3), seed)], last);
 
	}
 

	
 
	return 0;
 
@@ -323,38 +323,38 @@ static byte MakePolishTownName(char *buf
 

	
 
	/* optional first segment */
 
	i = SeedChance(0,
 
		lengthof(name_polish_2_o) + lengthof(name_polish_2_m) +
 
		lengthof(name_polish_2_f) + lengthof(name_polish_2_n),
 
		lengthof(_name_polish_2_o) + lengthof(_name_polish_2_m) +
 
		lengthof(_name_polish_2_f) + lengthof(_name_polish_2_n),
 
		seed);
 
	j = SeedChance(2, 20, seed);
 

	
 

	
 
	if (i < lengthof(name_polish_2_o)) {
 
		strecat(buf, name_polish_2_o[SeedChance(3, lengthof(name_polish_2_o), seed)], last);
 
	} else if (i < lengthof(name_polish_2_m) + lengthof(name_polish_2_o)) {
 
	if (i < lengthof(_name_polish_2_o)) {
 
		strecat(buf, _name_polish_2_o[SeedChance(3, lengthof(_name_polish_2_o), seed)], last);
 
	} else if (i < lengthof(_name_polish_2_m) + lengthof(_name_polish_2_o)) {
 
		if (j < 4)
 
			strecat(buf, name_polish_1_m[SeedChance(5, lengthof(name_polish_1_m), seed)], last);
 
			strecat(buf, _name_polish_1_m[SeedChance(5, lengthof(_name_polish_1_m), seed)], last);
 

	
 
		strecat(buf, name_polish_2_m[SeedChance(7, lengthof(name_polish_2_m), seed)], last);
 
		strecat(buf, _name_polish_2_m[SeedChance(7, lengthof(_name_polish_2_m), seed)], last);
 

	
 
		if (j >= 4 && j < 16)
 
			strecat(buf, name_polish_3_m[SeedChance(10, lengthof(name_polish_3_m), seed)], last);
 
	} else if (i < lengthof(name_polish_2_f) + lengthof(name_polish_2_m) + lengthof(name_polish_2_o)) {
 
			strecat(buf, _name_polish_3_m[SeedChance(10, lengthof(_name_polish_3_m), seed)], last);
 
	} else if (i < lengthof(_name_polish_2_f) + lengthof(_name_polish_2_m) + lengthof(_name_polish_2_o)) {
 
		if (j < 4)
 
			strecat(buf, name_polish_1_f[SeedChance(5, lengthof(name_polish_1_f), seed)], last);
 
			strecat(buf, _name_polish_1_f[SeedChance(5, lengthof(_name_polish_1_f), seed)], last);
 

	
 
		strecat(buf, name_polish_2_f[SeedChance(7, lengthof(name_polish_2_f), seed)], last);
 
		strecat(buf, _name_polish_2_f[SeedChance(7, lengthof(_name_polish_2_f), seed)], last);
 

	
 
		if (j >= 4 && j < 16)
 
			strecat(buf, name_polish_3_f[SeedChance(10, lengthof(name_polish_3_f), seed)], last);
 
			strecat(buf, _name_polish_3_f[SeedChance(10, lengthof(_name_polish_3_f), seed)], last);
 
	} else {
 
		if (j < 4)
 
			strecat(buf, name_polish_1_n[SeedChance(5, lengthof(name_polish_1_n), seed)], last);
 
			strecat(buf, _name_polish_1_n[SeedChance(5, lengthof(_name_polish_1_n), seed)], last);
 

	
 
		strecat(buf, name_polish_2_n[SeedChance(7, lengthof(name_polish_2_n), seed)], last);
 
		strecat(buf, _name_polish_2_n[SeedChance(7, lengthof(_name_polish_2_n), seed)], last);
 

	
 
		if (j >= 4 && j < 16)
 
			strecat(buf, name_polish_3_n[SeedChance(10, lengthof(name_polish_3_n), seed)], last);
 
			strecat(buf, _name_polish_3_n[SeedChance(10, lengthof(_name_polish_3_n), seed)], last);
 
	}
 
	return 0;
 
}
 
@@ -376,7 +376,7 @@ static byte MakeCzechTownName(char *buf,
 

	
 
	/* 1:3 chance to use a real name. */
 
	if (SeedModChance(0, 4, seed) == 0) {
 
		strecpy(buf, name_czech_real[SeedModChance(4, lengthof(name_czech_real), seed)], last);
 
		strecpy(buf, _name_czech_real[SeedModChance(4, lengthof(_name_czech_real), seed)], last);
 
		return 0;
 
	}
 

	
 
@@ -387,51 +387,51 @@ static byte MakeCzechTownName(char *buf,
 
	do_prefix = prob_tails < 12;
 
	do_suffix = prob_tails > 11 && prob_tails < 17;
 

	
 
	if (do_prefix) prefix = SeedModChance(5, lengthof(name_czech_adj) * 12, seed) / 12;
 
	if (do_suffix) suffix = SeedModChance(7, lengthof(name_czech_suffix), seed);
 
	if (do_prefix) prefix = SeedModChance(5, lengthof(_name_czech_adj) * 12, seed) / 12;
 
	if (do_suffix) suffix = SeedModChance(7, lengthof(_name_czech_suffix), seed);
 
	/* 3:1 chance 3:1 to use dynamic substantive */
 
	stem = SeedModChance(9,
 
		lengthof(name_czech_subst_full) + 3 * lengthof(name_czech_subst_stem),
 
		lengthof(_name_czech_subst_full) + 3 * lengthof(_name_czech_subst_stem),
 
		seed);
 
	if (stem < lengthof(name_czech_subst_full)) {
 
	if (stem < lengthof(_name_czech_subst_full)) {
 
		/* That was easy! */
 
		dynamic_subst = false;
 
		gender = name_czech_subst_full[stem].gender;
 
		choose = name_czech_subst_full[stem].choose;
 
		allow = name_czech_subst_full[stem].allow;
 
		gender = _name_czech_subst_full[stem].gender;
 
		choose = _name_czech_subst_full[stem].choose;
 
		allow = _name_czech_subst_full[stem].allow;
 
	} else {
 
		unsigned int map[lengthof(name_czech_subst_ending)];
 
		unsigned int map[lengthof(_name_czech_subst_ending)];
 
		int ending_start = -1, ending_stop = -1;
 
		int i;
 

	
 
		/* Load the substantive */
 
		dynamic_subst = true;
 
		stem -= lengthof(name_czech_subst_full);
 
		stem %= lengthof(name_czech_subst_stem);
 
		gender = name_czech_subst_stem[stem].gender;
 
		choose = name_czech_subst_stem[stem].choose;
 
		allow = name_czech_subst_stem[stem].allow;
 
		stem -= lengthof(_name_czech_subst_full);
 
		stem %= lengthof(_name_czech_subst_stem);
 
		gender = _name_czech_subst_stem[stem].gender;
 
		choose = _name_czech_subst_stem[stem].choose;
 
		allow = _name_czech_subst_stem[stem].allow;
 

	
 
		/* Load the postfix (1:1 chance that a postfix will be inserted) */
 
		postfix = SeedModChance(14, lengthof(name_czech_subst_postfix) * 2, seed);
 
		postfix = SeedModChance(14, lengthof(_name_czech_subst_postfix) * 2, seed);
 

	
 
		if (choose & CZC_POSTFIX) {
 
			/* Always get a real postfix. */
 
			postfix %= lengthof(name_czech_subst_postfix);
 
			postfix %= lengthof(_name_czech_subst_postfix);
 
		}
 
		if (choose & CZC_NOPOSTFIX) {
 
			/* Always drop a postfix. */
 
			postfix += lengthof(name_czech_subst_postfix);
 
			postfix += lengthof(_name_czech_subst_postfix);
 
		}
 
		if (postfix < lengthof(name_czech_subst_postfix)) {
 
		if (postfix < lengthof(_name_czech_subst_postfix)) {
 
			choose |= CZC_POSTFIX;
 
		} else {
 
			choose |= CZC_NOPOSTFIX;
 
		}
 

	
 
		/* Localize the array segment containing a good gender */
 
		for (ending = 0; ending < (int) lengthof(name_czech_subst_ending); ending++) {
 
			const CzechNameSubst *e = &name_czech_subst_ending[ending];
 
		for (ending = 0; ending < (int) lengthof(_name_czech_subst_ending); ending++) {
 
			const CzechNameSubst *e = &_name_czech_subst_ending[ending];
 

	
 
			if (gender == CZG_FREE ||
 
					(gender == CZG_NFREE && e->gender != CZG_SNEUT && e->gender != CZG_PNEUT) ||
 
@@ -452,7 +452,7 @@ static byte MakeCzechTownName(char *buf,
 
		/* Make a sequential map of the items with good mask */
 
		i = 0;
 
		for (ending = ending_start; ending <= ending_stop; ending++) {
 
			const CzechNameSubst *e = &name_czech_subst_ending[ending];
 
			const CzechNameSubst *e = &_name_czech_subst_ending[ending];
 

	
 
			if ((e->choose & choose) == choose && (e->allow & allow) != 0)
 
				map[i++] = ending;
 
@@ -463,11 +463,11 @@ static byte MakeCzechTownName(char *buf,
 
		ending = map[SeedModChance(16, i, seed)];
 
		/* Override possible CZG_*FREE; this must be a real gender,
 
		 * otherwise we get overflow when modifying the adjectivum. */
 
		gender = name_czech_subst_ending[ending].gender;
 
		gender = _name_czech_subst_ending[ending].gender;
 
		assert(gender != CZG_FREE && gender != CZG_NFREE);
 
	}
 

	
 
	if (do_prefix && (name_czech_adj[prefix].choose & choose) != choose) {
 
	if (do_prefix && (_name_czech_adj[prefix].choose & choose) != choose) {
 
		/* Throw away non-matching prefix. */
 
		do_prefix = false;
 
	}
 
@@ -475,10 +475,10 @@ static byte MakeCzechTownName(char *buf,
 
	/* Now finally construct the name */
 

	
 
	if (do_prefix) {
 
		CzechPattern pattern = name_czech_adj[prefix].pattern;
 
		CzechPattern pattern = _name_czech_adj[prefix].pattern;
 
		size_t endpos;
 

	
 
		strecat(buf, name_czech_adj[prefix].name, last);
 
		strecat(buf, _name_czech_adj[prefix].name, last);
 
		endpos = strlen(buf) - 1;
 
		/* Find the first character in a UTF-8 sequence */
 
		while (GB(buf[endpos], 6, 2) == 2) endpos--;
 
@@ -488,17 +488,17 @@ static byte MakeCzechTownName(char *buf,
 
			assert(buf[endpos - 1] == 'v');
 
			buf[endpos] = '\0';
 
		} else {
 
			strecpy(buf + endpos, name_czech_patmod[gender][pattern], last);
 
			strecpy(buf + endpos, _name_czech_patmod[gender][pattern], last);
 
		}
 

	
 
		strecat(buf, " ", last);
 
	}
 

	
 
	if (dynamic_subst) {
 
		strecat(buf, name_czech_subst_stem[stem].name, last);
 
		if (postfix < lengthof(name_czech_subst_postfix)) {
 
			const char *poststr = name_czech_subst_postfix[postfix];
 
			const char *endstr = name_czech_subst_ending[ending].name;
 
		strecat(buf, _name_czech_subst_stem[stem].name, last);
 
		if (postfix < lengthof(_name_czech_subst_postfix)) {
 
			const char *poststr = _name_czech_subst_postfix[postfix];
 
			const char *endstr = _name_czech_subst_ending[ending].name;
 
			size_t postlen, endlen;
 

	
 
			postlen = strlen(poststr);
 
@@ -524,14 +524,14 @@ static byte MakeCzechTownName(char *buf,
 
				}
 
			}
 
		}
 
		strecat(buf, name_czech_subst_ending[ending].name, last);
 
		strecat(buf, _name_czech_subst_ending[ending].name, last);
 
	} else {
 
		strecat(buf, name_czech_subst_full[stem].name, last);
 
		strecat(buf, _name_czech_subst_full[stem].name, last);
 
	}
 

	
 
	if (do_suffix) {
 
		strecat(buf, " ", last);
 
		strecat(buf, name_czech_suffix[suffix], last);
 
		strecat(buf, _name_czech_suffix[suffix], last);
 
	}
 

	
 
	return 0;
 
@@ -539,13 +539,13 @@ static byte MakeCzechTownName(char *buf,
 

	
 
static byte MakeRomanianTownName(char *buf, uint32 seed, const char *last)
 
{
 
	strecpy(buf, name_romanian_real[SeedChance(0, lengthof(name_romanian_real), seed)], last);
 
	strecpy(buf, _name_romanian_real[SeedChance(0, lengthof(_name_romanian_real), seed)], last);
 
	return 0;
 
}
 

	
 
static byte MakeSlovakTownName(char *buf, uint32 seed, const char *last)
 
{
 
	strecpy(buf, name_slovak_real[SeedChance(0, lengthof(name_slovak_real), seed)], last);
 
	strecpy(buf, _name_slovak_real[SeedChance(0, lengthof(_name_slovak_real), seed)], last);
 
	return 0;
 
}
 

	
 
@@ -557,12 +557,12 @@ static byte MakeNorwegianTownName(char *
 
	 * have a real name 3/16 chance.  Bit 0-3 */
 
	if (SeedChance(0, 15, seed) < 3) {
 
		/* Use 7bit for the realname table index.  Bit 4-10 */
 
		strecat(buf, name_norwegian_real[SeedChance(4, lengthof(name_norwegian_real), seed)], last);
 
		strecat(buf, _name_norwegian_real[SeedChance(4, lengthof(_name_norwegian_real), seed)], last);
 
	} else {
 
		/* Use 7bit for the first fake part.  Bit 4-10 */
 
		strecat(buf, name_norwegian_1[SeedChance(4, lengthof(name_norwegian_1), seed)], last);
 
		strecat(buf, _name_norwegian_1[SeedChance(4, lengthof(_name_norwegian_1), seed)], last);
 
		/* Use 7bit for the last fake part.  Bit 11-17 */
 
		strecat(buf, name_norwegian_2[SeedChance(11, lengthof(name_norwegian_2), seed)], last);
 
		strecat(buf, _name_norwegian_2[SeedChance(11, lengthof(_name_norwegian_2), seed)], last);
 
	}
 

	
 
	return 0;
 
@@ -576,21 +576,21 @@ static byte MakeHungarianTownName(char *
 
	strecpy(buf, "", last);
 

	
 
	if (SeedChance(12, 15, seed) < 3) {
 
		strecat(buf, name_hungarian_real[SeedChance(0, lengthof(name_hungarian_real), seed)], last);
 
		strecat(buf, _name_hungarian_real[SeedChance(0, lengthof(_name_hungarian_real), seed)], last);
 
	} else {
 
		/* optional first segment */
 
		i = SeedChance(3, lengthof(name_hungarian_1) * 3, seed);
 
		if (i < lengthof(name_hungarian_1))
 
			strecat(buf, name_hungarian_1[i], last);
 
		i = SeedChance(3, lengthof(_name_hungarian_1) * 3, seed);
 
		if (i < lengthof(_name_hungarian_1))
 
			strecat(buf, _name_hungarian_1[i], last);
 

	
 
		/* mandatory middle segments */
 
		strecat(buf, name_hungarian_2[SeedChance(3, lengthof(name_hungarian_2), seed)], last);
 
		strecat(buf, name_hungarian_3[SeedChance(6, lengthof(name_hungarian_3), seed)], last);
 
		strecat(buf, _name_hungarian_2[SeedChance(3, lengthof(_name_hungarian_2), seed)], last);
 
		strecat(buf, _name_hungarian_3[SeedChance(6, lengthof(_name_hungarian_3), seed)], last);
 

	
 
		/* optional last segment */
 
		i = SeedChance(10, lengthof(name_hungarian_4) * 3, seed);
 
		if (i < lengthof(name_hungarian_4)) {
 
			strecat(buf, name_hungarian_4[i], last);
 
		i = SeedChance(10, lengthof(_name_hungarian_4) * 3, seed);
 
		if (i < lengthof(_name_hungarian_4)) {
 
			strecat(buf, _name_hungarian_4[i], last);
 
		}
 
	}
 

	
 
@@ -599,7 +599,7 @@ static byte MakeHungarianTownName(char *
 

	
 
static byte MakeSwissTownName(char *buf, uint32 seed, const char *last)
 
{
 
	strecpy(buf, name_swiss_real[SeedChance(0, lengthof(name_swiss_real), seed)], last);
 
	strecpy(buf, _name_swiss_real[SeedChance(0, lengthof(_name_swiss_real), seed)], last);
 
	return 0;
 
}
 

	
 
@@ -611,13 +611,13 @@ static byte MakeDanishTownName(char *buf
 
	strecpy(buf, "", last);
 

	
 
	/* optional first segment */
 
	i = SeedChanceBias(0, lengthof(name_danish_1), seed, 50);
 
	i = SeedChanceBias(0, lengthof(_name_danish_1), seed, 50);
 
	if (i >= 0)
 
		strecat(buf, name_danish_1[i], last);
 
		strecat(buf, _name_danish_1[i], last);
 

	
 
	/* middle segments removed as this algorithm seems to create much more realistic names */
 
	strecat(buf, name_danish_2[SeedChance( 7, lengthof(name_danish_2), seed)], last);
 
	strecat(buf, name_danish_3[SeedChance(16, lengthof(name_danish_3), seed)], last);
 
	strecat(buf, _name_danish_2[SeedChance( 7, lengthof(_name_danish_2), seed)], last);
 
	strecat(buf, _name_danish_3[SeedChance(16, lengthof(_name_danish_3), seed)], last);
 

	
 
	return 0;
 
}
 
@@ -630,21 +630,21 @@ static byte MakeTurkishTownName(char *bu
 
	strecpy(buf, "", last);
 

	
 
	if ((i = SeedModChance(0, 5, seed)) == 0) {
 
		strecat(buf, name_turkish_prefix[SeedModChance( 2, lengthof(name_turkish_prefix), seed)], last);
 
		strecat(buf, _name_turkish_prefix[SeedModChance( 2, lengthof(_name_turkish_prefix), seed)], last);
 

	
 
		/* middle segment */
 
		strecat(buf, name_turkish_middle[SeedModChance( 4, lengthof(name_turkish_middle), seed)], last);
 
		strecat(buf, _name_turkish_middle[SeedModChance( 4, lengthof(_name_turkish_middle), seed)], last);
 

	
 
		/* optional suffix */
 
		if (SeedModChance(0, 7, seed) == 0) {
 
			strecat(buf, name_turkish_suffix[SeedModChance( 10, lengthof(name_turkish_suffix), seed)], last);
 
			strecat(buf, _name_turkish_suffix[SeedModChance( 10, lengthof(_name_turkish_suffix), seed)], last);
 
		}
 
	} else {
 
		if (i == 1 || i == 2) {
 
			strecat(buf, name_turkish_prefix[SeedModChance( 2, lengthof(name_turkish_prefix), seed)], last);
 
			strecat(buf, name_turkish_suffix[SeedModChance( 4, lengthof(name_turkish_suffix), seed)], last);
 
			strecat(buf, _name_turkish_prefix[SeedModChance( 2, lengthof(_name_turkish_prefix), seed)], last);
 
			strecat(buf, _name_turkish_suffix[SeedModChance( 4, lengthof(_name_turkish_suffix), seed)], last);
 
		} else {
 
			strecat(buf, name_turkish_real[SeedModChance( 4, lengthof(name_turkish_real), seed)], last);
 
			strecat(buf, _name_turkish_real[SeedModChance( 4, lengthof(_name_turkish_real), seed)], last);
 
		}
 
	}
 
	return 0;
 
@@ -660,34 +660,34 @@ static byte MakeItalianTownName(char *bu
 
	strecpy(buf, "", last);
 

	
 
	if (SeedModChance(0, 6, seed) == 0) { // real city names
 
		strecat(buf, name_italian_real[SeedModChance(4, lengthof(name_italian_real), seed)], last);
 
		strecat(buf, _name_italian_real[SeedModChance(4, lengthof(_name_italian_real), seed)], last);
 
	} else {
 
		uint i;
 

	
 
		if (SeedModChance(0, 8, seed) == 0) { // prefix
 
			strecat(buf, name_italian_pref[SeedModChance(11, lengthof(name_italian_pref), seed)], last);
 
			strecat(buf, _name_italian_pref[SeedModChance(11, lengthof(_name_italian_pref), seed)], last);
 
		}
 

	
 
		i = SeedChance(0, 2, seed);
 
		if (i == 0) { // masculine form
 
			strecat(buf, name_italian_1m[SeedModChance(4, lengthof(name_italian_1m), seed)], last);
 
			strecat(buf, _name_italian_1m[SeedModChance(4, lengthof(_name_italian_1m), seed)], last);
 
		} else { // feminine form
 
			strecat(buf, name_italian_1f[SeedModChance(4, lengthof(name_italian_1f), seed)], last);
 
			strecat(buf, _name_italian_1f[SeedModChance(4, lengthof(_name_italian_1f), seed)], last);
 
		}
 

	
 
		if (SeedModChance(3, 3, seed) == 0) {
 
			strecat(buf, name_italian_2[SeedModChance(11, lengthof(name_italian_2), seed)], last);
 
			strecat(buf, _name_italian_2[SeedModChance(11, lengthof(_name_italian_2), seed)], last);
 
			strecat(buf, mascul_femin_italian[i], last);
 
		} else {
 
			strecat(buf, name_italian_2i[SeedModChance(16, lengthof(name_italian_2i), seed)], last);
 
			strecat(buf, _name_italian_2i[SeedModChance(16, lengthof(_name_italian_2i), seed)], last);
 
		}
 

	
 
		if (SeedModChance(15, 4, seed) == 0) {
 
			if (SeedModChance(5, 2, seed) == 0) { // generic suffix
 
				strecat(buf, name_italian_3[SeedModChance(4, lengthof(name_italian_3), seed)], last);
 
				strecat(buf, _name_italian_3[SeedModChance(4, lengthof(_name_italian_3), seed)], last);
 
			} else { // river name suffix
 
				strecat(buf, name_italian_river1[SeedModChance(4, lengthof(name_italian_river1), seed)], last);
 
				strecat(buf, name_italian_river2[SeedModChance(16, lengthof(name_italian_river2), seed)], last);
 
				strecat(buf, _name_italian_river1[SeedModChance(4, lengthof(_name_italian_river1), seed)], last);
 
				strecat(buf, _name_italian_river2[SeedModChance(16, lengthof(_name_italian_river2), seed)], last);
 
			}
 
		}
 
	}
 
@@ -700,29 +700,29 @@ static byte MakeCatalanTownName(char *bu
 
	strecpy(buf, "", last);
 

	
 
	if (SeedModChance(0, 3, seed) == 0) { // real city names
 
		strecat(buf, name_catalan_real[SeedModChance(4, lengthof(name_catalan_real), seed)], last);
 
		strecat(buf, _name_catalan_real[SeedModChance(4, lengthof(_name_catalan_real), seed)], last);
 
	} else {
 
		uint i;
 

	
 
		if (SeedModChance(0, 2, seed) == 0) { // prefix
 
			strecat(buf, name_catalan_pref[SeedModChance(11, lengthof(name_catalan_pref), seed)], last);
 
			strecat(buf, _name_catalan_pref[SeedModChance(11, lengthof(_name_catalan_pref), seed)], last);
 
		}
 

	
 
		i = SeedChance(0, 2, seed);
 
		if (i == 0) { // masculine form
 
			strecat(buf, name_catalan_1m[SeedModChance(4, lengthof(name_catalan_1m), seed)], last);
 
			strecat(buf, name_catalan_2m[SeedModChance(11, lengthof(name_catalan_2m), seed)], last);
 
			strecat(buf, _name_catalan_1m[SeedModChance(4, lengthof(_name_catalan_1m), seed)], last);
 
			strecat(buf, _name_catalan_2m[SeedModChance(11, lengthof(_name_catalan_2m), seed)], last);
 
		} else { // feminine form
 
			strecat(buf, name_catalan_1f[SeedModChance(4, lengthof(name_catalan_1f), seed)], last);
 
			strecat(buf, name_catalan_2f[SeedModChance(11, lengthof(name_catalan_2f), seed)], last);
 
			strecat(buf, _name_catalan_1f[SeedModChance(4, lengthof(_name_catalan_1f), seed)], last);
 
			strecat(buf, _name_catalan_2f[SeedModChance(11, lengthof(_name_catalan_2f), seed)], last);
 
		}
 

	
 

	
 
		if (SeedModChance(15, 5, seed) == 0) {
 
			if (SeedModChance(5, 2, seed) == 0) { // generic suffix
 
				strecat(buf, name_catalan_3[SeedModChance(4, lengthof(name_catalan_3), seed)], last);
 
				strecat(buf, _name_catalan_3[SeedModChance(4, lengthof(_name_catalan_3), seed)], last);
 
			} else { // river name suffix
 
				strecat(buf, name_catalan_river1[SeedModChance(4, lengthof(name_catalan_river1), seed)], last);
 
				strecat(buf, _name_catalan_river1[SeedModChance(4, lengthof(_name_catalan_river1), seed)], last);
 
			}
 
		}
 
	}
src/saveload/oldloader_sl.cpp
Show inline comments
 
@@ -108,7 +108,7 @@ static uint32 RemapOldTownName(uint32 to
 
		case 1: // French
 
			/* For some reason 86 needs to be subtracted from townnameparts
 
			 * 0000 0000 0000 0000 0000 0000 1111 1111 */
 
			return FIXNUM(townnameparts - 86, lengthof(name_french_real), 0);
 
			return FIXNUM(townnameparts - 86, lengthof(_name_french_real), 0);
 

	
 
		case 2: // German
 
			DEBUG(misc, 0, "German Townnames are buggy (%d)", townnameparts);
 
@@ -116,13 +116,13 @@ static uint32 RemapOldTownName(uint32 to
 

	
 
		case 4: // Latin-American
 
			/* 0000 0000 0000 0000 0000 0000 1111 1111 */
 
			return FIXNUM(townnameparts, lengthof(name_spanish_real), 0);
 
			return FIXNUM(townnameparts, lengthof(_name_spanish_real), 0);
 

	
 
		case 5: // Silly
 
			/* NUM_SILLY_1 - lower 16 bits
 
			 * NUM_SILLY_2 - upper 16 bits without leading 1 (first 8 bytes)
 
			 * 1000 0000 2222 2222 0000 0000 1111 1111 */
 
			return FIXNUM(townnameparts, lengthof(name_silly_1), 0) | FIXNUM(GB(townnameparts, 16, 8), lengthof(name_silly_2), 16);
 
			return FIXNUM(townnameparts, lengthof(_name_silly_1), 0) | FIXNUM(GB(townnameparts, 16, 8), lengthof(_name_silly_2), 16);
 
	}
 
	return 0;
 
}
src/table/namegen.h
Show inline comments
 
@@ -4,14 +4,14 @@
 

	
 
#include "../core/enum_type.hpp"
 

	
 
static const char * const name_original_english_1[] = {
 
static const char * const _name_original_english_1[] = {
 
	"Great ",
 
	"Little ",
 
	"New ",
 
	"Fort ",
 
};
 

	
 
static const char * const name_original_english_2[] = {
 
static const char * const _name_original_english_2[] = {
 
	"Wr",
 
	"B",
 
	"C",
 
@@ -37,10 +37,10 @@ static const char * const name_original_
 
	"Sl",
 
	"T",
 
	"Tr",
 
	"W"
 
	"W",
 
};
 

	
 
static const char * const name_original_english_3[] = {
 
static const char * const _name_original_english_3[] = {
 
	"ar",
 
	"a",
 
	"e",
 
@@ -48,20 +48,20 @@ static const char * const name_original_
 
	"on",
 
	"u",
 
	"un",
 
	"en"
 
	"en",
 
};
 

	
 
static const char * const name_original_english_4[] = {
 
static const char * const _name_original_english_4[] = {
 
	"n",
 
	"ning",
 
	"ding",
 
	"d",
 
	"",
 
	"t"
 
	"fing"
 
	"t",
 
	"fing",
 
};
 

	
 
static const char * const name_original_english_5[] = {
 
static const char * const _name_original_english_5[] = {
 
	"ville",
 
	"ham",
 
	"field",
 
@@ -87,7 +87,7 @@ static const char * const name_original_
 
	"burg",
 
};
 

	
 
static const char * const name_original_english_6[] = {
 
static const char * const _name_original_english_6[] = {
 
	"-on-sea",
 
	" Bay",
 
	" Market",
 
@@ -96,19 +96,19 @@ static const char * const name_original_
 
	" Falls",
 
	" City",
 
	" Ridge",
 
	" Springs"
 
	" Springs",
 
};
 

	
 
static const char * const name_additional_english_prefix[] = {
 
static const char * const _name_additional_english_prefix[] = {
 
	"Great ",
 
	"Little ",
 
	"New ",
 
	"Fort ",
 
	"St. ",
 
	"Old "
 
	"Old ",
 
};
 

	
 
static const char * const name_additional_english_1a[] = {
 
static const char * const _name_additional_english_1a[] = {
 
	"Pen",
 
	"Lough",
 
	"Stam",
 
@@ -151,10 +151,10 @@ static const char * const name_additiona
 
	"Worm",
 
	"Tyne",
 
	"Avon",
 
	"Stan"
 
	"Stan",
 
};
 

	
 
static const char * const name_additional_english_1b1[] = {
 
static const char * const _name_additional_english_1b1[] = {
 
	"Wr",
 
	"B",
 
	"C",
 
@@ -180,10 +180,10 @@ static const char * const name_additiona
 
	"Sl",
 
	"T",
 
	"Tr",
 
	"W"
 
	"W",
 
};
 

	
 
static const char * const name_additional_english_1b2[] = {
 
static const char * const _name_additional_english_1b2[] = {
 
	"ar",
 
	"a",
 
	"e",
 
@@ -195,25 +195,25 @@ static const char * const name_additiona
 
	"es",
 
	"ea",
 
	"un",
 
	"en"
 
	"en",
 
};
 

	
 
static const char * const name_additional_english_1b3a[] = {
 
static const char * const _name_additional_english_1b3a[] = {
 
	"n",
 
	"d",
 
	"",
 
	"t",
 
	"",
 
	""
 
	"",
 
};
 

	
 
static const char * const name_additional_english_1b3b[] = {
 
static const char * const _name_additional_english_1b3b[] = {
 
	"ning",
 
	"ding",
 
	"fing"
 
	"fing",
 
};
 

	
 
static const char * const name_additional_english_2[] = {
 
static const char * const _name_additional_english_2[] = {
 
	"ville",
 
	"ham",
 
	"field",
 
@@ -268,10 +268,10 @@ static const char * const name_additiona
 
	"dale",
 
	"ness",
 
	"shaw",
 
	"thwaite"
 
	"thwaite",
 
};
 

	
 
static const char * const name_additional_english_3[] = {
 
static const char * const _name_additional_english_3[] = {
 
	"-on-sea",
 
	" Bay",
 
	" Market",
 
@@ -289,19 +289,19 @@ static const char * const name_additiona
 
	" Falls",
 
	" City",
 
	" Ridge",
 
	" Springs"
 
	" Springs",
 
};
 

	
 
static const char * const name_austrian_a1[] = {
 
static const char * const _name_austrian_a1[] = {
 
	"Bad ",
 
	"Deutsch ",
 
	"Gross ",
 
	"Klein ",
 
	"Markt ",
 
	"Maria "
 
	"Maria ",
 
};
 

	
 
static const char * const name_austrian_a2[] = {
 
static const char * const _name_austrian_a2[] = {
 
	"Aus",
 
	"Alten",
 
	"Braun",
 
@@ -343,10 +343,10 @@ static const char * const name_austrian_
 
	"Utten",
 
	"Vösen",
 
	"Vill",
 
	"Weissen"
 
	"Weissen",
 
};
 

	
 
static const char * const name_austrian_a3[] = {
 
static const char * const _name_austrian_a3[] = {
 
	"see",
 
	"bach",
 
	"dorf",
 
@@ -362,10 +362,10 @@ static const char * const name_austrian_
 
	"siedl",
 
	"markt",
 
	"wang",
 
	"haag"
 
	"haag",
 
};
 

	
 
static const char * const name_austrian_a4[] = {
 
static const char * const _name_austrian_a4[] = {
 
	"Bruck",
 
	"Brunn",
 
	"Gams",
 
@@ -377,15 +377,15 @@ static const char * const name_austrian_
 
	"Kirchberg",
 
	"Saal",
 
	"Taferl",
 
	"Wald"
 
	"Wald",
 
};
 

	
 
static const char * const name_austrian_a5[] = {
 
static const char * const _name_austrian_a5[] = {
 
	"St. ",
 
	"Sankt "
 
	"Sankt ",
 
};
 

	
 
static const char * const name_austrian_a6[] = {
 
static const char * const _name_austrian_a6[] = {
 
	"Aegyd",
 
	"Andrä",
 
	"Georgen",
 
@@ -405,15 +405,15 @@ static const char * const name_austrian_
 
	"Stephan",
 
	"Thomas",
 
	"Veit",
 
	"Wolfgang"
 
	"Wolfgang",
 
};
 

	
 
static const char * const name_austrian_f1[] = {
 
static const char * const _name_austrian_f1[] = {
 
	" an der ",
 
	" ob der "
 
	" ob der ",
 
};
 

	
 
static const char * const name_austrian_f2[] = {
 
static const char * const _name_austrian_f2[] = {
 
	"Donau",
 
	"Steyr",
 
	"Lafnitz",
 
@@ -426,14 +426,14 @@ static const char * const name_austrian_
 
	"Traisen",
 
	"Enns",
 
	"Mur",
 
	"Ill"
 
	"Ill",
 
};
 

	
 
static const char * const name_austrian_b1[] = {
 
	" am "
 
static const char * const _name_austrian_b1[] = {
 
	" am ",
 
};
 

	
 
static const char * const name_austrian_b2[] = {
 
static const char * const _name_austrian_b2[] = {
 
	"Brenner",
 
	"Dachstein",
 
	"Gebirge",
 
@@ -443,10 +443,10 @@ static const char * const name_austrian_
 
	"Wagram",
 
	"Wechsel",
 
	"Wilden Kaiser",
 
	"Ziller"
 
	"Ziller",
 
};
 

	
 
static const char * const name_german_real[] = {
 
static const char * const _name_german_real[] = {
 
	"Berlin",
 
	"Bonn",
 
	"Bremen",
 
@@ -467,16 +467,16 @@ static const char * const name_german_re
 
	"München",
 
	"Potsdam",
 
	"Stuttgart",
 
	"Wiesbaden"
 
	"Wiesbaden",
 
};
 

	
 
static const char * const name_german_pre[] = {
 
static const char * const _name_german_pre[] = {
 
	"Bad ",
 
	"Klein ",
 
	"Neu "
 
	"Neu ",
 
};
 

	
 
static const char * const name_german_1[] = {
 
static const char * const _name_german_1[] = {
 
	"Alb",
 
	"Als",
 
	"Ander",
 
@@ -569,10 +569,10 @@ static const char * const name_german_1[
 
	"Wester",
 
	"Witten",
 
	"Wolfs",
 
	"Würz"
 
	"Würz",
 
};
 

	
 
static const char * const name_german_2[] = {
 
static const char * const _name_german_2[] = {
 
	"bach",
 
	"berg",
 
	"brück",
 
@@ -588,30 +588,30 @@ static const char * const name_german_2[
 
	"mund",
 
	"münster",
 
	"stadt",
 
	"wald"
 
	"wald",
 
};
 

	
 
static const char * const name_german_3_an_der[] = {
 
	" an der "
 
static const char * const _name_german_3_an_der[] = {
 
	" an der ",
 
};
 

	
 
static const char * const name_german_3_am[] = {
 
	" am "
 
static const char * const _name_german_3_am[] = {
 
	" am ",
 
};
 

	
 
static const char * const name_german_4_an_der[] = {
 
static const char * const _name_german_4_an_der[] = {
 
	"Oder",
 
	"Spree",
 
	"Donau",
 
	"Saale",
 
	"Elbe"
 
	"Elbe",
 
};
 

	
 
static const char * const name_german_4_am[] = {
 
	"Main"
 
static const char * const _name_german_4_am[] = {
 
	"Main",
 
};
 

	
 
static const char * const name_spanish_real[] = {
 
static const char * const _name_spanish_real[] = {
 
	"Caracas",
 
	"Maracay",
 
	"Maracaibo",
 
@@ -697,10 +697,10 @@ static const char * const name_spanish_r
 
	"Temuco",
 
	"Tocopilla",
 
	"Mendoza",
 
	"Santa Rosa"
 
	"Santa Rosa",
 
};
 

	
 
static const char * const name_french_real[] = {
 
static const char * const _name_french_real[] = {
 
	"Agincourt",
 
	"Lille",
 
	"Dinan",
 
@@ -770,10 +770,10 @@ static const char * const name_french_re
 
	"Nîmes",
 
	"Chamonix",
 
	"Angoulème",
 
	"Alençon"
 
	"Alençon",
 
};
 

	
 
static const char * const name_silly_1[] = {
 
static const char * const _name_silly_1[] = {
 
	"Binky",
 
	"Blubber",
 
	"Bumble",
 
@@ -861,10 +861,10 @@ static const char * const name_silly_1[]
 
	"Fishy",
 
	"Fizzle",
 
	"Frosty",
 
	"Griddle"
 
	"Griddle",
 
};
 

	
 
static const char * const name_silly_2[] = {
 
static const char * const _name_silly_2[] = {
 
	"ton",
 
	"bury",
 
	"bottom",
 
@@ -879,17 +879,17 @@ static const char * const name_silly_2[]
 
	"head",
 
	"burg",
 
	"gate",
 
	"bridge"
 
	"bridge",
 
};
 

	
 
static const char * const name_swedish_1[] = {
 
static const char * const _name_swedish_1[] = {
 
	"Gamla ",
 
	"Lilla ",
 
	"Nya ",
 
	"Stora "
 
	"Stora ",
 
};
 

	
 
static const char * const name_swedish_2[] = {
 
static const char * const _name_swedish_2[] = {
 
	"Boll",
 
	"Bor",
 
	"Ed",
 
@@ -927,10 +927,10 @@ static const char * const name_swedish_2
 
	"Var",
 
	"Väster",
 
	"Ängel",
 
	"Öster"
 
	"Öster",
 
};
 

	
 
static const char * const name_swedish_2a[] = {
 
static const char * const _name_swedish_2a[] = {
 
	"B",
 
	"Br",
 
	"D",
 
@@ -972,10 +972,10 @@ static const char * const name_swedish_2
 
	"Tr",
 
	"Tv",
 
	"V",
 
	"Vr"
 
	"Vr",
 
};
 

	
 
static const char * const name_swedish_2b[] = {
 
static const char * const _name_swedish_2b[] = {
 
	"a",
 
	"e",
 
	"i",
 
@@ -984,10 +984,10 @@ static const char * const name_swedish_2
 
	"y",
 
	"å",
 
	"ä",
 
	"ö"
 
	"ö",
 
};
 

	
 
static const char * const name_swedish_2c[] = {
 
static const char * const _name_swedish_2c[] = {
 
	"ck",
 
	"d",
 
	"dd",
 
@@ -1013,10 +1013,10 @@ static const char * const name_swedish_2
 
	"st",
 
	"t",
 
	"tt",
 
	"v"
 
	"v",
 
};
 

	
 
static const char * const name_swedish_3[] = {
 
static const char * const _name_swedish_3[] = {
 
	"arp",
 
	"berg",
 
	"boda",
 
@@ -1048,10 +1048,10 @@ static const char * const name_swedish_3
 
	"valla",
 
	"viken",
 
	"älv",
 
	"ås"
 
	"ås",
 
};
 

	
 
static const char * const name_dutch_1[] = {
 
static const char * const _name_dutch_1[] = {
 
	"Nieuw ",
 
	"Oud ",
 
	"Groot ",
 
@@ -1059,10 +1059,10 @@ static const char * const name_dutch_1[]
 
	"Noord ",
 
	"Oost ",
 
	"West ",
 
	"Klein "
 
	"Klein ",
 
};
 

	
 
static const char * const name_dutch_2[] = {
 
static const char * const _name_dutch_2[] = {
 
	"Hoog",
 
	"Laag",
 
	"Zuider",
 
@@ -1115,10 +1115,10 @@ static const char * const name_dutch_2[]
 
	"Haar",
 
	"Til",
 
	"Loos",
 
	"Hil"
 
	"Hil",
 
};
 

	
 
static const char * const name_dutch_3[] = {
 
static const char * const _name_dutch_3[] = {
 
	"Drog",
 
	"Nat",
 
	"Valk",
 
@@ -1138,19 +1138,19 @@ static const char * const name_dutch_3[]
 
	"Vink",
 
	"Wams",
 
	"Heerhug",
 
	"Koning"
 
	"Koning",
 
};
 

	
 
static const char * const name_dutch_4[] = {
 
static const char * const _name_dutch_4[] = {
 
	"e",
 
	"er",
 
	"el",
 
	"en",
 
	"o",
 
	"s"
 
	"s",
 
};
 

	
 
static const char * const name_dutch_5[] = {
 
static const char * const _name_dutch_5[] = {
 
	"stad",
 
	"vorst",
 
	"dorp",
 
@@ -1206,10 +1206,10 @@ static const char * const name_dutch_5[]
 
	"bergen",
 
	"schede",
 
	"mere",
 
	"end"
 
	"end",
 
};
 

	
 
static const char * const name_finnish_real[] = {
 
static const char * const _name_finnish_real[] = {
 
	"Aijala",
 
	"Kisko",
 
	"Espoo",
 
@@ -1240,10 +1240,10 @@ static const char * const name_finnish_r
 
	"Pori",
 
	"Rauma",
 
	"Kolari",
 
	"Lieksa"
 
	"Lieksa",
 
};
 

	
 
static const char * const name_finnish_1[] = {
 
static const char * const _name_finnish_1[] = {
 
	"Hiekka",
 
	"Haapa",
 
	"Mylly",
 
@@ -1270,10 +1270,10 @@ static const char * const name_finnish_1
 
	"Kivi",
 
	"Riihi",
 
	"Ääne",
 
	"Niini"
 
	"Niini",
 
};
 

	
 
static const char * const name_finnish_2[] = {
 
static const char * const _name_finnish_2[] = {
 
	"Lappeen",
 
	"Lohjan",
 
	"Savon",
 
@@ -1284,10 +1284,10 @@ static const char * const name_finnish_2
 
	"Kemi",
 
	"Keri",
 
	"Hämeen",
 
	"Kangas"
 
	"Kangas",
 
};
 

	
 
static const char * const name_finnish_3[] = {
 
static const char * const _name_finnish_3[] = {
 
	"harju",
 
	"linna",
 
	"järvi",
 
@@ -1306,10 +1306,10 @@ static const char * const name_finnish_3
 
	"hovi",
 
	"ranta",
 
	"koski",
 
	"salo"
 
	"salo",
 
};
 

	
 
static const char * const name_polish_1_m[] = {
 
static const char * const _name_polish_1_m[] = {
 
	"Wielki ",
 
	"Mały ",
 
	"Zły ",
 
@@ -1320,10 +1320,10 @@ static const char * const name_polish_1_
 
	"Zielony ",
 
	"Biały ",
 
	"Modry ",
 
	"Dębowy "
 
	"Dębowy ",
 
};
 

	
 
static const char * const name_polish_1_f[] = {
 
static const char * const _name_polish_1_f[] = {
 
	"Wielka ",
 
	"Mała ",
 
	"Zła ",
 
@@ -1334,10 +1334,10 @@ static const char * const name_polish_1_
 
	"Zielona ",
 
	"Biała ",
 
	"Modra ",
 
	"Dębowa "
 
	"Dębowa ",
 
};
 

	
 
static const char * const name_polish_1_n[] = {
 
static const char * const _name_polish_1_n[] = {
 
	"Wielkie ",
 
	"Małe ",
 
	"Złe ",
 
@@ -1348,10 +1348,10 @@ static const char * const name_polish_1_
 
	"Zielone ",
 
	"Białe ",
 
	"Modre ",
 
	"Dębowe "
 
	"Dębowe ",
 
};
 

	
 
static const char * const name_polish_2_o[] = {
 
static const char * const _name_polish_2_o[] = {
 
	"Frombork",
 
	"Gniezno",
 
	"Olsztyn",
 
@@ -1385,10 +1385,10 @@ static const char * const name_polish_2_
 
	"Chojnice",
 
	"Ostrowiec",
 
	"Otwock",
 
	"Wolsztyn"
 
	"Wolsztyn",
 
};
 

	
 
static const char * const name_polish_2_m[] = {
 
static const char * const _name_polish_2_m[] = {
 
	"Jarocin",
 
	"Gogolin",
 
	"Tomaszów",
 
@@ -1436,10 +1436,10 @@ static const char * const name_polish_2_
 
	"Zgierz",
 
	"Zieleniec",
 
	"Drobin",
 
	"Garwolin"
 
	"Garwolin",
 
};
 

	
 
static const char * const name_polish_2_f[] = {
 
static const char * const _name_polish_2_f[] = {
 
	"Szprotawa",
 
	"Pogorzelica",
 
	"Motława",
 
@@ -1467,10 +1467,10 @@ static const char * const name_polish_2_
 
	"Limanowa",
 
	"Rabka",
 
	"Skawina",
 
	"Pilawa"
 
	"Pilawa",
 
};
 

	
 
static const char * const name_polish_2_n[] = {
 
static const char * const _name_polish_2_n[] = {
 
	"Lipsko",
 
	"Pilzno",
 
	"Przodkowo",
 
@@ -1500,10 +1500,10 @@ static const char * const name_polish_2_
 
	"Gryfino",
 
	"Koronowo",
 
	"Lubichowo",
 
	"Opoczno"
 
	"Opoczno",
 
};
 

	
 
static const char * const name_polish_3_m[] = {
 
static const char * const _name_polish_3_m[] = {
 
	" Wybudowanie",
 
	" Świętokrzyski",
 
	" Górski",
 
@@ -1532,10 +1532,10 @@ static const char * const name_polish_3_
 
	" Kujawski",
 
	" Małopolski",
 
	" Podlaski",
 
	" Lesny"
 
	" Lesny",
 
};
 

	
 
static const char * const name_polish_3_f[] = {
 
static const char * const _name_polish_3_f[] = {
 
	" Wybudowanie",
 
	" Świętokrzyska",
 
	" Górska",
 
@@ -1564,10 +1564,10 @@ static const char * const name_polish_3_
 
	" Kujawska",
 
	" Malopolska",
 
	" Podlaska",
 
	" Leśna"
 
	" Leśna",
 
};
 

	
 
static const char * const name_polish_3_n[] = {
 
static const char * const _name_polish_3_n[] = {
 
	" Wybudowanie",
 
	" Świetokrzyskie",
 
	" Górskie",
 
@@ -1596,10 +1596,10 @@ static const char * const name_polish_3_
 
	" Kujawskie",
 
	" Małopolskie",
 
	" Podlaskie",
 
	" Leśne"
 
	" Leśne",
 
};
 

	
 
static const char * const name_czech_real[] = {
 
static const char * const _name_czech_real[] = {
 
	"Aš",
 
	"Benešov",
 
	"Beroun",
 
@@ -1681,7 +1681,7 @@ static const char * const name_czech_rea
 
	"Vyškov",
 
	"Žďár nad Sázavou",
 
	"Zlín",
 
	"Znojmo"
 
	"Znojmo",
 
};
 

	
 

	
 
@@ -1713,7 +1713,7 @@ enum CzechPattern {
 
/* [CzechGender][CzechPattern] - replaces the last character of the adjective
 
 * by this.
 
 * XXX: [CZG_SMASC][CZP_PRIVL] needs special handling: -ovX -> -uv. */
 
static const char * const name_czech_patmod[][3] = {
 
static const char * const _name_czech_patmod[][3] = {
 
	/* CZG_SMASC */ { "í", "ý", "X" },
 
	/* CZG_SFEM */  { "í", "á", "a" },
 
	/* CZG_SNEUT */ { "í", "é", "o" },
 
@@ -1758,7 +1758,7 @@ struct CzechNameAdj {
 
};
 

	
 
/* Some of items which should be common are doubled. */
 
static const CzechNameAdj name_czech_adj[] = {
 
static const CzechNameAdj _name_czech_adj[] = {
 
	{ CZP_JARNI, CZC_ANY, "Horní" },
 
	{ CZP_JARNI, CZC_ANY, "Horní" },
 
	{ CZP_JARNI, CZC_ANY, "Dolní" },
 
@@ -1810,7 +1810,7 @@ static const CzechNameAdj name_czech_adj
 
};
 

	
 
/* Considered a stem for choose/allow matching purposes. */
 
static const CzechNameSubst name_czech_subst_full[] = {
 
static const CzechNameSubst _name_czech_subst_full[] = {
 
	{ CZG_SMASC, CZA_ALL, CZC_COLOR, "Sedlec" },
 
	{ CZG_SMASC, CZA_ALL, CZC_COLOR, "Brod" },
 
	{ CZG_SMASC, CZA_ALL, CZC_COLOR, "Brod" },
 
@@ -1830,7 +1830,7 @@ static const CzechNameSubst name_czech_s
 
};
 

	
 
/* TODO: More stems needed. --pasky */
 
static const CzechNameSubst name_czech_subst_stem[] = {
 
static const CzechNameSubst _name_czech_subst_stem[] = {
 
	{ CZG_SMASC,             CZA_MIDDLE,            CZC_COLOR, "Kostel" },
 
	{ CZG_SMASC,             CZA_MIDDLE,            CZC_COLOR, "Klášter" },
 
	{ CZG_SMASC, CZA_SHORT,                         CZC_COLOR, "Lhot" },
 
@@ -1876,14 +1876,14 @@ static const CzechNameSubst name_czech_s
 
};
 

	
 
/* Optional postfix inserted between stem and ending. */
 
static const char * const name_czech_subst_postfix[] = {
 
static const char * const _name_czech_subst_postfix[] = {
 
	"av", "an", "at",
 
	"ov", "on", "ot",
 
	"ev", "en", "et",
 
};
 

	
 
/* This array must have the both neutral genders at the end! */
 
static const CzechNameSubst name_czech_subst_ending[] = {
 
static const CzechNameSubst _name_czech_subst_ending[] = {
 
	{ CZG_SMASC, CZA_SHORT | CZA_MIDDLE,            CZC_ANY, "ec" },
 
	{ CZG_SMASC, CZA_SHORT | CZA_MIDDLE,            CZC_ANY, "ín" },
 
	{ CZG_SMASC, CZA_SHORT | CZA_MIDDLE | CZA_LONG, CZC_ANY, "ov" },
 
@@ -1906,7 +1906,7 @@ static const CzechNameSubst name_czech_s
 
	{ CZG_SNEUT,                          CZA_LONG, CZC_ANY, "iště" },
 
};
 

	
 
static const char * const name_czech_suffix[] = {
 
static const char * const _name_czech_suffix[] = {
 
	"nad Cidlinou",
 
	"nad Dyjí",
 
	"nad Jihlavou",
 
@@ -1930,7 +1930,7 @@ static const char * const name_czech_suf
 

	
 

	
 

	
 
static const char * const name_romanian_real[] = {
 
static const char * const _name_romanian_real[] = {
 
	"Adjud",
 
	"Alba Iulia",
 
	"Alexandria",
 
@@ -2024,10 +2024,10 @@ static const char * const name_romanian_
 
	"Vatra Dornei",
 
	"Victoria",
 
	"Videle",
 
	"Zalãu"
 
	"Zalãu",
 
};
 

	
 
static const char * const name_slovak_real[] = {
 
static const char * const _name_slovak_real[] = {
 
	"Bratislava",
 
	"Banovce nad Bebravou",
 
	"Banska Bystrica",
 
@@ -2114,10 +2114,10 @@ static const char * const name_slovak_re
 
	"Ziar nad Hronom",
 
	"Zilina",
 
	"Zlate Moravce",
 
	"Zvolen"
 
	"Zvolen",
 
};
 

	
 
static const char * const name_norwegian_1[] = {
 
static const char * const _name_norwegian_1[] = {
 
	"Arna",
 
	"Aust",
 
	"Bjørk",
 
@@ -2201,10 +2201,10 @@ static const char * const name_norwegian
 
	"Vest",
 
	"Vesle",
 
	"Vik",
 
	"Våg"
 
	"Våg",
 
};
 

	
 
static const char * const name_norwegian_2[] = {
 
static const char * const _name_norwegian_2[] = {
 
	"aker",
 
	"anger",
 
	"bakken",
 
@@ -2271,10 +2271,10 @@ static const char * const name_norwegian
 
	"voll",
 
	"våg",
 
	"um",
 
	"åsen"
 
	"åsen",
 
};
 

	
 
static const char * const name_norwegian_real[] = {
 
static const char * const _name_norwegian_real[] = {
 
	"Alta",
 
	"Arendal",
 
	"Askim",
 
@@ -2368,18 +2368,18 @@ static const char * const name_norwegian
 
	"Verdalsøra",
 
	"Åkrehamn",
 
	"Ålesund",
 
	"Åndalsnes"
 
	"Åndalsnes",
 
};
 

	
 
static const char * const name_hungarian_1[] = {
 
static const char * const _name_hungarian_1[] = {
 
	"Nagy-",
 
	"Kis-",
 
	"Felső-",
 
	"Alsó-",
 
	"Új-"
 
	"Új-",
 
};
 

	
 
static const char * const name_hungarian_2[] = {
 
static const char * const _name_hungarian_2[] = {
 
	"Bodrog",
 
	"Dráva",
 
	"Duna",
 
@@ -2433,10 +2433,10 @@ static const char * const name_hungarian
 
	"Torna",
 
	"Vas",
 
	"Vámos",
 
	"Vásáros"
 
	"Vásáros",
 
};
 

	
 
static const char * const name_hungarian_3[] = {
 
static const char * const _name_hungarian_3[] = {
 
	"apáti",
 
	"bába",
 
	"bikk",
 
@@ -2452,18 +2452,18 @@ static const char * const name_hungarian
 
	"szalonta",
 
	"telek",
 
	"vas",
 
	"völgy"
 
	"völgy",
 
};
 

	
 
static const char * const name_hungarian_4[] = {
 
static const char * const _name_hungarian_4[] = {
 
	"alja",
 
	"egyháza",
 
	"háza",
 
	"úr",
 
	"vár"
 
	"vár",
 
};
 

	
 
static const char * const name_hungarian_real[] = {
 
static const char * const _name_hungarian_real[] = {
 
	"Ajka",
 
	"Aszód",
 
	"Badacsony",
 
@@ -2499,10 +2499,10 @@ static const char * const name_hungarian
 
	"Tokaj",
 
	"Vác",
 
	"Záhony",
 
	"Zirc"
 
	"Zirc",
 
};
 

	
 
static const char * const name_swiss_real[] = {
 
static const char * const _name_swiss_real[] = {
 
	"Aarau",
 
	"Aesch",
 
	"Altdorf",
 
@@ -2628,7 +2628,7 @@ static const char * const name_swiss_rea
 
	"Zug",
 
};
 

	
 
static const char * const name_danish_1[] = {
 
static const char * const _name_danish_1[] = {
 
	"Gamle ",
 
	"Lille ",
 
	"Nye ",
 
@@ -2643,7 +2643,7 @@ static const char * const name_danish_1[
 
	"Kongens ",
 
};
 

	
 
static const char * const name_danish_2[] = {
 
static const char * const _name_danish_2[] = {
 
	"Ager",
 
	"Alle",
 
	"Aske",
 
@@ -2724,10 +2724,10 @@ static const char * const name_danish_2[
 
	"Vor",
 
	"Vær",
 
	"Ør",
 
	"Ål"
 
	"Ål",
 
};
 

	
 
static const char * const name_danish_3[] = {
 
static const char * const _name_danish_3[] = {
 
	"basse",
 
	"borg",
 
	"berg",
 
@@ -2757,10 +2757,10 @@ static const char * const name_danish_3[
 
	"bo",
 
	"lyst",
 
	"feld",
 
	"skov"
 
	"skov",
 
};
 

	
 
static const char * const name_turkish_prefix[] = {
 
static const char * const _name_turkish_prefix[] = {
 
	"Akça",
 
	"Altın",
 
	"Bahçe",
 
@@ -2776,20 +2776,20 @@ static const char * const name_turkish_p
 
	"Sarı",
 
	"Sultan",
 
	"Ulu",
 
	"Yeni"
 
	"Yeni",
 
};
 

	
 
static const char * const name_turkish_middle[] = {
 
static const char * const _name_turkish_middle[] = {
 
	"agaç",
 
	"ayva",
 
	"çam",
 
	"elma",
 
	"kurt",
 
	"pazar",
 
	"yalı"
 
	"yalı",
 
};
 

	
 
static const char * const name_turkish_suffix[] = {
 
static const char * const _name_turkish_suffix[] = {
 
	"dere",
 
	"hisar",
 
	"kale",
 
@@ -2803,10 +2803,10 @@ static const char * const name_turkish_s
 
	"saray",
 
	"tepe",
 
	"yer",
 
	"yurt"
 
	"yurt",
 
};
 

	
 
static const char * const name_turkish_real[] = {
 
static const char * const _name_turkish_real[] = {
 
	"Adana",
 
	"Adıyaman",
 
	"Afyon",
 
@@ -2871,10 +2871,10 @@ static const char * const name_turkish_r
 
	"Yalova",
 
	"Karabük",
 
	"Osmaniye",
 
	"Düzce"
 
	"Düzce",
 
};
 

	
 
static const char * const name_italian_real[] = {
 
static const char * const _name_italian_real[] = {
 
	"Roma",
 
	"Milano",
 
	"Napoli",
 
@@ -2955,7 +2955,7 @@ static const char * const name_italian_r
 
	"Grosseto",
 
};
 

	
 
static const char * const name_italian_pref[] = {
 
static const char * const _name_italian_pref[] = {
 
	"Alpe ",
 
	"Borgo ",
 
	"Cascina ",
 
@@ -2970,7 +2970,7 @@ static const char * const name_italian_p
 
	"Villar ",
 
};
 

	
 
static const char * const name_italian_1m[] = {
 
static const char * const _name_italian_1m[] = {
 
	"Bel",
 
	"Borgo",
 
	"Bosco",
 
@@ -2998,7 +2998,7 @@ static const char * const name_italian_1
 
	"Vico",
 
};
 

	
 
static const char * const name_italian_1f[] = {
 
static const char * const _name_italian_1f[] = {
 
	"Acqua",
 
	"Bra",
 
	"Cala",
 
@@ -3024,7 +3024,7 @@ static const char * const name_italian_1
 
	"Villa",
 
};
 

	
 
static const char * const name_italian_2[] = {
 
static const char * const _name_italian_2[] = {
 
	"bell",
 
	"bianc",
 
	"cald",
 
@@ -3054,7 +3054,7 @@ static const char * const name_italian_2
 
	"viv",
 
};
 

	
 
static const char * const name_italian_2i[] = {
 
static const char * const _name_italian_2i[] = {
 
	"",
 
	"breve",
 
	"brevi",
 
@@ -3081,7 +3081,7 @@ static const char * const name_italian_2
 
};
 

	
 

	
 
static const char * const name_italian_3[] = {
 
static const char * const _name_italian_3[] = {
 
	" Marittimo",
 
	" Marittima",
 
	" del Capo",
 
@@ -3105,14 +3105,14 @@ static const char * const name_italian_3
 
	" Ticino",
 
};
 

	
 
static const char * const name_italian_river1[] = {
 
static const char * const _name_italian_river1[] = {
 
	" del",
 
	" sul",
 
	" al",
 
	" nel",
 
};
 

	
 
static const char * const name_italian_river2[] = {
 
static const char * const _name_italian_river2[] = {
 
	"l'Adda",
 
	"l'Adige",
 
	"le Alpi",
 
@@ -3140,7 +3140,7 @@ static const char * const name_italian_r
 
	" Tevere",
 
};
 

	
 
static const char * const name_catalan_real[] = {
 
static const char * const _name_catalan_real[] = {
 
	"Barcelona",
 
	"Hospitalet",
 
	"Cerdanyola",
 
@@ -3210,7 +3210,7 @@ static const char * const name_catalan_r
 
	"Roses",
 
};
 

	
 
static const char * const name_catalan_pref[] = {
 
static const char * const _name_catalan_pref[] = {
 
	"Pont de ",
 
	"Parets de ",
 
	"Canet de ",
 
@@ -3245,7 +3245,7 @@ static const char * const name_catalan_p
 

	
 
};
 

	
 
static const char * const name_catalan_1m[] = {
 
static const char * const _name_catalan_1m[] = {
 
	"Torrent",
 
	"Cami",
 
	"Mont",
 
@@ -3254,7 +3254,7 @@ static const char * const name_catalan_1
 
	"Riu",
 
};
 

	
 
static const char * const name_catalan_1f[] = {
 
static const char * const _name_catalan_1f[] = {
 
	"Aigua",
 
	"Selva ",
 
	"Vall",
 
@@ -3265,7 +3265,7 @@ static const char * const name_catalan_1
 
	"Terra",
 
};
 

	
 
static const char * const name_catalan_2m[] = {
 
static const char * const _name_catalan_2m[] = {
 
	"alt",
 
	"baix",
 
	"fosc",
 
@@ -3276,7 +3276,7 @@ static const char * const name_catalan_2
 
	"gris",
 
};
 

	
 
static const char * const name_catalan_2f[] = {
 
static const char * const _name_catalan_2f[] = {
 
	"baixa",
 
	"alta",
 
	"fosca",
 
@@ -3287,7 +3287,7 @@ static const char * const name_catalan_2
 
	"freda",
 
};
 

	
 
static const char * const name_catalan_3[] = {
 
static const char * const _name_catalan_3[] = {
 
	" despí",
 
	" desvern",
 
	" del camí",
 
@@ -3300,7 +3300,7 @@ static const char * const name_catalan_3
 
	" de la plana",
 
};
 

	
 
static const char * const name_catalan_river1[] = {
 
static const char * const _name_catalan_river1[] = {
 
	" d'Anoia",
 
	" de Ter",
 
	" de Llobregat",
0 comments (0 inline, 0 general)