(svn r15727) -Codechange: apply coding style to namegen arrays

-Fix (r1307): missing comma in _name_original_english_4

3 files changed, 347 insertions, 347 deletions

diff --git a/src/namegen.cpp b/src/namegen.cpp
index db213ad17..bf0f2fe53 100644
--- a/src/namegen.cpp
+++ b/src/namegen.cpp
@@ -45,20 +45,20 @@ static byte MakeEnglishOriginalTownName(char *buf, uint32 seed, const char *last
 	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 MakeEnglishAdditionalTownName(char *buf, uint32 seed, const char *la
 	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 *buf, uint32 seed, const char *last)
 	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, uint32 seed, const char *last)
 
 	/* 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, uint32 seed, const char *last)
 
 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 *buf, uint32 seed, const char *last)
 	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, uint32 seed, const char *last)
 	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 *buf, uint32 seed, const char *last)
 
 	/* 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 *buf, uint32 seed, const char *last)
 			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, uint32 seed, const char *last)
 
 	/* 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, uint32 seed, const char *last)
 
 	/* 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, uint32 seed, const char *last)
 	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, uint32 seed, const char *last)
 		/* 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, uint32 seed, const char *last)
 		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, uint32 seed, const char *last)
 	/* 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, uint32 seed, const char *last)
 			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, uint32 seed, const char *last)
 				}
 			}
 		}
-		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, uint32 seed, const char *last)
 
 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 *buf, uint32 seed, const char *last)
 	 * 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 *buf, uint32 seed, const char *last)
 	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 *buf, uint32 seed, const char *last)
 
 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, uint32 seed, const char *last)
 	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 *buf, uint32 seed, const char *last)
 	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 *buf, uint32 seed, const char *last)
 	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 *buf, uint32 seed, const char *last)
 	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);
 			}
 		}
 	}
diff --git a/src/saveload/oldloader_sl.cpp b/src/saveload/oldloader_sl.cpp
index 3b0bf185c..812427b2c 100644
--- a/src/saveload/oldloader_sl.cpp
+++ b/src/saveload/oldloader_sl.cpp
@@ -108,7 +108,7 @@ static uint32 RemapOldTownName(uint32 townnameparts, byte old_town_name_type)
 		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 townnameparts, byte old_town_name_type)
 
 		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;
 }
diff --git a/src/table/namegen.h b/src/table/namegen.h
index fadddadd6..494c10d16 100644
--- a/src/table/namegen.h
+++ b/src/table/namegen.h
@@ -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_english_2[] = {
 	"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_english_3[] = {
 	"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_english_5[] = {
 	"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_english_6[] = {
 	" 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_additional_english_1a[] = {
 	"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_additional_english_1b1[] = {
 	"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_additional_english_1b2[] = {
 	"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_additional_english_2[] = {
 	"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_additional_english_3[] = {
 	" 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_a2[] = {
 	"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_a3[] = {
 	"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_a4[] = {
 	"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_a6[] = {
 	"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_f2[] = {
 	"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_b2[] = {
 	"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_real[] = {
 	"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_real[] = {
 	"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_real[] = {
 	"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_2a[] = {
 	"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_2b[] = {
 	"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_2c[] = {
 	"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_real[] = {
 	"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_m[] = {
 	"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_f[] = {
 	"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_n[] = {
 	"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_o[] = {
 	"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_m[] = {
 	"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_f[] = {
 	"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_n[] = {
 	"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_m[] = {
 	" 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_f[] = {
 	" 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_n[] = {
 	" 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_real[] = {
 	"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_subst_full[] = {
 };
 
 /* 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_subst_stem[] = {
 };
 
 /* 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_subst_ending[] = {
 	{ 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_suffix[] = {
 
 
 
-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_real[] = {
 	"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_real[] = {
 	"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_1[] = {
 	"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_2[] = {
 	"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_real[] = {
 	"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_2[] = {
 	"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_3[] = {
 	"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_real[] = {
 	"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_real[] = {
 	"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_prefix[] = {
 	"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_suffix[] = {
 	"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_real[] = {
 	"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_real[] = {
 	"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_pref[] = {
 	"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_1m[] = {
 	"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_1f[] = {
 	"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_2i[] = {
 };
 
 
-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_river2[] = {
 	" 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_real[] = {
 	"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_pref[] = {
 
 };
 
-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_1m[] = {
 	"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_1f[] = {
 	"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_2m[] = {
 	"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_2f[] = {
 	"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",