private IEnumerable <NamedRange> GetNamedRanges(LineReader reader)
{
List <string> segs = new List <string>();
foreach (var count in reader.GetLines(segs, 2))
{
int begin;
int end;
if (TryParseCodeRange(segs[0], out begin, out end))
{
yield return(new NamedRange(begin, end, segs[1]));
}
}
}
private IEnumerable <EnumRange <T> > GetRanges <T>(LineReader reader, Func <string, T> parse)
{
List <string> segs = new List <string>();
foreach (var count in reader.GetLines(segs, 2))
{
int begin;
int end;
if (TryParseCodeRange(segs[0], out begin, out end))
{
yield return(new EnumRange <T>(begin, end, parse(segs[1])));
}
}
}
private CaseFoldingEntry[] GetCaseFolding()
{
List <CaseFoldingEntry> list = new List <CaseFoldingEntry>();
List <string> segs = new List <string>();
List <int> codeList = new List <int>();
using (LineReader reader = OpenLineReader("CaseFolding.txt")) {
foreach (var count in reader.GetLines(segs, 3))
{
var entry = new CaseFoldingEntry();
if (!TryParseHex(segs[0], out entry.Code))
{
continue;
}
var status = segs[1].Trim();
if (status.Length != 1)
{
continue;
}
switch (status[0])
{
case 'C':
entry.Status = CaseFoldingStatus.Common;
break;
case 'F':
entry.Status = CaseFoldingStatus.Full;
break;
case 'S':
entry.Status = CaseFoldingStatus.Simple;
break;
case 'T':
entry.Status = CaseFoldingStatus.Special;
break;
default:
continue;
}
if (TryParseHex(codeList, segs[2], out entry.Mapping))
{
list.Add(entry);
}
}
}
list.Sort();
return(list.ToArray());
}
// http://www.unicode.org/reports/tr44/#Property_And_Value_Aliases
public void LoadAliases()
{
List <string> segs = new List <string>();
Dictionary <string, AliasSection> sections =
new Dictionary <string, AliasSection>(StringComparer.OrdinalIgnoreCase);
using (LineReader reader = OpenLineReader("PropertyValueAliases.txt")) {
foreach (var count in reader.GetLines(segs, 2))
{
AliasSection section;
string propertyName = segs[0];
if (!sections.TryGetValue(propertyName, out section))
{
section = new AliasSection()
{
Name = propertyName
};
sections.Add(section.Name, section);
}
}
}
}
public void LoadScripts(LineReader reader, bool standard)
{
string line;
List <string> segs = new List <string>();
List <int> commons = new List <int>();
foreach (var count in reader.GetLines(segs, 2))
{
line = segs[1];
WritingScript script;
commons.Clear();
if (!_scripts.TryGetValue(line, out script) && !Enum.TryParse(line, true, out script))
{
if (standard || line.IndexOf(' ') < 0)
{
_owner.Error($"Unable to find script '{line}'");
}
else
{
foreach (var s in line.SplitAtSpaces())
{
if (!_scripts.TryGetValue(s, out script))
{
_owner.Error($"Unable to find script '{s}'");
}
else
{
commons.Add((int)script);
}
}
//Debug.WriteLine( line );
}
}
else if (!standard)
{
commons.Add((int)script);
}
int cIndex = extScripts.IndexOf(commons);
if (cIndex < 0)
{
cIndex = extScripts.Count;
extScripts.AddRange(commons);
}
line = segs[0];
int from;
int to;
int idx = line.IndexOf("..", StringComparison.Ordinal);
if (idx > 0)
{
string text = line.Substring(idx + 2);
if (!TryParseHex(text, out to))
{
_owner.Error("Invalid code value '{0}'", text);
}
text = line.Substring(0, idx).Trim();
if (!TryParseHex(text, out from))
{
_owner.Error("Invalid code value '{0}'", text);
}
if (from > _owner._maxCodePoint)
{
continue;
}
}
else
{
if (!TryParseHex(line, out from))
{
_owner.Error("Invalid code value '{0}'", line);
}
else
{
if (from > _owner._maxCodePoint)
{
continue;
}
}
to = from;
}
if (standard)
{
SetScriptsToCode(from, to, script, standard);
}
else
{
SetScriptRangeToCode(from, to, cIndex, ( byte)commons.Count, standard);
}
}
}
public static IEnumerable <int> GetLines(Stream str, List <string> segs, TextReaderOptions options)
{
using (LineReader r = new LineReader(str, options)) {
return(r.GetLines(segs, 1));
}
}
public void Load(LineReader reader)
{
Dictionary <int, string> alternativeNames = _owner.AlternativeNames;
List <string> segs = new List <string>();
int firstRange = 0;
int lastRange = 0;
const string FirstRange = ", First>";
const string LastRange = ", Last>";
foreach (var count in reader.GetLines(segs, 15))
{
if (count != 15)
{
continue;
}
_entry = new UnicodeEntry();
if (!TryParseHex(segs[0], out _entry.CodeValue))
{
continue;
}
if (_entry.CodeValue > _owner._maxCodePoint)
{
break;
}
string name = segs[1];
string dscr;
if ((Options & LoadOptions.AlternativeNames) != 0 &&
alternativeNames.TryGetValue(_entry.CodeValue, out dscr))
{
name = dscr;
}
else
{
dscr = name;
if (name.HasValue())
{
if (name[0] == '<')
{
if (name.SameName("<control>"))
{
dscr = segs[10];
}
else if (name.EndsWith(FirstRange, StringComparison.OrdinalIgnoreCase))
{
firstRange = _entry.CodeValue;
name = name.Substring(1, name.Length - 1 - FirstRange.Length);
dscr = null;
}
else if (name.EndsWith(LastRange, StringComparison.OrdinalIgnoreCase))
{
name = name.Substring(1, name.Length - 1 - LastRange.Length);
dscr = null;
lastRange = _entry.CodeValue;
}
else
{
Debug.WriteLine("Asd:" + name);
}
}
}
}
if (dscr.HasValue())
{
if ((Options & LoadOptions.EnumNames) != 0)
{
_entry.EnumName = Util.GenEnumName(dscr);
}
}
else if (!alternativeNames.TryGetValue(_entry.CodeValue, out dscr))
{
//Debug.WriteLine( "NO NAME " + _entry.CodeValue.ToString( "X4" ) + " " + segs[ 11 ] );
}
_entry.Name = name;
if (!_charTypes.TryGetValue(segs[2], out _entry.Category))
{
Error("Unknown category '{0}'", segs[2]);
}
byte comb;
if (!byte.TryParse(segs[3], NumberStyles.Integer, CultureInfo.InvariantCulture, out comb))
{
Error("Unknown combing class '{0}'", segs[3]);
}
_entry.Combing = (CombingClass)comb;
if (!_bidiMap.TryGetValue(segs[4], out _entry.Bidirectional))
{
Error("Unknown bidi category '{0}'", segs[4]);
}
if (_decomposeMap != null && !string.IsNullOrEmpty(segs[5]))
{
ParseDecombosing(segs[5]);
}
//_entry._numericType = NumericEntryType.None;
byte dec;
if (segs[6].Length > 0)
{
if (!byte.TryParse(segs[6], NumberStyles.Integer,
CultureInfo.InvariantCulture, out dec) ||
dec > 9)
{
Error("Invalid Decimal digit value '{0}'", segs[6]);
}
_entry._numericType = NumericEntryType.Decimal;
_entry._value.Value = dec;
//_Decimals.Increment( _entry.DecimalValue );
}
if (segs[7].Length > 0)
{
if (!byte.TryParse(segs[7], NumberStyles.Integer,
CultureInfo.InvariantCulture, out dec) ||
dec > 9)
{
Error("Invalid Digit value '{0}'", segs[7]);
}
if (!_entry.IsDecimalDigit)
{
_entry._numericType = NumericEntryType.Digit;
_entry._value.Value = dec;
}
else if (_entry._value.Value != dec)
{
Error("Invalid Digit value '{0}'", segs[7]);
}
}
else if (_entry._numericType != NumericEntryType.None)
{
Error("Invalid Digit value '{0}'", segs[7]);
}
if (segs[8].Length > 0)
{
ParseNumeric(segs[8]);
}
switch (segs[9])
{
case "":
case "N":
break;
case "Y":
_entry.Mirrored = true;
break;
default:
Error("Invalid Mirrored value '{0}'", segs[9]);
break;
}
if ((Options & LoadOptions.OldNames) != 0 &&
segs[10].Length > 0)
{
_entry.OldName = segs[10];
}
if ((Options & LoadOptions.Comments) != 0 &&
segs[11].Length > 0)
{
_entry.Comment = segs[11];
}
if (segs[12].Length > 0)
{
if (!TryParseHex(segs[12], out _entry.Uppercase))
{
Error("Invlaid code point '{0}'", segs[12]);
}
}
if (segs[13].Length > 0)
{
if (!TryParseHex(segs[13], out _entry.LowerCase))
{
Error("Invlaid code point '{0}'", segs[13]);
}
}
if (segs[14].Length > 0)
{
if (!TryParseHex(segs[14], out _entry.TitleCase))
{
Error("Invlaid code point '{0}'", segs[14]);
}
}
if (lastRange > 0)
{
_entry.CodeValue = firstRange + 1;
while (_entry.CodeValue < lastRange)
{
Add(_entry);
_entry.CodeValue++;
}
lastRange = 0;
firstRange = 0;
}
Add(_entry);
}
//ShowCounts();
}