From e8f05273cd5acc075f91e922cf9b87b37dc0c147 Mon Sep 17 00:00:00 2001
From: magnum <magnum>
Date: Wed, 17 Aug 2011 14:06:33 +0200
Subject: [PATCH 17/17] Character classes tweaks

---
 run/cmpt_cp.pl      |  121 ++++++++++++++++++++++++++++-----------------------
 src/encoding_data.h |   84 ++++++++++++++++++++----------------
 src/rules.c         |    1 +
 3 files changed, 114 insertions(+), 92 deletions(-)

diff --git a/run/cmpt_cp.pl b/run/cmpt_cp.pl
index 61dce2f..117f787 100755
--- a/run/cmpt_cp.pl
+++ b/run/cmpt_cp.pl
@@ -3,7 +3,7 @@ use strict;
 use Encode;
 use Switch;
 use Unicode::Normalize;
-use utf8;  # This source file must be stored UTF-8 encoded
+use utf8;  # This source file MUST be stored UTF-8 encoded
 
 ###############################################################################
 # code page data builder, by magnum / JimF.   v1.2
@@ -45,9 +45,16 @@ sub lookupCategory {
 	return $cat{$c};
 }
 
+sub printdef {
+	my $param = shift;
+	if (length($param)>80) {print" \\\n\t";}
+	elsif (length($param)>0) {print" ";}
+	if (length($param)>0)  {print "\"".$param."\"";}
+}
+
 my $to_unicode_high128="";
-my $lower="";  my $upper="";  my $lowonly="";  my $uponly="";  my $specials = "";  my $punctuation = "";  my $alpha = "";  my $digits = "";  my $control = "";  my $invalid = ""; my $whitespace = ""; my $vowels = ""; my $consonants = "";
-my $clower=""; my $cupper=""; my $clowonly=""; my $cuponly=""; my $cspecials = ""; my $cpunctuation = ""; my $calpha = ""; my $cdigits = ""; my $cvowels = ""; my $cconsonants = "";
+my $lower="";  my $upper="";  my $lowonly="";  my $uponly="";  my $specials = "";  my $punctuation = "";  my $alpha = "";  my $digits = "";  my $control = "";  my $invalid = ""; my $whitespace = ""; my $vowels = "\\x59\\x79"; my $consonants = "";
+my $clower=""; my $cupper=""; my $clowonly=""; my $cuponly=""; my $cspecials = ""; my $cpunctuation = ""; my $calpha = ""; my $cdigits = ""; my $cvowels = "Yy"; my $cconsonants = "";
 my $encu = uc($enc);my $hs = "";
 $encu =~ s/-/_/g;
 #######################################
