private bool MatchDomainNamePart(Subject subject)
{
if (!_domainNameStartChars.Contains(subject.Char))
{
return(false);
}
subject.AdvanceWhile(c => _domainNameChars.Contains(c), 62);
return(_domainNameStartChars.Contains(subject[-1]));
}
private bool MatchDeclaration(Subject subject)
{
if (!subject.StartsWith("<!"))
{
return(false);
}
var saved = subject.Save();
subject.Advance(2);
if (subject.AdvanceWhile(c => _declarationChars.Contains(c)) > 0)
{
subject.SkipWhiteSpace();
subject.AdvanceWhileNot('>');
if (subject.Char == '>')
{
subject.Advance();
return(true);
}
}
saved.Restore();
return(false);
}
public bool Parse(ParserContext context, Subject subject)
{
var saved = subject.Save();
subject.AdvanceWhile(' ', 3);
if (subject.Char == '<')
{
subject.Advance();
if (subject.Char == '!' || subject.Char == '?')
{
subject.Advance();
}
else
{
if (subject.Char == '/')
{
subject.Advance();
var tagName = subject.TakeWhile(c => _tagNameChars.Contains(c), _maxTagNameLength);
if ((subject.Char != ' ' && subject.Char != '>') || !_tagNames.Contains(tagName))
{
saved.Restore();
return(false);
}
}
else
{
var tagName = subject.TakeWhile(c => _tagNameChars.Contains(c), _maxTagNameLength);
if ((subject.Char != ' ' && subject.Char != '>' && !subject.StartsWith("/>")) || !_tagNames.Contains(tagName))
{
saved.Restore();
return(false);
}
}
}
context.AddBlock(new HtmlBlock());
context.BlocksParsed = true;
// note, we restore subject because the tag is part of the text
saved.Restore();
return(true);
}
saved.Restore();
return(false);
}
private bool MatchUnquotedValue(Subject subject)
{
if (subject.AdvanceWhile(c => !_unquotedValueChars.Contains(c)) > 0)
{
return(true);
}
return(false);
}
private bool MatchTagName(Subject subject)
{
if (_tagNameStartChars.Contains(subject.Char))
{
subject.AdvanceWhile(c => _tagNameChars.Contains(c));
return(true);
}
return(false);
}
public override bool Execute(State state)
{
if (charSet.Contains(state.CurrentCharacter, state.IgnoreCase))
{
state.Position++;
return(true);
}
state.InstructionIndex++;
return(true);
}
public void CharSetNotContains()
{
// Arrange
CharSet chars = "abcABC";
// Act
var actual = chars.Contains('X');
// Assert
Assert.IsFalse(actual);
}
public void CharSetContains()
{
// Arrange
CharSet chars = "abcABC";
// Act
var actual = chars.Contains('B');
// Assert
Assert.IsTrue(actual);
}
public InlineString Parse(ParserContext context, Subject subject)
{
if (!CanParse(subject))
{
return(null);
}
if (subject.Char == '\\' && PunctuationChars.Contains(subject[1]))
{
subject.Advance(2);
return(new InlineString(subject[-1]));
}
return(null);
}
/// <summary>
/// Gets current character token and matches it agains provided set
/// </summary>
/// <param name="set">Character set to check current char belongs to</param>
/// <param name="nextline">Indicates if returning of line end sequence is allowed</param>
/// <param name="inner">Optional function to check for inner sequences which will be treated as compound character token</param>
/// <param name="token">Resulting token in case of match</param>
/// <param name="increment">Indicates if current source position needs to be advanced in case of match</param>
/// <returns>Returns <c>true</c> in case of match</returns>
/// <remarks>
/// <paramref name="set"/> must not be <c>null</c>.
/// If character doesn't match given set and it's not any inner sequence
/// function returns <c>false</c>
/// </remarks>
protected bool CheckCharToken(CharSet set, bool nextline, InnerScan inner, out SourceToken token, bool increment = true)
{
Debug.Assert(set != null, "set must not be null");
var result =
GetCharToken(nextline, inner, out token, false) &&
(token.Length > 1 || set.Contains(_source.CharCurrent));
if (result && increment)
{
_source.Advance(token.Length);
}
return(result);
}
/// <summary>
/// 返回指定的字符对应的字符类索引。
/// </summary>
/// <param name="ch">要获取字符类索引的字符。</param>
/// <returns>字符对应的字符类索引。</returns>
public HashSet <int> GetCharClass(char ch)
{
int cnt = charClassList.Count;
HashSet <int> result = new HashSet <int>();
for (int i = 0; i < cnt; i++)
{
CharSet cc = charClassList[i];
if (cc.Contains(ch))
{
if (cc.Count == 1)
{
// 完全包含当前字符类，直接添加。
result.Add(i);
}
else
{
// 当前的字符类需要被分割，从当前的字符类中剔除被分割的部分。
cc.Remove(ch);
// 添加新字符类。
int newCC = charClassList.Count;
result.Add(newCC);
charClassList.Add(new CharSet()
{
ch
});
// 这里虽然在 charClassRecord 里添加了新的项，但完全没有必要记录。
// 因为当前的字符类只包含一个字符，不可能再被分割了。
charClassRecord.Add(null);
// 更新旧的字符类。
List <HashSet <int> > record = charClassRecord[i];
int rCnt = record.Count;
for (int j = 0; j < rCnt; j++)
{
record[j].Add(newCC);
}
}
}
}
return(result);
}
/// <summary>
/// Returns a value indicating whether the next character matches the lexical rule.
/// </summary>
/// <param name="reader">The <see cref="BranchedReader"/> that provides the input character.</param>
/// <returns><see langword="true"/> if the next character matches the lexical rule; otherwise <see langword="false"/>.</returns>
/// <exception cref="ArgumentNullException"><paramref name="reader"/> is <see langword="null"/>.</exception>
public override bool Match(BranchedReader reader)
{
if (reader == null)
{
throw new ArgumentNullException();
}
char c = reader.Read();
if (c == '\0')
{
return(false);
}
if (!CharSet.Contains(c))
{
return(true);
}
else
{
return(false);
}
}
public DataValidateResult Validate(string value)
{
DataValidateResult result = new DataValidateResult();
if (value != null && value.ToString().Trim().Length > 0)
{
try
{
Char c = Convert.ToChar(value);
if (!CharSet.Contains(c))
{
result.AddItem(Message);
}
}
catch
{
result.AddItem(Message);
}
}
return(result);
}
// execute test cases for Scanner.CharSet helper class
public static void TestCharSet()
{
var charset = new CharSet();
charset.Add('A', 'Z');
charset.Add('a', 'z');
charset.Add('_');
TestCase(
"Contains: {0}",
(d) =>
{
var result = 0;
foreach (var c in d)
{
if (charset.Contains(c))
{
++result;
}
}
return(result);
},
8,
"heloTES_"
);
TestCase(
"Does not contain: {0}",
(d) =>
{
var result = 0;
foreach (var c in d)
{
if (!charset.Contains(c))
{
++result;
}
}
return(result);
},
8,
"61=^;.!0"
);
var charset2 = new Scanner.CharSet(charset);
charset.Add('0', '9');
TestCase(
"Contains: {0}",
(d) =>
{
var result = 0;
foreach (var c in d)
{
if (charset.Contains(c))
{
++result;
}
}
return(result);
},
8,
"_F0hT7bZ"
);
TestCase(
"Does not contain: {0}",
(d) =>
{
var result = 0;
foreach (var c in d)
{
if (!charset.Contains(c))
{
++result;
}
}
return(result);
},
8,
";=(%!.,{"
);
Console.WriteLine();
}
private static bool MatchEmailName(Subject subject)
{
return(subject.AdvanceWhile(c => _emailNameChars.Contains(c)) > 0);
}
