private static BaseLexerRule NotDoubleQuote()
{
// ([^"]|(\\.))*
var start = new DfaState();
var escape = new DfaState();
var final = new DfaState(true);
var notDoubleQuoteTerminal = new NegationTerminal(
new CharacterTerminal('"'));
var escapeTerminal = new CharacterTerminal('\\');
var anyTerminal = new AnyTerminal();
var notDoubleQuoteEdge = new DfaTransition(notDoubleQuoteTerminal, final);
start.AddTransition(notDoubleQuoteEdge);
final.AddTransition(notDoubleQuoteEdge);
var escapeEdge = new DfaTransition(escapeTerminal, escape);
start.AddTransition(escapeEdge);
final.AddTransition(escapeEdge);
var anyEdge = new DfaTransition(anyTerminal, final);
escape.AddTransition(anyEdge);
return(new DfaLexerRule(start, TokenTypes.NotDoubleQuote));
}
private static ILexerRule CreateNotDoubleQuoteLexerRule()
{
// ( [^"\\] | (\\ .) ) +
var start = new DfaState();
var escape = new DfaState();
var final = new DfaState(true);
var notQuoteTerminal = new NegationTerminal(
new SetTerminal('"', '\\'));
var escapeTerminal = new CharacterTerminal('\\');
var anyTerminal = new AnyTerminal();
var notQuoteEdge = new DfaTransition(notQuoteTerminal, final);
start.AddTransition(notQuoteEdge);
final.AddTransition(notQuoteEdge);
var escapeEdge = new DfaTransition(escapeTerminal, escape);
start.AddTransition(escapeEdge);
final.AddTransition(escapeEdge);
var anyEdge = new DfaTransition(anyTerminal, final);
escape.AddTransition(anyEdge);
return(new DfaLexerRule(start, new TokenType("not-double-quote")));
}
private static ILexerRule DoubleQuoteString()
{
var start = new DfaState();
var loop = new DfaState();
var esc = new DfaState();
var end = new DfaState(isFinal: true);
var doubleQuote = new CharacterTerminal('"');
var notDoubleQuote = new NegationTerminal(doubleQuote);
var escape = new CharacterTerminal('\\');
var any = new AnyTerminal();
// (start) - " -> (loop)
start.AddTransition(doubleQuote, loop);
// (loop) - [^"] -> (loop)
// - \ -> (esc)
// - " -> (end)
loop.AddTransition(notDoubleQuote, loop);
loop.AddTransition(escape, esc);
loop.AddTransition(doubleQuote, end);
// (esc) - . -> (loop)
esc.AddTransition(any, loop);
return(new DfaLexerRule(start, "double-quote-string"));
}
private static BaseLexerRule CreateMultiLineCommentLexerRule()
{
var pattern = @"\/[*]([*][^\/]|[^*])*[*][\/]";
var states = new DfaState[5];
for (int i = 0; i < states.Length; i++)
{
states[i] = new DfaState();
}
var slash = new CharacterTerminal('/');
var star = new CharacterTerminal('*');
var notStar = new NegationTerminal(star);
var notSlash = new NegationTerminal(slash);
var firstSlash = new DfaTransition(slash, states[1]);
var firstStar = new DfaTransition(star, states[2]);
var repeatNotStar = new DfaTransition(notStar, states[2]);
var lastStar = new DfaTransition(star, states[3]);
var goBackNotSlash = new DfaTransition(notSlash, states[2]);
var lastSlash = new DfaTransition(slash, states[4]);
states[0].AddTransition(firstSlash);
states[1].AddTransition(firstStar);
states[2].AddTransition(repeatNotStar);
states[2].AddTransition(lastStar);
states[3].AddTransition(goBackNotSlash);
states[3].AddTransition(lastSlash);
return(new DfaLexerRule(states[0], pattern));
}
private static BaseLexerRule MultiLineComment()
{
var states = new DfaState[5];
for (int i = 0; i < states.Length; i++)
{
states[i] = new DfaState();
}
var slash = new CharacterTerminal('/');
var star = new CharacterTerminal('*');
var notStar = new NegationTerminal(star);
var notSlash = new NegationTerminal(slash);
var firstSlash = new DfaTransition(slash, states[1]);
var firstStar = new DfaTransition(star, states[2]);
var repeatNotStar = new DfaTransition(notStar, states[2]);
var lastStar = new DfaTransition(star, states[3]);
var goBackNotSlash = new DfaTransition(notSlash, states[2]);
var lastSlash = new DfaTransition(slash, states[4]);
states[0].AddTransition(firstSlash);
states[1].AddTransition(firstStar);
states[2].AddTransition(repeatNotStar);
states[2].AddTransition(lastStar);
states[3].AddTransition(goBackNotSlash);
states[3].AddTransition(lastSlash);
return(new DfaLexerRule(states[0], TokenTypes.MultiLineComment));
}
public void NegationTerminalShouldReturnInverseIntervals()
{
var negationTerminal = new NegationTerminal(AnyTerminal.Instance);
var intervals = negationTerminal.GetIntervals();
Assert.AreEqual(0, intervals.Count);
}
private static LexerRule CreateMultiLineCommentLexerRule()
{
var states = new[]
{
DfaState.Inner(),
DfaState.Inner(),
DfaState.Inner(),
DfaState.Inner(),
DfaState.Final(),
};
var slash = new CharacterTerminal('/');
var star = new CharacterTerminal('*');
var notStar = new NegationTerminal(star);
var notSlash = new NegationTerminal(slash);
//var firstSlash = new DfaTransition(slash, states[1]);
//var firstStar = new DfaTransition(star, states[2]);
//var repeatNotStar = new DfaTransition(notStar, states[2]);
//var lastStar = new DfaTransition(star, states[3]);
//var goBackNotSlash = new DfaTransition(notSlash, states[2]);
//var lastSlash = new DfaTransition(slash, states[4]);
states[0].AddTransition(slash, states[1]);
states[1].AddTransition(star, states[2]);
states[2].AddTransition(notStar, states[2]);
states[2].AddTransition(star, states[3]);
states[3].AddTransition(notSlash, states[2]);
states[3].AddTransition(slash, states[4]);
return(new DfaLexerRule(states[0], new TokenName(@"\/[*]([*][^\/]|[^*])*[*][\/]")));
}
public void NegationTerminalShouldNegateAnyTerminal()
{
var negationTerminal = new NegationTerminal(AnyTerminal.Instance);
Assert.IsFalse(negationTerminal.CanApply('a'));
Assert.IsFalse(negationTerminal.CanApply(char.MaxValue));
Assert.IsFalse(negationTerminal.CanApply('0'));
}
public void NegationTerminalShouldNegateAnyTerminal()
{
var anyTerminal = new AnyTerminal();
var negationTerminal = new NegationTerminal(anyTerminal);
Assert.IsFalse(negationTerminal.IsMatch('a'));
Assert.IsFalse(negationTerminal.IsMatch(char.MaxValue));
Assert.IsFalse(negationTerminal.IsMatch('0'));
}
private static LexerRule CreateNotSingleQuoteLexerRule()
{
var start = DfaState.Inner();
var final = DfaState.Final();
var terminal = new NegationTerminal(new CharacterTerminal('\''));
start.AddTransition(terminal, final);
final.AddTransition(terminal, final);
return(new DfaLexerRule(start, "not-single-quote"));
}
private static ILexerRule CreateNotSingleQuoteLexerRule()
{
var start = new DfaState();
var final = new DfaState(true);
var terminal = new NegationTerminal(new CharacterTerminal('\''));
var edge = new DfaTransition(terminal, final);
start.AddTransition(edge);
final.AddTransition(edge);
return(new DfaLexerRule(start, new TokenType("not-single-quote")));
}
private static BaseLexerRule NotSingleQuote()
{
// ([^']|(\\.))*
var start = new DfaState();
var final = new DfaState(true);
var terminal = new NegationTerminal(new CharacterTerminal('\''));
var edge = new DfaTransition(terminal, final);
start.AddTransition(edge);
final.AddTransition(edge);
return(new DfaLexerRule(start, TokenTypes.NotSingleQuote));
}
private static AtomTerminal CreateTerminalForCharacter(char value, bool isEscaped, bool negate)
{
AtomTerminal terminal;
if (!isEscaped)
{
terminal = new CharacterTerminal(value);
}
else
{
switch (value)
{
case 's':
terminal = WhitespaceTerminal.Instance;
break;
case 'd':
terminal = DigitTerminal.Instance;
break;
case 'w':
terminal = WordTerminal.Instance;
break;
case 'D':
terminal = DigitTerminal.Instance;
negate = !negate;
break;
case 'S':
terminal = WhitespaceTerminal.Instance;
negate = !negate;
break;
case 'W':
terminal = WordTerminal.Instance;
negate = !negate;
break;
default:
terminal = new CharacterTerminal(value);
break;
}
}
if (negate)
{
terminal = new NegationTerminal(terminal);
}
return(terminal);
}
static SimpleDoubleQuoteStringLexerRule()
{
var start = DfaState.Inner();
var inner = DfaState.Inner();
var final = DfaState.Final();
var quote = new CharacterTerminal('"');
var notQuote = new NegationTerminal(quote);
start.AddTransition(quote, inner);
inner.AddTransition(notQuote, inner);
inner.AddTransition(quote, final);
enter = start;
}
private static LexerRule CreateSingleLineComment()
{
var slash = new CharacterTerminal('/');
var newLine = new CharacterTerminal('\n');
var notNewLine = new NegationTerminal(newLine);
var start = DfaState.Inner();
var oneSlash = DfaState.Inner();
var twoSlash = DfaState.Final();
start.AddTransition(slash, oneSlash);
oneSlash.AddTransition(slash, twoSlash);
twoSlash.AddTransition(notNewLine, twoSlash);
return(new DfaLexerRule(start, TokenClasses.SingleLineComment));
}
private static INfa Range(RegexCharacterRange range, bool negate)
{
// combine characters into a character range terminal
var start = range.StartCharacter.Value;
var end = range.EndCharacter.Value;
ITerminal terminal = new RangeTerminal(start, end);
var nfaStartState = new NfaState();
var nfaEndState = new NfaState();
if (negate)
{
terminal = new NegationTerminal(terminal);
}
nfaStartState.AddTransistion(
new TerminalNfaTransition(terminal, nfaEndState));
return(new Nfa(nfaStartState, nfaEndState));
}
private static LexerRule CreateNotDoubleQuoteLexerRule()
{
// ( [^"\\] | (\\ .) ) +
var start = DfaState.Inner();
var escape = DfaState.Inner();
var final = DfaState.Final();
var notQuoteTerminal = new NegationTerminal(new SetTerminal("\"\\"));
var escapeTerminal = new CharacterTerminal('\\');
start.AddTransition(notQuoteTerminal, final)
.AddTransition(escapeTerminal, escape);
final.AddTransition(notQuoteTerminal, final)
.AddTransition(escapeTerminal, escape);
escape.AddTransition(AnyTerminal.Instance, final);
return(new DfaLexerRule(start, "not-double-quote"));
}
static SingleQuoteStringLexerRule()
{
var states = new DfaState[3];
for (var i = 0; i < states.Length; i++)
{
states[i] = new DfaState(i == 2);
}
var quote = new CharacterTerminal('\'');
var notQuote = new NegationTerminal(quote);
var quoteToNotQuote = new DfaTransition(quote, states[1]);
var notQuoteToNotQuote = new DfaTransition(notQuote, states[1]);
var notQuoteToQuote = new DfaTransition(quote, states[2]);
states[0].AddTransition(quoteToNotQuote);
states[1].AddTransition(notQuoteToNotQuote);
states[1].AddTransition(notQuoteToQuote);
_start = states[0];
}
private static LexerRule CreateMultiLineCommentLexerRule()
{
var states = new DfaState[5];
for (var i = 0; i < states.Length; i++)
{
states[i] = DfaState.Inner();
}
var slash = new CharacterTerminal('/');
var star = new CharacterTerminal('*');
var notStar = new NegationTerminal(star);
var notSlash = new NegationTerminal(slash);
states[0].AddTransition(slash, states[1]);
states[1].AddTransition(star, states[2]);
states[2].AddTransition(notStar, states[2]);
states[2].AddTransition(star, states[3]);
states[3].AddTransition(notSlash, states[2]);
states[3].AddTransition(slash, states[4]);
return(new DfaLexerRule(states[0], TokenClasses.MultiLineComment));
}
private static INfa Character(RegexCharacterClassCharacter character, bool negate)
{
var start = new NfaState();
var end = new NfaState();
ITerminal terminal = null;
if (!character.IsEscaped)
{
terminal = new CharacterTerminal(character.Value);
}
else
{
switch (character.Value)
{
case 's':
terminal = new WhitespaceTerminal();
break;
case 'd':
terminal = new DigitTerminal();
break;
case 'w':
terminal = new WordTerminal();
break;
case 'D':
terminal = new DigitTerminal();
negate = !negate;
break;
case 'S':
terminal = new WhitespaceTerminal();
negate = !negate;
break;
case 'W':
terminal = new WordTerminal();
negate = !negate;
break;
default:
terminal = new CharacterTerminal(character.Value);
break;
}
}
if (negate)
{
terminal = new NegationTerminal(terminal);
}
var transition = new TerminalNfaTransition(
terminal: terminal,
target: end);
start.AddTransistion(transition);
return(new Nfa(start, end));
}