@@ -57,6 +64,9 @@ foreach my $i (0x80..0xFF) {
 	my $u = chr($i);
 	$u = Encode::decode($enc, $u);
 	$hs .= $u;
+	if (ord($u) == 0xfffd) {
+		$u = chr($i);
+	}
 	$to_unicode_high128 .= "0x" . sprintf "%04X", ord($u);
 	if ($i % 16 == 15 && $i != 255) { $to_unicode_high128 .= ",\n"; }
 	elsif ($i != 255) { $to_unicode_high128 .= ","; }
@@ -86,17 +96,27 @@ foreach my $i (0x80..0xFF) {
 	    if (chr($i) ne $euc) {
 			if (chr($i) ne $elc && chr($i) ne $euc) {
 				no warnings;
-				printf("// *** WARNING, char at ord(0x%X) U+%04X (%s) needs to be looked into. Neither conversion gets back to original value!\n",$i,ord($c), $c);
-			} elsif ( ord($euc) == 0x3F) { # 0x3F is ?  In perl, if there IS a unicode conversion for a case, but there is no 'reverse' case char in the charset,
+				printf("// *** WARNING, char at 0x%X U+%04X (%s) needs to be looked into. Neither conversion gets back to original value!\n",$i,ord($c), $c);
+			} elsif ( length($euc) > 1) {
+				$lowonly .= sprintf("\\x%02X", ord($elc));
+				$clowonly .= $c;
+				printf("// *** WARNING, char at 0x%X U+%04X (%s -> %s) needs to be looked into.  Single to multi-byte conversion\n",$i,ord($c), $ulc, $uuc);
+			} elsif ( length($elc) > 1) {
+				$uponly .= sprintf("\\x%02X", ord($euc));
+				$cuponly .= $c;
+				printf("// *** WARNING, char at 0x%X U+%04X (%s -> %s) needs to be looked into.  Single to multi-byte conversion\n",$i,ord($c), $ulc, $uuc);
+			} elsif ( ord($euc) < 0x80) {
 				$lowonly .= sprintf("\\x%02X", ord($elc));
 				$clowonly .= $c;
-			} elsif ( ord($elc) == 0x3F) { # then the final encode gives us a '?'. Thus, we know this is a character, and know it's case, but we can not 'convert' it to the other case.
+				if (ord($euc) != 0x3f) {
+					printf("// *** WARNING, char at 0x%X -> U+%04X -> U+%04X -> 0x%X (%s -> %s) needs to be looked into.  Likely one way casing conversion\n",$i,ord($ulc),ord($uuc),ord($euc), $ulc, $uuc);
+				}
+			} elsif ( ord($elc) < 0x80) {
 				$uponly .= sprintf("\\x%02X", ord($euc));
 				$cuponly .= $c;
-			} elsif ( length($elc) > 1 || length($euc) > 1) {
-				printf("// *** WARNING, char at ord(0x%X) U+%04X (%s, lc %s, uc %s) needs to be looked into.  Single to multi-byte conversion\n",$i,ord($c), $c, $ulc, $uuc);
-			} elsif ( ord($elc) < 0x80 || ord($euc) < 0x80) {
-				printf("// *** WARNING, char at ord(0x%X) U+%04X (%s, lc %s, uc %s) needs to be looked into.  Likely one way casing conversion\n",$i,ord($c), $c, $ulc, $uuc);
+				if (ord($elc) != 0x3f) {
+					printf("// *** WARNING, char at 0x%X -> U+%04X -> U+%04X -> 0x%X (%s -> %s) needs to be looked into.  Likely one way casing conversion\n",$i,ord($ulc),ord($uuc),ord($euc), $ulc, $uuc);
+				}
 			} else {
 				$lower .= sprintf("\\x%02X", ord($elc));
 				$clower .= lc($c);
@@ -126,15 +146,18 @@ foreach my $i (0x80..0xFF) {
 				$calpha .= $c;
 
 				# best-effort vowel/consonant matching
-				# Note eg. in English, y and w CAN be vowels depending on
-				# situation (boy, yet, we)
-
 				# We normalize to decomposed and match known vowels in lc
 				my $nfd = substr(NFD($c), 0, 1);
 				# Done: Latin, Nordic, Greek, Russian, Ukrainian, Turkish
-				if ($nfd =~ m/[aoueiœæøɪʏɛɔαεηιοωυаэыуояеюиєіı]/i) {
+				if ($nfd =~ m/[aoueiyœæøɪʏɛɔαεηιοωυаэыуояеюиєіı]/i) {
 					$vowels .= sprintf("\\x%02X", $i);
 					$cvowels .= $c;
+					# Note eg. in English, y depends on situation
+					# (yellow, happy). We set latin yY variants as both!
+					if ($nfd =~ m/y/i) {
+						$consonants .= sprintf("\\x%02X", $i);
+						$cconsonants .= $c;
+					}
 				} else {
 					$consonants .= sprintf("\\x%02X", $i);
 					$cconsonants .= $c;
@@ -154,82 +177,70 @@ foreach my $i (0x80..0xFF) {
 	}
 }
 print "\n// $clower\n" if $verbose;
-print "#define CHARS_LOWER_".$encu." ";
-if (length($lower)>80) {print"\\\n\t";}
-if (length($lower)>0)  {print "\"".$lower."\"";}
+print "#define CHARS_LOWER_".$encu;
+printdef($lower);
 print "\n";
 
 print "\n// $clowonly\n" if $verbose;
-print "#define CHARS_LOW_ONLY_".$encu." ";
-if (length($lowonly)>80) {print"\\\n\t";}
-if (length($lowonly)>0)  {print "\"".$lowonly."\"";}
+print "#define CHARS_LOW_ONLY_".$encu;
+printdef($lowonly);
 print "\n";
 
 print "\n// $cupper\n" if $verbose;
-print "#define CHARS_UPPER_".$encu." ";
-if (length($upper)>80) {print"\\\n\t";}
-if (length($upper)>0)  {print "\"".$upper."\"";}
+print "#define CHARS_UPPER_".$encu;
+printdef($upper);
 print "\n";
 
 print "\n// $cuponly\n" if $verbose;
-print "#define CHARS_UP_ONLY_".$encu." ";
-if (length($uponly)>80) {print"\\\n\t";}
-if (length($uponly)>0)  {print "\"".$uponly."\"";}
+print "#define CHARS_UP_ONLY_".$encu;
+printdef($uponly);
 print "\n";
 
 print "\n// $cdigits\n" if $verbose;
-print "#define CHARS_DIGITS_".$encu." ";
-if (length($digits)>80) {print"\\\n\t";}
-if (length($digits)>0)  {print "\"".$digits."\"";}
+print "#define CHARS_DIGITS_".$encu;
+printdef($digits);
 print "\n";
 
 print "\n// $cpunctuation\n" if $verbose;
-print "#define CHARS_PUNCTUATION_".$encu." ";
-if (length($punctuation)>80) {print"\\\n\t";}
-if (length($punctuation)>0)  {print "\"".$punctuation."\"";}
+print "#define CHARS_PUNCTUATION_".$encu;
+printdef($punctuation);
 print "\n";
 
 print "\n// $cspecials\n" if $verbose;
-print "#define CHARS_SPECIALS_".$encu." ";
-if (length($specials)>80) {print"\\\n\t";}
-if (length($specials)>0)  {print "\"".$specials."\"";}
+print "#define CHARS_SPECIALS_".$encu;
+printdef($specials);
 print "\n";
 
 print "\n// $calpha\n" if $verbose;
-print "#define CHARS_ALPHA_".$encu." ";
-if (length($alpha)>80) {print"\\\n\t";}
-if (length($alpha)>0)  {print "\"".$alpha."\"";}
+print "#define CHARS_ALPHA_".$encu;
+printdef($alpha);
 print "\n";
 
 print "\n" if $verbose;
-print "#define CHARS_WHITESPACE_".$encu." ";
-if (length($whitespace)>80) {print"\\\n\t";}
-if (length($whitespace)>0)  {print "\"".$whitespace."\"";}
+print "#define CHARS_WHITESPACE_".$encu;
+printdef($whitespace);
 print "\n";
 
 print "\n" if $verbose;
-print "#define CHARS_CONTROL_".$encu." ";
-if (length($control)>80) {print"\\\n\t";}
-if (length($control)>0)  {print "\"".$control."\"";}
+print "#define CHARS_CONTROL_".$encu;
+printdef($control);
 print "\n";
 
+print "\n" if $verbose;
+print "#define CHARS_INVALID_".$encu." ";
+if (length($invalid)>80) {print"\\\n\t";}
+print "\"".$invalid."\"\n";	# we ALWAYS want to print the "" even if string empty.
+
 print "\n// $cvowels\n" if $verbose;
-print "#define CHARS_VOWELS_".$encu." ";
-if (length($vowels)>80) {print"\\\n\t";}
-if (length($vowels)>0)  {print "\"".$vowels."\"";}
+print "#define CHARS_VOWELS_".$encu;
+printdef($vowels);
 print "\n";
 
 print "\n// $cconsonants\n" if $verbose;
-print "#define CHARS_CONSONANTS_".$encu." ";
-if (length($consonants)>80) {print"\\\n\t";}
-if (length($consonants)>0)  {print "\"".$consonants."\"";}
+print "#define CHARS_CONSONANTS_".$encu;
+printdef($consonants);
 print "\n";
 
-print "\n" if $verbose;
-print "#define CHARS_INVALID_".$encu." ";
-if (length($invalid)>80) {print"\\\n\t";}
-print "\"".$invalid."\"\n";	# we ALWAYS want to print the "" even if string empty.
-
 ####################################################################
 # Ok, provide a check to see if any of the characters UNDER 0x80
 # are non-standard.  At this time, there is no plan on HOW to handle
diff --git a/src/encoding_data.h b/src/encoding_data.h
index 3de5608..54ae3ff 100644
--- a/src/encoding_data.h
+++ b/src/encoding_data.h
@@ -1,9 +1,11 @@
 /*
+ * This source file is UTF-8 encoded, for auto-generated warnings
+ *
  * This software was written by Jim Fougeron jfoug AT cox dot net
  * in 2011. No copyright is claimed, and the software is hereby
  * placed in the public domain. In case this attempt to disclaim
  * copyright and place the software in the public domain is deemed
- * null and void, then the software is Copyright � 2011 Jim Fougeron
+ * null and void, then the software is Copyright © 2011 Jim Fougeron
  * and it is hereby released to the general public under the following
  * terms:
  *
@@ -28,8 +30,14 @@
 // for UTF16/UTF8 definition
 #include "unicode.h"
 
+// These are always invalid, but there are also a lot of multi-octet
+// combinations that are invalid but can't be matched this easily.
 #define CHARS_INVALID_UTF8 "\xc0\xc1\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff"
 
+// for i in iso-8859-1 koi8-r cp1251 cp866 cp1252 iso-8859-15 cp437 cp850 cp858 cp737; do ../run/cmpt_cp.pl $i; done >> encoding_data.h
+
+// ----8<------8<---- AUTO-GENERATED DATA BELOW THIS POINT ----8<------8<----
+
 // here is the ISO_8859_1 to Unicode conversion for ISO_8859_1 characters from 0x80 to 0xFF
 static UTF16 ISO_8859_1_to_unicode_high128[] = {
 0x0080,0x0081,0x0082,0x0083,0x0084,0x0085,0x0086,0x0087,0x0088,0x0089,0x008A,0x008B,0x008C,0x008D,0x008E,0x008F,
@@ -40,10 +48,10 @@ static UTF16 ISO_8859_1_to_unicode_high128[] = {
 0x00D0,0x00D1,0x00D2,0x00D3,0x00D4,0x00D5,0x00D6,0x00D7,0x00D8,0x00D9,0x00DA,0x00DB,0x00DC,0x00DD,0x00DE,0x00DF,
 0x00E0,0x00E1,0x00E2,0x00E3,0x00E4,0x00E5,0x00E6,0x00E7,0x00E8,0x00E9,0x00EA,0x00EB,0x00EC,0x00ED,0x00EE,0x00EF,
 0x00F0,0x00F1,0x00F2,0x00F3,0x00F4,0x00F5,0x00F6,0x00F7,0x00F8,0x00F9,0x00FA,0x00FB,0x00FC,0x00FD,0x00FE,0x00FF };
-// *** WARNING, char at ord(0xDF) U+00DF (�, lc �, uc SS) needs to be looked into.  Single to multi-byte conversion
+// *** WARNING, char at 0xDF U+00DF (ß -> SS) needs to be looked into.  Single to multi-byte conversion
 #define CHARS_LOWER_ISO_8859_1 \
 	"\xE0\xE1\xE2\xE3\xE4\xE5\xE6\xE7\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF\xF0\xF1\xF2\xF3\xF4\xF5\xF6\xF8\xF9\xFA\xFB\xFC\xFD\xFE"
-#define CHARS_LOW_ONLY_ISO_8859_1 "\xAA\xBA\xB5\xFF"
+#define CHARS_LOW_ONLY_ISO_8859_1 "\xAA\xB5\xBA\xDF\xFF"
 #define CHARS_UPPER_ISO_8859_1 \
 	"\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF\xD0\xD1\xD2\xD3\xD4\xD5\xD6\xD8\xD9\xDA\xDB\xDC\xDD\xDE"
 #define CHARS_UP_ONLY_ISO_8859_1
@@ -57,7 +65,7 @@ static UTF16 ISO_8859_1_to_unicode_high128[] = {
 	"\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F"
 #define CHARS_INVALID_ISO_8859_1 ""
 #define CHARS_VOWELS_ISO_8859_1 \
-	"\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF\xD2\xD3\xD4\xD5\xD6\xD8\xD9\xDA\xDB\xDC\xE0\xE1\xE2\xE3\xE4\xE5\xE6\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF\xF2\xF3\xF4\xF5\xF6\xF8\xF9\xFA\xFB\xFC"
+	"\x59\x79\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF\xD2\xD3\xD4\xD5\xD6\xD8\xD9\xDA\xDB\xDC\xDD\xE0\xE1\xE2\xE3\xE4\xE5\xE6\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF\xF2\xF3\xF4\xF5\xF6\xF8\xF9\xFA\xFB\xFC\xFD\xFF"
 #define CHARS_CONSONANTS_ISO_8859_1 "\xAA\xB5\xBA\xC7\xD0\xD1\xDD\xDE\xDF\xE7\xF0\xF1\xFD\xFE\xFF"
 
 // here is the KOI8_R to Unicode conversion for KOI8_R characters from 0x80 to 0xFF
@@ -86,14 +94,14 @@ static UTF16 KOI8_R_to_unicode_high128[] = {
 #define CHARS_CONTROL_KOI8_R
 #define CHARS_INVALID_KOI8_R ""
 #define CHARS_VOWELS_KOI8_R \
-	"\xA3\xB3\xC0\xC1\xC5\xC9\xCA\xCF\xD1\xD5\xD9\xDC\xE0\xE1\xE5\xE9\xEA\xEF\xF1\xF5\xF9\xFC"
+	"\x59\x79\xA3\xB3\xC0\xC1\xC5\xC9\xCA\xCF\xD1\xD5\xD9\xDC\xE0\xE1\xE5\xE9\xEA\xEF\xF1\xF5\xF9\xFC"
 #define CHARS_CONSONANTS_KOI8_R \
 	"\xC2\xC3\xC4\xC6\xC7\xC8\xCB\xCC\xCD\xCE\xD0\xD2\xD3\xD4\xD6\xD7\xD8\xDA\xDB\xDD\xDE\xDF\xE2\xE3\xE4\xE6\xE7\xE8\xEB\xEC\xED\xEE\xF0\xF2\xF3\xF4\xF6\xF7\xF8\xFA\xFB\xFD\xFE\xFF"
 
-// here is the CP1251 to Unicode conversion for CP1251 characters from 0xA0 to 0xFF 
+// here is the CP1251 to Unicode conversion for CP1251 characters from 0x80 to 0xFF
 static UTF16 CP1251_to_unicode_high128[] = {
 0x0402,0x0403,0x201A,0x0453,0x201E,0x2026,0x2020,0x2021,0x20AC,0x2030,0x0409,0x2039,0x040A,0x040C,0x040B,0x040F,
-0x0452,0x2018,0x2019,0x201C,0x201D,0x2022,0x2013,0x2014,0xFFFD,0x2122,0x0459,0x203A,0x045A,0x045C,0x045B,0x045F,
+0x0452,0x2018,0x2019,0x201C,0x201D,0x2022,0x2013,0x2014,0x0098,0x2122,0x0459,0x203A,0x045A,0x045C,0x045B,0x045F,
 0x00A0,0x040E,0x045E,0x0408,0x00A4,0x0490,0x00A6,0x00A7,0x0401,0x00A9,0x0404,0x00AB,0x00AC,0x00AD,0x00AE,0x0407,
 0x00B0,0x00B1,0x0406,0x0456,0x0491,0x00B5,0x00B6,0x00B7,0x0451,0x2116,0x0454,0x00BB,0x0458,0x0405,0x0455,0x0457,
 0x0410,0x0411,0x0412,0x0413,0x0414,0x0415,0x0416,0x0417,0x0418,0x0419,0x041A,0x041B,0x041C,0x041D,0x041E,0x041F,
@@ -115,11 +123,11 @@ static UTF16 CP1251_to_unicode_high128[] = {
 #define CHARS_CONTROL_CP1251
 #define CHARS_INVALID_CP1251 "\x98"
 #define CHARS_VOWELS_CP1251 \
-	"\xA1\xA2\xA8\xAA\xAF\xB2\xB3\xB8\xBA\xBF\xC0\xC5\xC8\xC9\xCE\xD3\xDB\xDD\xDE\xDF\xE0\xE5\xE8\xE9\xEE\xF3\xFB\xFD\xFE\xFF"
+	"\x59\x79\xA1\xA2\xA8\xAA\xAF\xB2\xB3\xB8\xBA\xBF\xC0\xC5\xC8\xC9\xCE\xD3\xDB\xDD\xDE\xDF\xE0\xE5\xE8\xE9\xEE\xF3\xFB\xFD\xFE\xFF"
 #define CHARS_CONSONANTS_CP1251 \
 	"\x80\x81\x83\x8A\x8C\x8D\x8E\x8F\x90\x9A\x9C\x9D\x9E\x9F\xA3\xA5\xB4\xB5\xBC\xBD\xBE\xC1\xC2\xC3\xC4\xC6\xC7\xCA\xCB\xCC\xCD\xCF\xD0\xD1\xD2\xD4\xD5\xD6\xD7\xD8\xD9\xDA\xDC\xE1\xE2\xE3\xE4\xE6\xE7\xEA\xEB\xEC\xED\xEF\xF0\xF1\xF2\xF4\xF5\xF6\xF7\xF8\xF9\xFA\xFC"
 
-// here is the CP866 to Unicode conversion for CP866 characters from 0xA0 to 0xFF
+// here is the CP866 to Unicode conversion for CP866 characters from 0x80 to 0xFF
 static UTF16 CP866_to_unicode_high128[] = {
 0x0410,0x0411,0x0412,0x0413,0x0414,0x0415,0x0416,0x0417,0x0418,0x0419,0x041A,0x041B,0x041C,0x041D,0x041E,0x041F,
 0x0420,0x0421,0x0422,0x0423,0x0424,0x0425,0x0426,0x0427,0x0428,0x0429,0x042A,0x042B,0x042C,0x042D,0x042E,0x042F,
@@ -145,24 +153,24 @@ static UTF16 CP866_to_unicode_high128[] = {
 #define CHARS_CONTROL_CP866
 #define CHARS_INVALID_CP866 ""
 #define CHARS_VOWELS_CP866 \
-	"\x80\x85\x88\x89\x8E\x93\x9B\x9D\x9E\x9F\xA0\xA5\xA8\xA9\xAE\xE3\xEB\xED\xEE\xEF\xF0\xF1\xF2\xF3\xF4\xF5\xF6\xF7"
+	"\x59\x79\x80\x85\x88\x89\x8E\x93\x9B\x9D\x9E\x9F\xA0\xA5\xA8\xA9\xAE\xE3\xEB\xED\xEE\xEF\xF0\xF1\xF2\xF3\xF4\xF5\xF6\xF7"
 #define CHARS_CONSONANTS_CP866 \
 	"\x81\x82\x83\x84\x86\x87\x8A\x8B\x8C\x8D\x8F\x90\x91\x92\x94\x95\x96\x97\x98\x99\x9A\x9C\xA1\xA2\xA3\xA4\xA6\xA7\xAA\xAB\xAC\xAD\xAF\xE0\xE1\xE2\xE4\xE5\xE6\xE7\xE8\xE9\xEA\xEC"
 
-// here is the CP1252 to Unicode conversion for CP1252 characters from 0xA0 to 0xFF
+// here is the CP1252 to Unicode conversion for CP1252 characters from 0x80 to 0xFF
 static UTF16 CP1252_to_unicode_high128[] = {
-0x20AC,0xFFFD,0x201A,0x0192,0x201E,0x2026,0x2020,0x2021,0x02C6,0x2030,0x0160,0x2039,0x0152,0xFFFD,0x017D,0xFFFD,
-0xFFFD,0x2018,0x2019,0x201C,0x201D,0x2022,0x2013,0x2014,0x02DC,0x2122,0x0161,0x203A,0x0153,0xFFFD,0x017E,0x0178,
+0x20AC,0x0081,0x201A,0x0192,0x201E,0x2026,0x2020,0x2021,0x02C6,0x2030,0x0160,0x2039,0x0152,0x008D,0x017D,0x008F,
+0x0090,0x2018,0x2019,0x201C,0x201D,0x2022,0x2013,0x2014,0x02DC,0x2122,0x0161,0x203A,0x0153,0x009D,0x017E,0x0178,
 0x00A0,0x00A1,0x00A2,0x00A3,0x00A4,0x00A5,0x00A6,0x00A7,0x00A8,0x00A9,0x00AA,0x00AB,0x00AC,0x00AD,0x00AE,0x00AF,
 0x00B0,0x00B1,0x00B2,0x00B3,0x00B4,0x00B5,0x00B6,0x00B7,0x00B8,0x00B9,0x00BA,0x00BB,0x00BC,0x00BD,0x00BE,0x00BF,
 0x00C0,0x00C1,0x00C2,0x00C3,0x00C4,0x00C5,0x00C6,0x00C7,0x00C8,0x00C9,0x00CA,0x00CB,0x00CC,0x00CD,0x00CE,0x00CF,
 0x00D0,0x00D1,0x00D2,0x00D3,0x00D4,0x00D5,0x00D6,0x00D7,0x00D8,0x00D9,0x00DA,0x00DB,0x00DC,0x00DD,0x00DE,0x00DF,
 0x00E0,0x00E1,0x00E2,0x00E3,0x00E4,0x00E5,0x00E6,0x00E7,0x00E8,0x00E9,0x00EA,0x00EB,0x00EC,0x00ED,0x00EE,0x00EF,
 0x00F0,0x00F1,0x00F2,0x00F3,0x00F4,0x00F5,0x00F6,0x00F7,0x00F8,0x00F9,0x00FA,0x00FB,0x00FC,0x00FD,0x00FE,0x00FF };
-// *** WARNING, char at ord(0xDF) U+00DF (�, lc �, uc SS) needs to be looked into.  Single to multi-byte conversion
+// *** WARNING, char at 0xDF U+00DF (ß -> SS) needs to be looked into.  Single to multi-byte conversion
 #define CHARS_LOWER_CP1252 \
 	"\x9A\x9C\x9E\xE0\xE1\xE2\xE3\xE4\xE5\xE6\xE7\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF\xF0\xF1\xF2\xF3\xF4\xF5\xF6\xF8\xF9\xFA\xFB\xFC\xFD\xFE\xFF"
-#define CHARS_LOW_ONLY_CP1252 "\x83\xAA\xB5\xBA"
+#define CHARS_LOW_ONLY_CP1252 "\x83\xAA\xB5\xBA\xDF"
 #define CHARS_UPPER_CP1252 \
 	"\x8A\x8C\x8E\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF\xD0\xD1\xD2\xD3\xD4\xD5\xD6\xD8\xD9\xDA\xDB\xDC\xDD\xDE\x9F"
 #define CHARS_UP_ONLY_CP1252
@@ -176,11 +184,11 @@ static UTF16 CP1252_to_unicode_high128[] = {
 #define CHARS_CONTROL_CP1252
 #define CHARS_INVALID_CP1252 "\x81\x8D\x8F\x90\x9D"
 #define CHARS_VOWELS_CP1252 \
-	"\x8C\x9C\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF\xD2\xD3\xD4\xD5\xD6\xD8\xD9\xDA\xDB\xDC\xE0\xE1\xE2\xE3\xE4\xE5\xE6\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF\xF2\xF3\xF4\xF5\xF6\xF8\xF9\xFA\xFB\xFC"
+	"\x59\x79\x8C\x9C\x9F\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF\xD2\xD3\xD4\xD5\xD6\xD8\xD9\xDA\xDB\xDC\xDD\xE0\xE1\xE2\xE3\xE4\xE5\xE6\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF\xF2\xF3\xF4\xF5\xF6\xF8\xF9\xFA\xFB\xFC\xFD\xFF"
 #define CHARS_CONSONANTS_CP1252 \
 	"\x83\x8A\x8E\x9A\x9E\x9F\xAA\xB5\xBA\xC7\xD0\xD1\xDD\xDE\xDF\xE7\xF0\xF1\xFD\xFE\xFF"
 
-// here is the ISO_8859_15 to Unicode conversion for ISO_8859_15 characters from 0xA0 to 0xFF
+// here is the ISO_8859_15 to Unicode conversion for ISO_8859_15 characters from 0x80 to 0xFF
 static UTF16 ISO_8859_15_to_unicode_high128[] = {
 0x0080,0x0081,0x0082,0x0083,0x0084,0x0085,0x0086,0x0087,0x0088,0x0089,0x008A,0x008B,0x008C,0x008D,0x008E,0x008F,
 0x0090,0x0091,0x0092,0x0093,0x0094,0x0095,0x0096,0x0097,0x0098,0x0099,0x009A,0x009B,0x009C,0x009D,0x009E,0x009F,
@@ -190,10 +198,10 @@ static UTF16 ISO_8859_15_to_unicode_high128[] = {
 0x00D0,0x00D1,0x00D2,0x00D3,0x00D4,0x00D5,0x00D6,0x00D7,0x00D8,0x00D9,0x00DA,0x00DB,0x00DC,0x00DD,0x00DE,0x00DF,
 0x00E0,0x00E1,0x00E2,0x00E3,0x00E4,0x00E5,0x00E6,0x00E7,0x00E8,0x00E9,0x00EA,0x00EB,0x00EC,0x00ED,0x00EE,0x00EF,
 0x00F0,0x00F1,0x00F2,0x00F3,0x00F4,0x00F5,0x00F6,0x00F7,0x00F8,0x00F9,0x00FA,0x00FB,0x00FC,0x00FD,0x00FE,0x00FF };
-// *** WARNING, char at ord(0xDF) U+00DF (�, lc �, uc SS) needs to be looked into.  Single to multi-byte conversion
+// *** WARNING, char at 0xDF U+00DF (ß -> SS) needs to be looked into.  Single to multi-byte conversion
 #define CHARS_LOWER_ISO_8859_15 \
 	"\xA8\xB8\xBD\xE0\xE1\xE2\xE3\xE4\xE5\xE6\xE7\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF\xF0\xF1\xF2\xF3\xF4\xF5\xF6\xF8\xF9\xFA\xFB\xFC\xFD\xFE\xFF"
-#define CHARS_LOW_ONLY_ISO_8859_15 "\xAA\xB5\xBA"
+#define CHARS_LOW_ONLY_ISO_8859_15 "\xAA\xB5\xBA\xDF"
 #define CHARS_UPPER_ISO_8859_15 \
 	"\xA6\xB4\xBC\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF\xD0\xD1\xD2\xD3\xD4\xD5\xD6\xD8\xD9\xDA\xDB\xDC\xDD\xDE\xBE"
 #define CHARS_UP_ONLY_ISO_8859_15
@@ -207,10 +215,10 @@ static UTF16 ISO_8859_15_to_unicode_high128[] = {
 	"\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F"
 #define CHARS_INVALID_ISO_8859_15 ""
 #define CHARS_VOWELS_ISO_8859_15 \
-	"\xBC\xBD\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF\xD2\xD3\xD4\xD5\xD6\xD8\xD9\xDA\xDB\xDC\xE0\xE1\xE2\xE3\xE4\xE5\xE6\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF\xF2\xF3\xF4\xF5\xF6\xF8\xF9\xFA\xFB\xFC"
+	"\x59\x79\xBC\xBD\xBE\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF\xD2\xD3\xD4\xD5\xD6\xD8\xD9\xDA\xDB\xDC\xDD\xE0\xE1\xE2\xE3\xE4\xE5\xE6\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF\xF2\xF3\xF4\xF5\xF6\xF8\xF9\xFA\xFB\xFC\xFD\xFF"
 #define CHARS_CONSONANTS_ISO_8859_15 "\xA6\xA8\xAA\xB4\xB5\xB8\xBA\xBE\xC7\xD0\xD1\xDD\xDE\xDF\xE7\xF0\xF1\xFD\xFE\xFF"
 
-// here is the CP437 to Unicode conversion for CP437 characters from 0xA0 to 0xFF
+// here is the CP437 to Unicode conversion for CP437 characters from 0x80 to 0xFF
 static UTF16 CP437_to_unicode_high128[] = {
 0x00C7,0x00FC,0x00E9,0x00E2,0x00E4,0x00E0,0x00E5,0x00E7,0x00EA,0x00EB,0x00E8,0x00EF,0x00EE,0x00EC,0x00C4,0x00C5,
 0x00C9,0x00E6,0x00C6,0x00F4,0x00F6,0x00F2,0x00FB,0x00F9,0x00FF,0x00D6,0x00DC,0x00A2,0x00A3,0x00A5,0x20A7,0x0192,
@@ -220,10 +228,10 @@ static UTF16 CP437_to_unicode_high128[] = {
 0x2568,0x2564,0x2565,0x2559,0x2558,0x2552,0x2553,0x256B,0x256A,0x2518,0x250C,0x2588,0x2584,0x258C,0x2590,0x2580,
 0x03B1,0x00DF,0x0393,0x03C0,0x03A3,0x03C3,0x00B5,0x03C4,0x03A6,0x0398,0x03A9,0x03B4,0x221E,0x03C6,0x03B5,0x2229,
 0x2261,0x00B1,0x2265,0x2264,0x2320,0x2321,0x00F7,0x2248,0x00B0,0x2219,0x00B7,0x221A,0x207F,0x00B2,0x25A0,0x00A0 };
-// *** WARNING, char at ord(0xE1) U+00DF (�, lc �, uc SS) needs to be looked into.  Single to multi-byte conversion
+// *** WARNING, char at 0xE1 U+00DF (ß -> SS) needs to be looked into.  Single to multi-byte conversion
 #define CHARS_LOWER_CP437 "\x81\x82\x84\x86\x87\x91\x94\xA4\xE5\xED"
 #define CHARS_LOW_ONLY_CP437 \
-	"\x83\x85\x88\x89\x8A\x8B\x8C\x8D\x93\x95\x96\x97\x98\x9F\xA0\xA1\xA2\xA3\xA6\xA7\xE0\xE3\xE6\xE7\xEB\xEE"
+	"\x83\x85\x88\x89\x8A\x8B\x8C\x8D\x93\x95\x96\x97\x98\x9F\xA0\xA1\xA2\xA3\xA6\xA7\xE0\xE1\xE3\xE6\xE7\xEB\xEE"
 #define CHARS_UPPER_CP437 "\x9A\x90\x8E\x8F\x80\x92\x99\xA5\xE4\xE8"
 #define CHARS_UP_ONLY_CP437
 #define CHARS_DIGITS_CP437 "\xAB\xAC\xFD"
@@ -236,10 +244,10 @@ static UTF16 CP437_to_unicode_high128[] = {
 #define CHARS_CONTROL_CP437
 #define CHARS_INVALID_CP437 ""
 #define CHARS_VOWELS_CP437 \
-	"\x81\x82\x83\x84\x85\x86\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x99\x9A\xA0\xA1\xA2\xA3\xE0\xEA\xEE"
+	"\x59\x79\x81\x82\x83\x84\x85\x86\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\xA0\xA1\xA2\xA3\xE0\xEA\xEE"
 #define CHARS_CONSONANTS_CP437 "\x80\x87\x98\x9F\xA4\xA5\xA6\xA7\xE1\xE2\xE3\xE4\xE5\xE6\xE7\xE8\xE9\xEB\xED"
 
-// here is the CP850 to Unicode conversion for CP850 characters from 0xA0 to 0xFF
+// here is the CP850 to Unicode conversion for CP850 characters from 0x80 to 0xFF
 static UTF16 CP850_to_unicode_high128[] = {
 0x00C7,0x00FC,0x00E9,0x00E2,0x00E4,0x00E0,0x00E5,0x00E7,0x00EA,0x00EB,0x00E8,0x00EF,0x00EE,0x00EC,0x00C4,0x00C5,
 0x00C9,0x00E6,0x00C6,0x00F4,0x00F6,0x00F2,0x00FB,0x00F9,0x00FF,0x00D6,0x00DC,0x00F8,0x00A3,0x00D8,0x00D7,0x0192,
@@ -249,13 +257,13 @@ static UTF16 CP850_to_unicode_high128[] = {
 0x00F0,0x00D0,0x00CA,0x00CB,0x00C8,0x0131,0x00CD,0x00CE,0x00CF,0x2518,0x250C,0x2588,0x2584,0x00A6,0x00CC,0x2580,
 0x00D3,0x00DF,0x00D4,0x00D2,0x00F5,0x00D5,0x00B5,0x00FE,0x00DE,0x00DA,0x00DB,0x00D9,0x00FD,0x00DD,0x00AF,0x00B4,
 0x00AD,0x00B1,0x2017,0x00BE,0x00B6,0x00A7,0x00F7,0x00B8,0x00B0,0x00A8,0x00B7,0x00B9,0x00B3,0x00B2,0x25A0,0x00A0 };
-// *** WARNING, char at ord(0xD5) U+0131 (i, lc i, uc I) needs to be looked into.  Likely one way casing conversion
-// *** WARNING, char at ord(0xE1) U+00DF (�, lc �, uc SS) needs to be looked into.  Single to multi-byte conversion
+// *** WARNING, char at 0xD5 -> U+0131 -> U+0049 -> 0x49 (ı -> I) needs to be looked into.  Likely one way casing conversion
+// *** WARNING, char at 0xE1 U+00DF (ß -> SS) needs to be looked into.  Single to multi-byte conversion
 #define CHARS_LOWER_CP850 \
-	"\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x91\x93\x94\x95\x96\x97\x9B\xA0\xA1\xA2\xA3\xA4\xC6\xD0\xD5\xE4\xE7\xEC"
-#define CHARS_LOW_ONLY_CP850 "\x98\x9F\xA6\xA7\xE6"
+	"\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x91\x93\x94\x95\x96\x97\x9B\xA0\xA1\xA2\xA3\xA4\xC6\xD0\xE4\xE7\xEC"
+#define CHARS_LOW_ONLY_CP850 "\x98\x9F\xA6\xA7\xD5\xE1\xE6"
 #define CHARS_UPPER_CP850 \
-	"\x9A\x90\xB6\x8E\xB7\x8F\x80\xD2\xD3\xD4\xD8\xD7\xDE\x92\xE2\x99\xE3\xEA\xEB\x9D\xB5\xD6\xE0\xE9\xA5\xC7\xD1\x49\xE5\xE8\xED"
+	"\x9A\x90\xB6\x8E\xB7\x8F\x80\xD2\xD3\xD4\xD8\xD7\xDE\x92\xE2\x99\xE3\xEA\xEB\x9D\xB5\xD6\xE0\xE9\xA5\xC7\xD1\xE5\xE8\xED"
 #define CHARS_UP_ONLY_CP850
 #define CHARS_DIGITS_CP850 "\xAB\xAC\xF3\xFB\xFC\xFD"
 #define CHARS_PUNCTUATION_CP850 "\xA8\xAD\xAE\xAF\xF2\xFA"
@@ -267,10 +275,10 @@ static UTF16 CP850_to_unicode_high128[] = {
 #define CHARS_CONTROL_CP850
 #define CHARS_INVALID_CP850 ""
 #define CHARS_VOWELS_CP850 \
-	"\x81\x82\x83\x84\x85\x86\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x99\x9A\x9B\x9D\xA0\xA1\xA2\xA3\xB5\xB6\xB7\xC6\xC7\xD2\xD3\xD4\xD5\xD6\xD7\xD8\xDE\xE0\xE2\xE3\xE4\xE5\xE9\xEA\xEB"
+	"\x59\x79\x81\x82\x83\x84\x85\x86\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9D\xA0\xA1\xA2\xA3\xB5\xB6\xB7\xC6\xC7\xD2\xD3\xD4\xD5\xD6\xD7\xD8\xDE\xE0\xE2\xE3\xE4\xE5\xE9\xEA\xEB\xEC\xED"
 #define CHARS_CONSONANTS_CP850 "\x80\x87\x98\x9F\xA4\xA5\xA6\xA7\xD0\xD1\xE1\xE6\xE7\xE8\xEC\xED"
 
-// here is the CP858 to Unicode conversion for CP858 characters from 0xA0 to 0xFF
+// here is the CP858 to Unicode conversion for CP858 characters from 0x80 to 0xFF
 static UTF16 CP858_to_unicode_high128[] = {
 0x00C7,0x00FC,0x00E9,0x00E2,0x00E4,0x00E0,0x00E5,0x00E7,0x00EA,0x00EB,0x00E8,0x00EF,0x00EE,0x00EC,0x00C4,0x00C5,
 0x00C9,0x00E6,0x00C6,0x00F4,0x00F6,0x00F2,0x00FB,0x00F9,0x00FF,0x00D6,0x00DC,0x00F8,0x00A3,0x00D8,0x00D7,0x0192,
@@ -280,10 +288,10 @@ static UTF16 CP858_to_unicode_high128[] = {
 0x00F0,0x00D0,0x00CA,0x00CB,0x00C8,0x20AC,0x00CD,0x00CE,0x00CF,0x2518,0x250C,0x2588,0x2584,0x00A6,0x00CC,0x2580,
 0x00D3,0x00DF,0x00D4,0x00D2,0x00F5,0x00D5,0x00B5,0x00FE,0x00DE,0x00DA,0x00DB,0x00D9,0x00FD,0x00DD,0x00AF,0x00B4,
 0x00AD,0x00B1,0x2017,0x00BE,0x00B6,0x00A7,0x00F7,0x00B8,0x00B0,0x00A8,0x00B7,0x00B9,0x00B3,0x00B2,0x25A0,0x00A0 };
-// *** WARNING, char at ord(0xE1) U+00DF (�, lc �, uc SS) needs to be looked into.  Single to multi-byte conversion
+// *** WARNING, char at 0xE1 U+00DF (ß -> SS) needs to be looked into.  Single to multi-byte conversion
 #define CHARS_LOWER_CP858 \
 	"\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x91\x93\x94\x95\x96\x97\x9B\xA0\xA1\xA2\xA3\xA4\xC6\xD0\xE4\xE7\xEC"
-#define CHARS_LOW_ONLY_CP858 "\x98\x9F\xA6\xA7\xE6"
+#define CHARS_LOW_ONLY_CP858 "\x98\x9F\xA6\xA7\xE1\xE6"
 #define CHARS_UPPER_CP858 \
 	"\x9A\x90\xB6\x8E\xB7\x8F\x80\xD2\xD3\xD4\xD8\xD7\xDE\x92\xE2\x99\xE3\xEA\xEB\x9D\xB5\xD6\xE0\xE9\xA5\xC7\xD1\xE5\xE8\xED"
 #define CHARS_UP_ONLY_CP858
@@ -297,10 +305,10 @@ static UTF16 CP858_to_unicode_high128[] = {
 #define CHARS_CONTROL_CP858
 #define CHARS_INVALID_CP858 ""
 #define CHARS_VOWELS_CP858 \
-	"\x81\x82\x83\x84\x85\x86\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x99\x9A\x9B\x9D\xA0\xA1\xA2\xA3\xB5\xB6\xB7\xC6\xC7\xD2\xD3\xD4\xD6\xD7\xD8\xDE\xE0\xE2\xE3\xE4\xE5\xE9\xEA\xEB"
+	"\x59\x79\x81\x82\x83\x84\x85\x86\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9D\xA0\xA1\xA2\xA3\xB5\xB6\xB7\xC6\xC7\xD2\xD3\xD4\xD6\xD7\xD8\xDE\xE0\xE2\xE3\xE4\xE5\xE9\xEA\xEB\xEC\xED"
 #define CHARS_CONSONANTS_CP858 "\x80\x87\x98\x9F\xA4\xA5\xA6\xA7\xD0\xD1\xE1\xE6\xE7\xE8\xEC\xED"
 
-// here is the CP737 to Unicode conversion for CP737 characters from 0xA0 to 0xFF
+// here is the CP737 to Unicode conversion for CP737 characters from 0x80 to 0xFF
 static UTF16 CP737_to_unicode_high128[] = {
 0x0391,0x0392,0x0393,0x0394,0x0395,0x0396,0x0397,0x0398,0x0399,0x039A,0x039B,0x039C,0x039D,0x039E,0x039F,0x03A0,
 0x03A1,0x03A3,0x03A4,0x03A5,0x03A6,0x03A7,0x03A8,0x03A9,0x03B1,0x03B2,0x03B3,0x03B4,0x03B5,0x03B6,0x03B7,0x03B8,
@@ -326,8 +334,10 @@ static UTF16 CP737_to_unicode_high128[] = {
 #define CHARS_CONTROL_CP737
 #define CHARS_INVALID_CP737 ""
 #define CHARS_VOWELS_CP737 \
-	"\x80\x84\x86\x88\x8E\x93\x97\x98\x9C\x9E\xA0\xA6\xAC\xE0\xE1\xE2\xE3\xE4\xE5\xE6\xE7\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF\xF0\xF4\xF5"
+	"\x59\x79\x80\x84\x86\x88\x8E\x93\x97\x98\x9C\x9E\xA0\xA6\xAC\xE0\xE1\xE2\xE3\xE4\xE5\xE6\xE7\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF\xF0\xF4\xF5"
 #define CHARS_CONSONANTS_CP737 \
 	"\x81\x82\x83\x85\x87\x89\x8A\x8B\x8C\x8D\x8F\x90\x91\x92\x94\x95\x96\x99\x9A\x9B\x9D\x9F\xA1\xA2\xA3\xA4\xA5\xA7\xA8\xA9\xAA\xAB\xAD\xAE\xAF"
 
+// ----8<------8<---- END OF AUTO-GENERATED DATA ----8<------8<----
+
 #endif // __ENCODING_DATA_H__
diff --git a/src/rules.c b/src/rules.c
index 62c0d64..dd18757 100644
--- a/src/rules.c
+++ b/src/rules.c
@@ -92,6 +92,7 @@ static struct {
 	"``1234567890-=qqwertyuiop[aasdfghjkl;zzxcvbnm,." \
 	"~~!@#$%^&*()_+QQWERTYUIOP{AASDFGHJKL:ZZXCVBNM<>"
 
+// yY variants will be both consonants and vowels when --encoding is used
 #define CHARS_VOWELS \
 	"aeiouAEIOU"
 #define CHARS_CONSONANTS \
-- 
1.7.4.1

