public void AddKeyWord(IN token, string keyword)
{
NodeCallback <GenericToken> callback = (FSMMatch <GenericToken> match) =>
{
if (derivedTokens.ContainsKey(GenericToken.Identifier))
{
Dictionary <string, IN> derived = derivedTokens[GenericToken.Identifier];
if (derived.ContainsKey(match.Result.Value))
{
match.Properties[DerivedToken] = derived[match.Result.Value];
}
else if (derived.ContainsKey(defaultIdentifierKey))
{
match.Properties[DerivedToken] = identifierDerivedToken;
}
}
else
{
match.Properties[DerivedToken] = identifierDerivedToken;
}
return(match);
};
AddLexeme(GenericToken.Identifier, token, keyword);
FSMBuilder.GoTo(in_identifier);
var node = FSMBuilder.GetNode(in_identifier);
if (!FSMBuilder.Fsm.HasCallback(node.Id))
{
FSMBuilder.GoTo(in_identifier).
CallBack(callback);
}
}
private static void AddExponentExtension(DoubleExponent token, LexemeAttribute lexem, GenericLexer <DoubleExponent> lexer)
{
if (token == DoubleExponent.DOUBLE_EXP)
{
// callback on end_exponent node
NodeCallback <GenericToken> callback = (FSMMatch <GenericToken> match) =>
{
string[] items = match.Result.Value.Split(new[] { 'e', 'E' });
double radix = 0;
double.TryParse(items[0].Replace(".", ","), out radix);
double exponent = 0;
double.TryParse(items[1], out exponent);
double value = Math.Pow(radix, exponent);
match.Result.SpanValue = value.ToString().AsMemory();
match.Properties[GenericLexer <DoubleExponent> .DerivedToken] = DoubleExponent.DOUBLE_EXP;
return(match);
};
var fsmBuilder = lexer.FSMBuilder;
fsmBuilder.GoTo(GenericLexer <DoubleExponent> .in_double) // start a in_double node
.Transition(new char[] { 'E', 'e' }) // add a transition on '.' with precondition
.Transition(new char[] { '+', '-' })
.Mark("start_exponent_val")
.RangeTransitionTo('0', '9', "start_exponent_val") // first year digit
.Mark("end_exponent")
.End(GenericToken.Extension) // mark as ending node
.CallBack(callback); // set the ending callback
}
}
public void AddKeyWord(IN token, string keyword, BuildResult <ILexer <IN> > result)
{
NodeCallback <GenericToken> callback = match =>
{
IN derivedToken;
if (derivedTokens.TryGetValue(GenericToken.Identifier, out var derived))
{
if (!derived.TryGetValue(match.Result.Value, out derivedToken))
{
derivedToken = identifierDerivedToken;
}
}
else
{
derivedToken = identifierDerivedToken;
}
match.Properties[DerivedToken] = derivedToken;
return(match);
};
AddLexeme(GenericToken.Identifier, result, token, keyword);
var node = FSMBuilder.GetNode(in_identifier);
if (!FSMBuilder.Fsm.HasCallback(node.Id))
{
FSMBuilder.GoTo(in_identifier).CallBack(callback);
}
}
public static void SymbolExtension(LispLexer token, LexemeAttribute lexem, GenericLexer <LispLexer> lexer)
{
if (token == LispLexer.SYMBOL)
{
// callback on end_date node
NodeCallback <GenericToken> callback = (FSMMatch <GenericToken> match) =>
{
// this store the token id the the FSMMatch object to be later returned by GenericLexer.Tokenize
match.Properties[GenericLexer <LispLexer> .DerivedToken] = LispLexer.SYMBOL;
return(match);
};
var fsmBuilder = lexer.FSMBuilder;
var symbolCharExclusions = new char[]
{ '(', ')', '|', '#', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '.', ' ', '\'', '\r', '\n' };
fsmBuilder.GoTo(GenericLexer <LispLexer> .start)
.ExceptTransition(symbolCharExclusions)
.Mark("end_symbol")
.ExceptTransitionTo(symbolCharExclusions, "end_symbol")
.End(GenericToken.Extension)
.CallBack(callback);
var graph = fsmBuilder.Fsm.ToGraphViz();
;
}
}
public FSMLexerBuilder <N> CallBack(NodeCallback <N> callback)
{
if (Fsm.HasState(CurrentState))
{
Fsm.SetCallback(CurrentState, callback);
}
return(this);
}
private static NodeCallback <GenericToken> GetCallbackMulti <IN>(IN token, bool doNotIgnore) where IN : struct
{
NodeCallback <GenericToken> callbackMulti = match =>
{
match.Properties[GenericLexer <IN> .DerivedToken] = token;
match.Result.IsComment = true;
match.Result.Notignored = doNotIgnore;
match.Result.CommentType = CommentType.Multi;
return(match);
};
return(callbackMulti);
}
public void RemoveAgent(Agent agent)
{
if (trvCurPln.InvokeRequired) {
NodeCallback d = new NodeCallback(RemoveAgent);
trvCurPln.Invoke(d, new object[] { agent });
} else {
if (agent is Operator || agent is Controller) {
trvCurPln.Nodes[0].Nodes.Remove(agent);
} else {
trvCurPln.Nodes[1].Nodes[(int)agent.Type].Nodes.Remove(agent);
trvCurPln.Nodes[1].Nodes[(int)agent.Type].Text = agentTypes[(int)agent.Type] + " (" + trvCurPln.Nodes[1].Nodes[(int)agent.Type].Nodes.Count + ")";
}
}
}
public static void AddExtension(Extensions token, LexemeAttribute lexem, GenericLexer <Extensions> lexer)
{
if (token == Extensions.DATE)
{
NodeCallback <GenericToken> callback = match =>
{
match.Properties[GenericLexer <Extensions> .DerivedToken] = Extensions.DATE;
return(match);
};
var fsmBuilder = lexer.FSMBuilder;
fsmBuilder.GoTo(GenericLexer <Extensions> .in_double)
.Transition('.', CheckDate)
.Mark("start_date")
.RepetitionTransition(4, "[0-9]")
.End(GenericToken.Extension)
.CallBack(callback);
}
}
public void AddSugarLexem(IN token, string specialValue)
{
if (char.IsLetter(specialValue[0]))
{
throw new InvalidLexerException($"bad lexem {specialValue} : SugarToken lexeme <{token.ToString()}> can not start with a letter.");
}
NodeCallback <GenericToken> callback = (FSMMatch <GenericToken> match) =>
{
match.Properties[DerivedToken] = token;
return(match);
};
FSMBuilder.GoTo(start);
for (int i = 0; i < specialValue.Length; i++)
{
FSMBuilder.SafeTransition(specialValue[i]);
}
FSMBuilder.End(GenericToken.SugarToken)
.CallBack(callback);
}
public void AddNewAgent(Agent agent)
{
if (trvCurPln.InvokeRequired) {
NodeCallback d = new NodeCallback(AddNewAgent);
trvCurPln.Invoke(d, new object[] { agent });
} else {
// Check if a simulation agent has been added
if ((int)agent.Type < 4) {
trvCurPln.Nodes[1].Nodes[(int)agent.Type].Nodes.Add(agent);
trvCurPln.Nodes[1].Nodes[(int)agent.Type].Text = agentTypes[(int)agent.Type] + " (" + trvCurPln.Nodes[1].Nodes[(int)agent.Type].Nodes.Count + ")";
} else {
int newNode = trvCurPln.Nodes[0].Nodes.Add(agent);
trvCurPln.Nodes[0].Nodes[newNode].Text = agentTypes[(int)agent.Type];
}
int totAgents = 0;
for (int i = 0; i < trvCurPln.Nodes[1].Nodes.Count; i++) {
totAgents += trvCurPln.Nodes[1].Nodes[i].Nodes.Count;
}
trvCurPln.Nodes[1].Text = "Simulation Agents (" + totAgents + ")";
}
}
public void AddSugarLexem(IN token, BuildResult <ILexer <IN> > buildResult, string specialValue, bool isLineEnding = false)
{
if (char.IsLetter(specialValue[0]))
{
buildResult.AddError(new InitializationError(ErrorLevel.FATAL,
$"bad lexem {specialValue} : SugarToken lexeme <{token.ToString()}> can not start with a letter.", ErrorCodes.LEXER_SUGAR_TOKEN_CANNOT_START_WITH_LETTER));
return;
}
NodeCallback <GenericToken> callback = match =>
{
match.Properties[DerivedToken] = token;
return(match);
};
FSMBuilder.GoTo(start);
for (var i = 0; i < specialValue.Length; i++)
{
FSMBuilder.SafeTransition(specialValue[i]);
}
FSMBuilder.End(GenericToken.SugarToken, isLineEnding)
.CallBack(callback);
}
public void AddCharLexem(IN token, BuildResult <ILexer <IN> > result, string charDelimiter, string escapeDelimiterChar = "\\")
{
if (string.IsNullOrEmpty(charDelimiter) || charDelimiter.Length > 1)
{
result.AddError(new InitializationError(ErrorLevel.FATAL,
$"bad lexem {charDelimiter} : CharToken lexeme delimiter char <{token.ToString()}> must be 1 character length.",
ErrorCodes.LEXER_CHAR_ESCAPE_CHAR_MUST_BE_1_CHAR));
}
if (charDelimiter.Length == 1 && char.IsLetterOrDigit(charDelimiter[0]))
{
result.AddError(new InitializationError(ErrorLevel.FATAL,
$"bad lexem {charDelimiter} : CharToken lexeme delimiter char <{token.ToString()}> can not start with a letter or digit.", ErrorCodes.LEXER_CHAR_DELIMITER_CANNOT_BE_LETTER));
}
if (string.IsNullOrEmpty(escapeDelimiterChar) || escapeDelimiterChar.Length > 1)
{
result.AddError(new InitializationError(ErrorLevel.FATAL,
$"bad lexem {escapeDelimiterChar} : CharToken lexeme escape char <{token.ToString()}> must be 1 character length.", ErrorCodes.LEXER_CHAR_ESCAPE_CHAR_MUST_BE_1_CHAR));
}
if (escapeDelimiterChar.Length == 1 && char.IsLetterOrDigit(escapeDelimiterChar[0]))
{
result.AddError(new InitializationError(ErrorLevel.FATAL,
$"bad lexem {escapeDelimiterChar} : CharToken lexeme escape char lexeme <{token.ToString()}> can not start with a letter or digit.", ErrorCodes.LEXER_CHAR_ESCAPE_CHAR_CANNOT_BE_LETTER_OR_DIGIT));
}
CharCounter++;
var charDelimiterChar = charDelimiter[0];
var escapeChar = escapeDelimiterChar[0];
NodeCallback <GenericToken> callback = match =>
{
match.Properties[DerivedToken] = token;
var value = match.Result.SpanValue;
match.Result.SpanValue = value;
return(match);
};
FSMBuilder.GoTo(start);
FSMBuilder.Transition(charDelimiterChar)
.Mark(start_char + "_" + CharCounter)
.ExceptTransition(new[] { charDelimiterChar, escapeChar })
.Mark(in_char + "_" + CharCounter)
.Transition(charDelimiterChar)
.Mark(end_char + "_" + CharCounter)
.End(GenericToken.Char)
.CallBack(callback)
.GoTo(start_char + "_" + CharCounter)
.Transition(escapeChar)
.Mark(escapeChar_char + "_" + CharCounter)
.ExceptTransitionTo(new[] { 'u' }, in_char + "_" + CharCounter)
.CallBack(callback);
FSMBuilder.Fsm.StringDelimiter = charDelimiterChar;
// TODO : unicode transitions
FSMBuilder = FSMBuilder.GoTo(escapeChar_char + "_" + CharCounter)
.Transition('u')
.Mark(unicode_char + "_" + CharCounter)
.RepetitionTransitionTo(in_char + "_" + CharCounter, 4, "[0-9,a-z,A-Z]");
}
public void AddStringLexem(IN token, BuildResult <ILexer <IN> > result, string stringDelimiter,
string escapeDelimiterChar = "\\")
{
if (string.IsNullOrEmpty(stringDelimiter) || stringDelimiter.Length > 1)
{
result.AddError(new LexerInitializationError(ErrorLevel.FATAL, $"bad lexem {stringDelimiter} : StringToken lexeme delimiter char <{token.ToString()}> must be 1 character length.", ErrorCodes.LEXER_STRING_DELIMITER_MUST_BE_1_CHAR));
}
if (stringDelimiter.Length == 1 && char.IsLetterOrDigit(stringDelimiter[0]))
{
result.AddError(new InitializationError(ErrorLevel.FATAL, $"bad lexem {stringDelimiter} : StringToken lexeme delimiter char <{token.ToString()}> can not start with a letter.", ErrorCodes.LEXER_STRING_DELIMITER_CANNOT_BE_LETTER_OR_DIGIT));
}
if (string.IsNullOrEmpty(escapeDelimiterChar) || escapeDelimiterChar.Length > 1)
{
result.AddError(new InitializationError(ErrorLevel.FATAL, $"bad lexem {escapeDelimiterChar} : StringToken lexeme escape char <{token.ToString()}> must be 1 character length.", ErrorCodes.LEXER_STRING_ESCAPE_CHAR_MUST_BE_1_CHAR));
}
if (escapeDelimiterChar.Length == 1 && char.IsLetterOrDigit(escapeDelimiterChar[0]))
{
result.AddError(new InitializationError(ErrorLevel.FATAL, $"bad lexem {escapeDelimiterChar} : StringToken lexeme escape char lexeme <{token.ToString()}> can not start with a letter.", ErrorCodes.LEXER_STRING_ESCAPE_CHAR_CANNOT_BE_LETTER_OR_DIGIT));
}
StringDelimiterChar = (char)0;
var stringDelimiterChar = (char)0;
EscapeStringDelimiterChar = (char)0;
var escapeStringDelimiterChar = (char)0;
if (stringDelimiter.Length == 1)
{
StringCounter++;
StringDelimiterChar = stringDelimiter[0];
stringDelimiterChar = stringDelimiter[0];
EscapeStringDelimiterChar = escapeDelimiterChar[0];
escapeStringDelimiterChar = escapeDelimiterChar[0];
}
NodeCallback <GenericToken> callback = match =>
{
match.Properties[DerivedToken] = token;
var value = match.Result.SpanValue;
match.Result.SpanValue = value;
match.StringDelimiterChar = stringDelimiterChar;
match.IsString = true;
if (stringDelimiterChar != escapeStringDelimiterChar)
{
match.Result.SpanValue = diffCharEscaper(escapeStringDelimiterChar, stringDelimiterChar, match.Result.SpanValue);
}
else
{
match.Result.SpanValue = sameCharEscaper(escapeStringDelimiterChar, stringDelimiterChar, match.Result.SpanValue);
}
return(match);
};
if (stringDelimiterChar != escapeStringDelimiterChar)
{
FSMBuilder.GoTo(start);
FSMBuilder.Transition(stringDelimiterChar)
.Mark(in_string + StringCounter)
.ExceptTransitionTo(new[] { stringDelimiterChar, escapeStringDelimiterChar },
in_string + StringCounter)
.Transition(escapeStringDelimiterChar)
.Mark(escape_string + StringCounter)
.ExceptTransitionTo(new[] { stringDelimiterChar }, in_string + StringCounter)
.GoTo(escape_string + StringCounter)
.TransitionTo(stringDelimiterChar, in_string + StringCounter)
.Transition(stringDelimiterChar)
.End(GenericToken.String)
.Mark(string_end + StringCounter)
.CallBack(callback);
FSMBuilder.Fsm.StringDelimiter = stringDelimiterChar;
}
else
{
var exceptDelimiter = new[] { stringDelimiterChar };
var in_string = "in_string_same";
var escaped = "escaped_same";
var delim = "delim_same";
FSMBuilder.GoTo(start)
.Transition(stringDelimiterChar)
.Mark(in_string + StringCounter)
.ExceptTransitionTo(exceptDelimiter, in_string + StringCounter)
.Transition(stringDelimiterChar)
.Mark(escaped + StringCounter)
.End(GenericToken.String)
.CallBack(callback)
.Transition(stringDelimiterChar)
.Mark(delim + StringCounter)
.ExceptTransitionTo(exceptDelimiter, in_string + StringCounter);
FSMBuilder.GoTo(delim + StringCounter)
.TransitionTo(stringDelimiterChar, escaped + StringCounter)
.ExceptTransitionTo(exceptDelimiter, in_string + StringCounter);
}
}
/// <summary>Invokes a callback on each node</summary>
/// <param name="cb">Callbacke to be invoked</param>
public void ForAllNodes(NodeCallback cb)
{
foreach (Node node in _Nodes)
cb(node);
}
public void AddLexeme(GenericToken generic, IN token)
{
NodeCallback <GenericToken> callback = match =>
{
switch (match.Result.TokenID)
{
case GenericToken.Identifier:
{
if (derivedTokens.ContainsKey(GenericToken.Identifier))
{
var possibleTokens = derivedTokens[GenericToken.Identifier];
if (possibleTokens.ContainsKey(match.Result.Value))
{
match.Properties[DerivedToken] = possibleTokens[match.Result.Value];
}
else
{
match.Properties[DerivedToken] = identifierDerivedToken;
}
}
else
{
match.Properties[DerivedToken] = identifierDerivedToken;
}
break;
}
case GenericToken.Int:
{
match.Properties[DerivedToken] = intDerivedToken;
break;
}
case GenericToken.Double:
{
match.Properties[DerivedToken] = doubleDerivedToken;
break;
}
default:
{
match.Properties[DerivedToken] = token;
break;
}
}
return(match);
};
switch (generic)
{
case GenericToken.Double:
{
doubleDerivedToken = token;
FSMBuilder.GoTo(in_double);
FSMBuilder.CallBack(callback);
break;
}
case GenericToken.Int:
{
intDerivedToken = token;
FSMBuilder.GoTo(in_int);
FSMBuilder.CallBack(callback);
break;
}
case GenericToken.Identifier:
{
identifierDerivedToken = token;
FSMBuilder.GoTo(in_identifier);
FSMBuilder.CallBack(callback);
break;
}
}
}
internal void SetCallback(int nodeId, NodeCallback <N> callback)
{
Callbacks[nodeId] = callback;
}
public void AddStringLexem(IN token, string stringDelimiter, string escapeDelimiterChar = "\\")
{
if (string.IsNullOrEmpty(stringDelimiter) || stringDelimiter.Length > 1)
{
throw new InvalidLexerException($"bad lexem {stringDelimiter} : StringToken lexeme delimiter char <{token.ToString()}> must be 1 character length.");
}
if (char.IsLetterOrDigit(stringDelimiter[0]))
{
throw new InvalidLexerException($"bad lexem {stringDelimiter} : StringToken lexeme delimiter char <{token.ToString()}> can not start with a letter.");
}
if (string.IsNullOrEmpty(escapeDelimiterChar) || escapeDelimiterChar.Length > 1)
{
throw new InvalidLexerException($"bad lexem {escapeDelimiterChar} : StringToken lexeme escape char <{token.ToString()}> must be 1 character length.");
}
if (char.IsLetterOrDigit(escapeDelimiterChar[0]))
{
throw new InvalidLexerException($"bad lexem {escapeDelimiterChar} : StringToken lexeme escape char lexeme <{token.ToString()}> can not start with a letter.");
}
StringCounter++;
StringDelimiterChar = stringDelimiter[0];
EscapeStringDelimiterChar = escapeDelimiterChar[0];
NodeCallback <GenericToken> callback = (FSMMatch <GenericToken> match) =>
{
match.Properties[DerivedToken] = token;
string value = match.Result.Value;
match.Result.Value = value;
return(match);
};
if (StringDelimiterChar != EscapeStringDelimiterChar)
{
FSMBuilder.GoTo(start);
FSMBuilder.Transition(StringDelimiterChar)
.Mark(in_string + StringCounter)
.ExceptTransitionTo(new char[] { StringDelimiterChar, EscapeStringDelimiterChar }, in_string + StringCounter)
.Transition(EscapeStringDelimiterChar)
.Mark(escape_string + StringCounter)
.AnyTransitionTo(' ', in_string + StringCounter)
.Transition(StringDelimiterChar)
.End(GenericToken.String)
.Mark(string_end + StringCounter)
.CallBack(callback);
FSMBuilder.Fsm.StringDelimiter = StringDelimiterChar;
}
else
{
NodeAction collapseDelimiter = (string value) =>
{
if (value.EndsWith("" + StringDelimiterChar + StringDelimiterChar))
{
return(value.Substring(0, value.Length - 2) + StringDelimiterChar);
}
return(value);
};
var exceptDelimiter = new char[] { StringDelimiterChar };
string in_string = "in_string_same";
string escaped = "escaped_same";
string delim = "delim_same";
FSMBuilder.GoTo(start)
.Transition(StringDelimiterChar)
.Mark(in_string + StringCounter)
.ExceptTransitionTo(exceptDelimiter, in_string + StringCounter)
.Transition(StringDelimiterChar)
.Mark(escaped + StringCounter)
.End(GenericToken.String)
.CallBack(callback)
.Transition(StringDelimiterChar)
.Mark(delim + StringCounter)
.Action(collapseDelimiter)
.ExceptTransitionTo(exceptDelimiter, in_string + StringCounter);
FSMBuilder.GoTo(delim + StringCounter)
.TransitionTo(StringDelimiterChar, escaped + StringCounter)
.ExceptTransitionTo(exceptDelimiter, in_string + StringCounter);
}
}
public static void AddExtension(Extensions token, LexemeAttribute lexem, GenericLexer <Extensions> lexer)
{
if (token == Extensions.DATE)
{
NodeCallback <GenericToken> callback = match =>
{
match.Properties[GenericLexer <Extensions> .DerivedToken] = Extensions.DATE;
return(match);
};
var fsmBuilder = lexer.FSMBuilder;
fsmBuilder.GoTo(GenericLexer <Extensions> .in_double)
.Transition('.', CheckDate)
.Mark("start_date")
.RepetitionTransition(4, "[0-9]")
.End(GenericToken.Extension)
.CallBack(callback);
}
else if (token == Extensions.CHAINE)
{
NodeCallback <GenericToken> callback = match =>
{
match.Properties[GenericLexer <Extensions> .DerivedToken] = Extensions.CHAINE;
return(match);
};
var quote = '\'';
NodeAction collapseDelimiter = value =>
{
if (value.EndsWith("" + quote + quote))
{
return(value.Substring(0, value.Length - 2) + quote);
}
return(value);
};
var exceptQuote = new[] { quote };
var in_string = "in_string_same";
var escaped = "escaped_same";
var delim = "delim_same";
var fsmBuilder = lexer.FSMBuilder;
fsmBuilder.GoTo(GenericLexer <Extensions> .start)
.Transition(quote)
.Mark(in_string)
.ExceptTransitionTo(exceptQuote, in_string)
.Transition(quote)
.Mark(escaped)
.End(GenericToken.String)
.CallBack(callback)
.Transition(quote)
.Mark(delim)
.Action(collapseDelimiter)
.ExceptTransitionTo(exceptQuote, in_string);
fsmBuilder.GoTo(delim)
.TransitionTo(quote, escaped)
.ExceptTransitionTo(exceptQuote, in_string);
}
}
private static BuildResult <ILexer <IN> > BuildGenericLexer <IN>(Dictionary <IN, List <LexemeAttribute> > attributes,
BuildExtension <IN> extensionBuilder, BuildResult <ILexer <IN> > result) where IN : struct
{
result = CheckStringAndCharTokens(attributes, result);
var(config, tokens) = GetConfigAndGenericTokens(attributes);
config.ExtensionBuilder = extensionBuilder;
var lexer = new GenericLexer <IN>(config, tokens);
var Extensions = new Dictionary <IN, LexemeAttribute>();
foreach (var pair in attributes)
{
var tokenID = pair.Key;
var lexemes = pair.Value;
foreach (var lexeme in lexemes)
{
try
{
if (lexeme.IsStaticGeneric)
{
lexer.AddLexeme(lexeme.GenericToken, tokenID);
}
if (lexeme.IsKeyWord)
{
foreach (var param in lexeme.GenericTokenParameters)
{
lexer.AddKeyWord(tokenID, param);
}
}
if (lexeme.IsSugar)
{
foreach (var param in lexeme.GenericTokenParameters)
{
lexer.AddSugarLexem(tokenID, param, lexeme.IsLineEnding);
}
}
if (lexeme.IsString)
{
var(delimiter, escape) = GetDelimiters(lexeme, "\"", "\\");
lexer.AddStringLexem(tokenID, delimiter, escape);
}
if (lexeme.IsChar)
{
var(delimiter, escape) = GetDelimiters(lexeme, "'", "\\");
lexer.AddCharLexem(tokenID, delimiter, escape);
}
if (lexeme.IsExtension)
{
Extensions[tokenID] = lexeme;
}
}
catch (Exception e)
{
result.AddError(new InitializationError(ErrorLevel.FATAL, e.Message));
}
}
}
AddExtensions(Extensions, extensionBuilder, lexer);
var comments = GetCommentsAttribute(result);
if (!result.IsError)
{
foreach (var comment in comments)
{
NodeCallback <GenericToken> callbackSingle = match =>
{
match.Properties[GenericLexer <IN> .DerivedToken] = comment.Key;
match.Result.IsComment = true;
match.Result.CommentType = CommentType.Single;
return(match);
};
NodeCallback <GenericToken> callbackMulti = match =>
{
match.Properties[GenericLexer <IN> .DerivedToken] = comment.Key;
match.Result.IsComment = true;
match.Result.CommentType = CommentType.Multi;
return(match);
};
foreach (var commentAttr in comment.Value)
{
var fsmBuilder = lexer.FSMBuilder;
var hasSingleLine = !string.IsNullOrWhiteSpace(commentAttr.SingleLineCommentStart);
if (hasSingleLine)
{
lexer.SingleLineComment = commentAttr.SingleLineCommentStart;
fsmBuilder.GoTo(GenericLexer <IN> .start);
fsmBuilder.ConstantTransition(commentAttr.SingleLineCommentStart);
fsmBuilder.Mark(GenericLexer <IN> .single_line_comment_start);
fsmBuilder.End(GenericToken.Comment);
fsmBuilder.CallBack(callbackSingle);
}
var hasMultiLine = !string.IsNullOrWhiteSpace(commentAttr.MultiLineCommentStart);
if (hasMultiLine)
{
lexer.MultiLineCommentStart = commentAttr.MultiLineCommentStart;
lexer.MultiLineCommentEnd = commentAttr.MultiLineCommentEnd;
fsmBuilder.GoTo(GenericLexer <IN> .start);
fsmBuilder.ConstantTransition(commentAttr.MultiLineCommentStart);
fsmBuilder.Mark(GenericLexer <IN> .multi_line_comment_start);
fsmBuilder.End(GenericToken.Comment);
fsmBuilder.CallBack(callbackMulti);
}
}
}
}
result.Result = lexer;
return(result);
}
public void AddCharLexem(IN token, string charDelimiter, string escapeDelimiterChar = "\\")
{
if (string.IsNullOrEmpty(charDelimiter) || charDelimiter.Length > 1)
{
throw new InvalidLexerException(
$"bad lexem {charDelimiter} : CharToken lexeme delimiter char <{token.ToString()}> must be 1 character length.");
}
if (char.IsLetterOrDigit(charDelimiter[0]))
{
throw new InvalidLexerException(
$"bad lexem {charDelimiter} : CharToken lexeme delimiter char <{token.ToString()}> can not start with a letter.");
}
if (string.IsNullOrEmpty(escapeDelimiterChar) || escapeDelimiterChar.Length > 1)
{
throw new InvalidLexerException(
$"bad lexem {escapeDelimiterChar} : CharToken lexeme escape char <{token.ToString()}> must be 1 character length.");
}
if (char.IsLetterOrDigit(escapeDelimiterChar[0]))
{
throw new InvalidLexerException(
$"bad lexem {escapeDelimiterChar} : CharToken lexeme escape char lexeme <{token.ToString()}> can not start with a letter.");
}
CharCounter++;
var charDelimiterChar = charDelimiter[0];
var escapeChar = escapeDelimiterChar[0];
NodeCallback <GenericToken> callback = match =>
{
match.Properties[DerivedToken] = token;
var value = match.Result.SpanValue;
match.Result.SpanValue = value;
return(match);
};
FSMBuilder.GoTo(start);
FSMBuilder.Transition(charDelimiterChar)
.Mark(start_char + "_" + CharCounter)
.ExceptTransition(new[] { charDelimiterChar, escapeChar })
.Mark(in_char + "_" + CharCounter)
.Transition(charDelimiterChar)
.Mark(end_char + "_" + CharCounter)
.End(GenericToken.Char)
.CallBack(callback)
.GoTo(start_char + "_" + CharCounter)
.Transition(escapeChar)
.Mark(escapeChar_char + "_" + CharCounter)
.ExceptTransitionTo(new[] { 'u' }, in_char + "_" + CharCounter)
.CallBack(callback);
FSMBuilder.Fsm.StringDelimiter = charDelimiterChar;
// TODO : unicode transitions
FSMBuilder = FSMBuilder.GoTo(escapeChar_char + "_" + CharCounter)
.Transition('u')
.Mark(unicode_char + "_" + CharCounter)
.RepetitionTransitionTo(in_char + "_" + CharCounter, 4, "[0-9,a-z,A-Z]");
}
public void AddStringLexem(IN token, string stringDelimiter, string escapeDelimiterChar = "\\")
{
if (string.IsNullOrEmpty(stringDelimiter) || stringDelimiter.Length > 1)
{
throw new InvalidLexerException(
$"bad lexem {stringDelimiter} : StringToken lexeme delimiter char <{token.ToString()}> must be 1 character length.");
}
if (char.IsLetterOrDigit(stringDelimiter[0]))
{
throw new InvalidLexerException(
$"bad lexem {stringDelimiter} : StringToken lexeme delimiter char <{token.ToString()}> can not start with a letter.");
}
if (string.IsNullOrEmpty(escapeDelimiterChar) || escapeDelimiterChar.Length > 1)
{
throw new InvalidLexerException(
$"bad lexem {escapeDelimiterChar} : StringToken lexeme escape char <{token.ToString()}> must be 1 character length.");
}
if (char.IsLetterOrDigit(escapeDelimiterChar[0]))
{
throw new InvalidLexerException(
$"bad lexem {escapeDelimiterChar} : StringToken lexeme escape char lexeme <{token.ToString()}> can not start with a letter.");
}
StringCounter++;
StringDelimiterChar = stringDelimiter[0];
var stringDelimiterChar = stringDelimiter[0];
EscapeStringDelimiterChar = escapeDelimiterChar[0];
var escapeStringDelimiterChar = escapeDelimiterChar[0];
NodeCallback <GenericToken> callback = match =>
{
match.Properties[DerivedToken] = token;
var value = match.Result.SpanValue;
match.Result.SpanValue = value;
if (stringDelimiterChar != escapeStringDelimiterChar)
{
match.Result.SpanValue = diffCharEscaper(escapeStringDelimiterChar, stringDelimiterChar, match.Result.SpanValue);
}
else
{
match.Result.SpanValue = sameCharEscaper(escapeStringDelimiterChar, stringDelimiterChar, match.Result.SpanValue);
}
return(match);
};
if (stringDelimiterChar != escapeStringDelimiterChar)
{
FSMBuilder.GoTo(start);
FSMBuilder.Transition(stringDelimiterChar)
.Mark(in_string + StringCounter)
.ExceptTransitionTo(new[] { stringDelimiterChar, escapeStringDelimiterChar },
in_string + StringCounter)
.Transition(escapeStringDelimiterChar)
.Mark(escape_string + StringCounter)
.ExceptTransitionTo(new[] { stringDelimiterChar }, in_string + StringCounter)
.GoTo(escape_string + StringCounter)
.TransitionTo(stringDelimiterChar, in_string + StringCounter)
.Transition(stringDelimiterChar)
.End(GenericToken.String)
.Mark(string_end + StringCounter)
.CallBack(callback);
FSMBuilder.Fsm.StringDelimiter = stringDelimiterChar;
}
else
{
var exceptDelimiter = new[] { stringDelimiterChar };
var in_string = "in_string_same";
var escaped = "escaped_same";
var delim = "delim_same";
FSMBuilder.GoTo(start)
.Transition(stringDelimiterChar)
.Mark(in_string + StringCounter)
.ExceptTransitionTo(exceptDelimiter, in_string + StringCounter)
.Transition(stringDelimiterChar)
.Mark(escaped + StringCounter)
.End(GenericToken.String)
.CallBack(callback)
.Transition(stringDelimiterChar)
.Mark(delim + StringCounter)
.ExceptTransitionTo(exceptDelimiter, in_string + StringCounter);
FSMBuilder.GoTo(delim + StringCounter)
.TransitionTo(stringDelimiterChar, escaped + StringCounter)
.ExceptTransitionTo(exceptDelimiter, in_string + StringCounter);
}
}
public TreeIterator(System.Windows.Forms.TreeView tree, NodeCallback cb)
{
m_tree = tree;
m_callback = cb;
}
public TreeIterator(System.Windows.Forms.TreeView tree, NodeCallback cb)
{
m_tree = tree;
m_callback = cb;
}
public void AddLexeme(GenericToken generic, IN token)
{
if (generic == GenericToken.Identifier)
{
identifierDerivedToken = token;
var derived = new Dictionary <string, IN>();
if (derivedTokens.ContainsKey(generic))
{
derived = derivedTokens[generic];
}
derived[defaultIdentifierKey] = token;
//return;
}
if (generic == GenericToken.Double)
{
doubleDerivedToken = token;
}
if (generic == GenericToken.Int)
{
intDerivedToken = token;
}
NodeCallback <GenericToken> callback = (FSMMatch <GenericToken> match) =>
{
switch (match.Result.TokenID)
{
case GenericToken.Identifier:
{
if (derivedTokens.ContainsKey(GenericToken.Identifier))
{
var possibleTokens = derivedTokens[GenericToken.Identifier];
if (possibleTokens.ContainsKey(match.Result.Value))
{
match.Properties[DerivedToken] = possibleTokens[match.Result.Value];
}
else
{
match.Properties[DerivedToken] = identifierDerivedToken;
}
}
else
{
match.Properties[DerivedToken] = identifierDerivedToken;
}
;
break;
}
case GenericToken.Int:
{
match.Properties[DerivedToken] = intDerivedToken;
break;
}
case GenericToken.Double:
{
match.Properties[DerivedToken] = doubleDerivedToken;
break;
}
default:
{
match.Properties[DerivedToken] = token;
break;
}
}
return(match);
};
switch (generic)
{
case GenericToken.Double:
{
FSMBuilder.GoTo(in_double);
FSMBuilder.CallBack(callback);
break;
}
case GenericToken.Int:
{
FSMBuilder.GoTo(in_int);
FSMBuilder.CallBack(callback);
break;
}
case GenericToken.Identifier:
{
FSMBuilder.GoTo(in_identifier);
FSMBuilder.CallBack(callback);
break;
}
}
}
public TreeIterator(TreeView tree, NodeCallback cb)
{
m_tree = tree;
m_callback = cb;
}