private static Func <FormattingContext, bool> InForLoopOnSameLine(Side side)
{
return((FormattingContext formattingContext) =>
{
ParsedToken parsedToken = GetTokenOn(side, formattingContext);
SourceText sourceText = formattingContext.SourceText;
int start;
int end;
if (parsedToken.UpperStatementNode.Kind == SyntaxKind.SimpleForStatementNode)
{
SimpleForStatementNode forStatement = (SimpleForStatementNode)parsedToken.UpperStatementNode;
start = forStatement.ForKeyword.Start;
end = forStatement.EndKeyword.Start;
return sourceText.GetLineNumberFromIndex(start) == sourceText.GetLineNumberFromIndex(end);
}
else if (parsedToken.UpperStatementNode.Kind == SyntaxKind.MultipleArgForStatementNode)
{
MultipleArgForStatementNode forStatement = (MultipleArgForStatementNode)parsedToken.UpperStatementNode;
start = forStatement.ForKeyword.Start;
end = forStatement.EndKeyword.Start;
return sourceText.GetLineNumberFromIndex(start) == sourceText.GetLineNumberFromIndex(end);
}
return false;
});
}
private static Func <FormattingContext, bool> InFunctionStatementOnOneLine(Side side)
{
return((FormattingContext formattingContext) =>
{
ParsedToken parsedToken = GetTokenOn(side, formattingContext);
SourceText sourceText = formattingContext.SourceText;
int start;
int end;
if (parsedToken.UpperStatementNode.Kind == SyntaxKind.GlobalFunctionStatementNode)
{
GlobalFunctionStatementNode function = (GlobalFunctionStatementNode)parsedToken.UpperStatementNode;
start = function.FunctionKeyword.Start;
end = function.FuncBody.EndKeyword.Start;
return sourceText.GetLineNumberFromIndex(start) == sourceText.GetLineNumberFromIndex(end);
}
else if (parsedToken.UpperStatementNode.Kind == SyntaxKind.LocalFunctionStatementNode)
{
LocalFunctionStatementNode function = (LocalFunctionStatementNode)parsedToken.UpperStatementNode;
start = function.LocalKeyword.Start;
end = function.FuncBody.EndKeyword.Start;
return sourceText.GetLineNumberFromIndex(start) == sourceText.GetLineNumberFromIndex(end);
}
return false;
});
}
/// <summary>
/// Parse with error intercepts
/// </summary>
ParsedToken ParseNext(HParser parser, Func <Exception, bool> errorHandler)
{
ParsedToken result = null;
do
{
try
{
result = parser.Parse();
if (result == null)
{
break;
}
}
catch (Exception ex)
{
if (errorHandler != null)
{
if (errorHandler(ex))
{
continue;
}
}
throw;
}
} while (result == null);
return(result);
}
private static Func <FormattingContext, bool> IsStartOfStatement(Side side)
{
return((FormattingContext formattingContext) =>
{
ParsedToken parsedToken = GetTokenOn(side, formattingContext);
return parsedToken.Token.FullStart == parsedToken.ImmediateStatementNode.StartPosition;
});
}
internal void SynchronizeToken(ParsedToken parsedToken, string remainingText)
{
if (parsedToken.QueryToken == null)
{
string tokenString = parsedToken.String;
if (tokenString.StartsWith("$"))
{
string v = tokenString.TryBefore('.') ?? tokenString;
if (!Variables.TryGetValue(v, out ValueProviderBase? prov))
{
SafeConsole.WriteLineColor(ConsoleColor.Magenta, "Variable '{0}' not found!".FormatWith(v));
}
var provToken = prov as TokenValueProvider;
if (!(provToken is TokenValueProvider))
{
SafeConsole.WriteLineColor(ConsoleColor.Magenta, "Variable '{0}' is not a Query Token");
}
var part = provToken?.ParsedToken;
if (part != null && part.QueryToken == null)
{
SafeConsole.WriteLineColor(ConsoleColor.Magenta, "Variable '{0}' is not fixed yet! currently: '{1}'".FormatWith(v, part.String));
}
var after = tokenString.TryAfter('.');
tokenString =
(part == null ? "Unknown" :
part.QueryToken == null ? part.String :
part.QueryToken.FullKey()) + (after == null ? null : ("." + after));
}
SafeConsole.WriteColor(ConsoleColor.Red, " " + tokenString);
Console.WriteLine(" " + remainingText);
FixTokenResult result = QueryTokenSynchronizer.FixToken(Replacements, tokenString, out QueryToken? token, QueryDescription, SubTokensOptions.CanElement | SubTokensOptions.CanAnyAll /*not always*/, remainingText, allowRemoveToken: false, allowReGenerate: ModelType != null);
switch (result)
{
case FixTokenResult.Nothing:
case FixTokenResult.Fix:
this.HasChanges = true;
parsedToken.QueryToken = token;
parsedToken.String = token !.FullKey();
break;
case FixTokenResult.SkipEntity:
case FixTokenResult.RemoveToken:
case FixTokenResult.ReGenerateEntity:
throw new TemplateSyncException(result);
}
}
}
public TranslateInstanceValueProvider(ParsedToken token, bool isExplicit, Action <bool, string> addError)
{
this.ParsedToken = token;
this.IsExplicit = isExplicit;
if (token.QueryToken != null)
{
this.Route = token.QueryToken.GetPropertyRoute();
this.EntityToken = DeterminEntityToken(token.QueryToken, addError);
}
}
private static Func <FormattingContext, bool> InSyntaxNode(Side side, List <SyntaxKind> statementKinds)
{
return((FormattingContext formattingContext) =>
{
ParsedToken parsedToken = GetTokenOn(side, formattingContext);
bool containsImmediateStatementNode =
parsedToken.ImmediateStatementNode != null &&
statementKinds.Contains(parsedToken.ImmediateStatementNode.Kind);
return containsImmediateStatementNode;
});
}
public string Encrypt(string message, string hexKey)
{
var parsedToken = new ParsedToken(message);
var keyBits = new BitArray(hexKey.GetBytesFromHex());
BitArray[] encryptedBits = parsedToken.BitBlocks
.Select(bitsBlock => this.algorithm.Encrypt(bitsBlock, keyBits))
.ToArray();
var encryptedToken = new EncryptedToken(parsedToken.OriginalBytesCount, encryptedBits);
return(encryptedToken.ToString());
}
private static Func <FormattingContext, bool> InTableConstructor(Side side)
{
return((FormattingContext formattingContext) =>
{
ParsedToken parsedToken = GetTokenOn(side, formattingContext);
bool upperStatementNodeIsTableConstructor =
parsedToken.UpperStatementNode != null &&
(SyntaxKind.TableConstructorArg == parsedToken.ImmediateStatementNode.Kind ||
SyntaxKind.TableConstructorExp == parsedToken.ImmediateStatementNode.Kind);
return upperStatementNodeIsTableConstructor;
});
}
public void Encrypt_WhenDataAndKeyAreValid_ReturnsEncryptedData()
{
string originalMessage = "hello world";
var parsedToken = new ParsedToken(originalMessage);
var keyBits = new BitArray("13-34-57-79-9B-BC-DF-F1".GetBytesFromHex());
var algorithm = this.resolver.Resolve <IDesAlgorithm>();
BitArray[] encryptedResult = parsedToken.BitBlocks.Select(block => algorithm.Encrypt(block, keyBits)).ToArray();
BitArray[] decryptedResult = encryptedResult.Select(block => algorithm.Decrypt(block, keyBits)).ToArray();
var decryptedToken = new DecryptedToken(parsedToken.OriginalBytesCount, decryptedResult);
Assert.AreEqual(originalMessage, decryptedToken.ToString());
}
public void Constructor_CorrectSecuenceOfBitsIsExstractedFromString()
{
string originalMessage = "hello world";
byte[] originalMessageBytes = { 104, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100, 0, 0, 0, 0, 0 };
BitArray[] result = new ParsedToken(originalMessage).BitBlocks.ToArray();
CollectionAssert.AreEqual(
new BitArray(originalMessageBytes.Take(BytesIn64Bits).ToArray()),
result[0]);
CollectionAssert.AreEqual(
new BitArray(originalMessageBytes.Skip(BytesIn64Bits).Take(BytesIn64Bits).ToArray()),
result[1]);
}
public void ParsingTest(string paramText, Token[] tokens, ParsedToken <Parameter[]> expectedToken)
{
var parser = new ParameterParser(null);
var parsedToken = parser.Parse(tokens);
Assert.IsNotNull(parsedToken);
Assert.AreEqual(parsedToken.TokenType, expectedToken.TokenType);
Assert.AreEqual(parsedToken.ParsedValue.Length, expectedToken.ParsedValue.Length);
for (int i = 0; i < parsedToken.ParsedValue.Length; i++)
{
var value = parsedToken.ParsedValue[i];
var expectedValue = expectedToken.ParsedValue[i];
Assert.AreEqual(value.Name, expectedValue.Name);
Assert.AreEqual(value.ParameterType, expectedValue.ParameterType);
Assert.AreEqual(value.DefaultValue, expectedValue.DefaultValue);
}
}
public static bool TryParse(ReadOnlySpan <char> value, out IpAddressV4 result)
{
Tokenizer tokenizer = new Tokenizer(value);
if (!TryParse(ref tokenizer, out result))
{
return(false);
}
// We now expect the end
ParsedToken token = tokenizer.ParseAndAdvance();
if (token.Type != TokenType.None)
{
// Something other than EOF was found
result = default;
return(false);
}
return(true);
}
internal static bool TryParse(ref Tokenizer tokenizer, out IpAddressV4 result)
{
// Shortest IPv4 is 1 char (0)
// Longest IPv4 is 15 chars (255.255.255.255)
if (tokenizer.Length < 1 || tokenizer.Length > 15)
{
result = default;
return(false);
}
uint ip = 0;
ParsedToken token = default;
// Parse the IP
int i;
for (i = 0; i < 4; i++)
{
token = tokenizer.ParseAndAdvance(false);
// Read a dot, or break on slashes
if (i > 0)
{
if (token.Type == TokenType.None)
{
// We're at the end, and we could have parsed a number. To support partial IPv4's ("192.168"), we break here
break;
}
if (token.Type != TokenType.Dot)
{
// We expected a dot, but we didn't get one
result = default;
return(false);
}
// Advance once more
token = tokenizer.ParseAndAdvance(false);
}
// Read a number
if (token.Type != TokenType.Number || token.Value > byte.MaxValue)
{
// We expected a 0..255 number, but we didn't get one
result = default;
return(false);
}
ip <<= 8;
ip += token.Value;
}
// Assume the remainder of the IP is 0's
for (; i < 4; i++)
{
ip <<= 8;
}
result = new IpAddressV4(ip);
return(true);
}
internal static bool TryParse(ref Tokenizer tokenizer, out IpAddressNetworkV4 result)
{
// Shortest IPv4 is 1 char (0)
// Longest IPv4 is 18 chars (255.255.255.255/32)
if (tokenizer.Length < 1 || tokenizer.Length > 18)
{
result = default;
return(false);
}
uint ip = 0;
byte cidr = 32;
ParsedToken token = default;
// Parse the IP
int i;
for (i = 0; i < 4; i++)
{
token = tokenizer.ParseAndAdvance(false);
// Read a dot, or break on slashes
if (i > 0)
{
if (token.Type == TokenType.Slash)
{
break;
}
if (token.Type != TokenType.Dot)
{
// We expected a dot, but we didn't get one
result = default;
return(false);
}
// Advance once more
token = tokenizer.ParseAndAdvance(false);
}
// Read a number
if (token.Type != TokenType.Number || token.Value > byte.MaxValue)
{
// We expected a 0..255 number, but we didn't get one
result = default;
return(false);
}
ip <<= 8;
ip += token.Value;
}
// Assume the remainder of the IP is 0's
for (; i < 4; i++)
{
ip <<= 8;
}
// Parse the Cidr
if (token.Type != TokenType.Slash)
{
token = tokenizer.ParseAndAdvance(false);
}
if (token.Type == TokenType.Slash)
{
// Read a number, as the cidr
token = tokenizer.ParseAndAdvance(false);
if (token.Type != TokenType.Number || token.Value > 32)
{
// We expected a 0..32 number, but we didn't get one
result = default;
return(false);
}
cidr = (byte)token.Value;
}
result = new IpAddressNetworkV4(ip, cidr);
return(true);
}
/// <summary>
/// Parse a content as raw text.
/// </summary>
/// <remarks>
/// This method is used for parsing the content of the script, style tag content.
/// The parsing is continue until matching the end of the <paramref name="tag"/>.
/// If <paramref name="tag"/> is null or empty then we accept all endtag.
/// </remarks>
/// <exception cref="InvalidOperationException">
/// Raised when the parser is not in a normal state : all tag need to be closed.
/// </exception>
/// <param name="tag">Tag name for the end tag expected.</param>
/// <returns>Content</returns>
public ParsedText ParseContentText(String tag)
{
// Verify
if (this._State != ParseState.Content)
{
throw new InvalidOperationException("Can't read a content in a opened tag.");
}
// Read loop
var start = SourceReader.Position;
CharInfo c;
while ((c = ReadChar(false)) != CharInfo.EOF)
{
// End detected ?
if (c == '<')
{
var endTagPos = c.Position;
StringBuilder saveTag = new StringBuilder(15);
saveTag.Append(c);
while ((c = ReadChar(false)) != CharInfo.EOF && Char.IsWhiteSpace(c.AsChar))
{
saveTag.Append(c.AsChar);
}
if (c == '/')
{
// Pass '/'
saveTag.Append(c);
while ((c = ReadChar(false)) != CharInfo.EOF && Char.IsWhiteSpace(c.AsChar))
{
saveTag.Append(c.AsChar);
}
if (c != CharInfo.EOF)
{
// Pass tag name
StringBuilder tagName = new StringBuilder(10);
saveTag.Append(c.AsChar);
tagName.Append(c.AsChar);
while ((c = ReadChar(false)) != CharInfo.EOF && IsAttributeNameChar(c.AsChar))
{
saveTag.Append(c.AsChar);
tagName.Append(c.AsChar);
}
// We find the good end tag ?
if (c != CharInfo.EOF)
{
if (String.IsNullOrEmpty(tag) || String.Equals(tagName.ToString(), tag, StringComparison.OrdinalIgnoreCase))
{
SaveChar(c);
// Search the good end
while ((c = ReadChar(false)) != CharInfo.EOF && Char.IsWhiteSpace(c.AsChar))
{
saveTag.Append(c.AsChar);
}
if (c == '>')
{
// Save the end tag for the next parse
_CurrentToken = ParsedTag.EndTag(tagName.ToString());
_CurrentToken.Position = endTagPos;
c = CharInfo.EOF; // Don't save the char
// Exit the loop
break;
}
}
}
}
}
// If here then we don't find a good end tag we convert to 'text'
var etp = endTagPos;
foreach (var st in saveTag.ToString())
{
AddToCurrentRead(new CharInfo(st, etp++));
}
}
//
AddToCurrentRead(c);
}
if (c != CharInfo.EOF)
{
SaveChar(c);
}
// Returns parse result
LastParsed = new ParsedText()
{
Position = start,
Text = HEntity.HtmlDecode(GetCurrentRead(true), RemoveUnknownOrInvalidEntities)
};
return((ParsedText)LastParsed);
}
/// <summary>
/// This sample rule recognizes just the special parsed Token we defined earlier
/// </summary>
public NLPActionResult ProductNumber(ParsedToken parsedToken)
{
st.Say("You entered a product number recognized by your custom token definition class");
st.Say("It had a strongly typed value on it of " + parsedToken.Value);
return(NLPActionResult.None);
}
/// <summary>
/// Parse a doctype
/// </summary>
/// <returns></returns>
protected ParsedToken ParseDoctype()
{
// We are in doctype
_State = ParseState.Doctype;
var stag = _CurrentPosition;
// read DOCTYPE
StringBuilder dc = new StringBuilder();
dc.Append(ReadChar().AsChar);
CharInfo c;
while ((c = ReadChar()) != CharInfo.EOF && Char.IsLetter(c.AsChar))
{
dc.Append(c.AsChar);
}
if (dc.ToString().ToLower() != "doctype")
{
throw new ParseError("DOCTYPE expected.", _CurrentPosition);
}
// Read loop
int s = 0; char quote = '\0';
// s : state
// 0 : in tag
// 1 : in value
List <String> values = new List <string>();
while ((c = ReadChar()) != CharInfo.EOF)
{
if (s == 0)
{
// Start a value ?
if (c == '"' || c == '\'')
{
quote = c.AsChar;
_CurrentRead = null;
s = 1;
}
else if (Char.IsLetterOrDigit(c.AsChar))
{
quote = '\0';
_CurrentRead = null;
AddToCurrentRead(c);
s = 1;
}
else if (c == '>')
{
break;
}
}
else if (s == 1)
{
// End of the value ?
if (quote == c.AsChar)
{
var v = GetCurrentRead(true);
values.Add(v.Substring(0, v.Length - 1));
s = 0;
}
else if (c == '>' || (quote == '\0' && !Char.IsLetterOrDigit(c.AsChar)))
{
var v = GetCurrentRead(true);
values.Add(v.Substring(0, v.Length - 1));
SaveChar(c);
s = 0;
}
}
}
if (s == 1 && _CurrentRead != null)
{
values.Add(GetCurrentRead(true));
}
_CurrentRead = null;
_CurrentToken = new ParsedDoctype()
{
Position = stag,
Values = values.ToArray()
};
if (c == CharInfo.EOF)
{
throw new ParseError("End of file unexpected, doctype not closed.", ReadPosition);
}
// Back to content state
_State = ParseState.Content;
ResetTagBuffer();
// Returns doctype
var result = _CurrentToken;
_CurrentToken = null;
return(result);
}
/// <summary>
/// Parse a start tag
/// </summary>
protected ParsedToken ParseStartTag()
{
_StartTagPosition = _CurrentPosition;
_TagBuffer = SourceReader.OpenBuffer();
CharInfo c = ReadChar();
// Comments ?
if (c == '!')
{
// Expect '--' or 'DOCTYPE'
c = ReadChar();
if (Char.IsLetter(c.AsChar))
{
SaveChar(c);
return(ParseDoctype());
}
else if (c == '-')
{
if (ReadChar() != '-')
{
throw new ParseError("Comments need to start with '<!--'.", ReadPosition);
}
return(ParseComment());
}
throw new ParseError("Comment or DOCTYPE expected.", ReadPosition);
}
// Process instruction ?
if (c == '?')
{
_State = ParseState.ProcessInstruction;
c = ReadChar(false);
// Pass whitespace
while (c != CharInfo.EOF && Char.IsWhiteSpace(c.AsChar))
{
c = ReadChar(false);
}
}
else if (c == '/')
{
_State = ParseState.EndTag;
c = ReadChar(false);
if (c == CharInfo.EOF || !Char.IsLetterOrDigit(c.AsChar))
{
SaveChar(c);
throw new ParseError("Invalid tag name. Need to start with an alphanumeric", ReadPosition);
}
}
else
{
_State = ParseState.Tag;
}
// Tagname
if (c == CharInfo.EOF || !Char.IsLetterOrDigit(c.AsChar))
{
throw new ParseError("Invalid tag name. Need to start with an alphanumeric", ReadPosition);
}
// Loop tag name
_CurrentRead = null;
AddToCurrentRead(c);
while ((c = ReadChar(false)) != CharInfo.EOF && (Char.IsLetterOrDigit(c.AsChar) || c == '.' || c == ':' || c == '-'))
{
AddToCurrentRead(c);
}
// If EndTag
if (_State == ParseState.EndTag)
{
_CurrentToken = ParsedTag.EndTag(GetCurrentRead(true));
_CurrentToken.Position = _StartTagPosition;
// Pass whitespace
while (c != CharInfo.EOF && Char.IsWhiteSpace(c.AsChar))
{
c = ReadChar(false);
}
try
{
if (c == CharInfo.EOF)
{
throw new ParseError("Unexpected end of stream.", ReadPosition);
}
if (IsAttributeNameChar(c.AsChar))
{
throw new ParseError("End tag can't contains attribute.", ReadPosition);
}
if (c != '>')
{
throw new ParseError("Unexpected char. End tag not closed.", ReadPosition);
}
}
catch
{
// Reset steam
while (c != CharInfo.EOF && c != '<' && c != '>')
{
c = ReadChar(false);
}
if (c == '<')
{
SaveChar(c);
}
throw;
}
_State = ParseState.Content;
ResetTagBuffer();
var result = _CurrentToken;
_CurrentToken = null;
return(result);
}
// Create the tag
if (c != CharInfo.EOF)
{
SaveChar(c);
}
_CurrentToken = _State == ParseState.Tag ? ParsedTag.OpenTag(GetCurrentRead(true)) : ParsedTag.OpenProcessInstruction(GetCurrentRead(true));
_CurrentToken.Position = _StartTagPosition;
return(_CurrentToken);
}
/// <summary>
/// Parse in tag
/// </summary>
protected ParsedToken ParseInTag()
{
_CurrentRead = null;
// Whitespaces
CharInfo c;
while ((c = ReadChar(false)) != CharInfo.EOF && Char.IsWhiteSpace(c.AsChar))
{
;
}
var cpos = c.Position;
// EOF ?
if (c == CharInfo.EOF)
{
_CurrentToken = null;
_State = ParseState.Content;
ResetTagBuffer();
throw new ParseError("Unexpected end of file. Tag not closed.", ReadPosition);
}
// End of auto closed tag ?
else if (c == '/' && _State == ParseState.Tag)
{
CharInfo saveSlash = c;
bool spaces = false;
while ((c = ReadChar(false)) != CharInfo.EOF && Char.IsWhiteSpace(c.AsChar))
{
spaces = true;
}
if (c != '>')
{
// Prepare a correct next tag
SaveChar(new CharInfo('>', (c == CharInfo.EOF) ? saveSlash.Position : c.Position));
SaveChar(saveSlash);
throw new ParseError("Invalid char after '/'. End of auto closed tag expected.", cpos);
}
if (spaces)
{
// Prepare a correct next tag
SaveChar(c);
SaveChar(saveSlash);
// Raise the error
throw new ParseError("Invalid auto closed tag, '/' need to be follow by '>'.", cpos);
}
// Returns autoclosed
var result = ParsedTag.AutoClosedTag(((ParsedTag)_CurrentToken).TagName);
result.Position = cpos;
_CurrentToken = null;
_CurrentRead = null;
_State = ParseState.Content;
ResetTagBuffer();
return(result);
}
// End of process instruction
else if (c == '?' && _State == ParseState.ProcessInstruction)
{
c = ReadChar(false);
if (c != '>')
{
throw new ParseError("Invalid char after '?'. End of process instruction expected.", cpos);
}
// Returns processinstruction
var result = ParsedTag.CloseProcessInstruction(((ParsedTag)_CurrentToken).TagName);
result.Position = cpos;
_CurrentToken = null;
_CurrentRead = null;
_State = ParseState.Content;
ResetTagBuffer();
return(result);
}
else if (c == '>')
{
// Check tag
if (_State == ParseState.ProcessInstruction)
{
throw new ParseError("A process instruction need to be closed with '?>'.", cpos);
}
// Returns close
var result = ParsedTag.CloseTag(((ParsedTag)_CurrentToken).TagName);
result.Position = cpos;
_CurrentToken = null;
_CurrentRead = null;
_State = ParseState.Content;
ResetTagBuffer();
return(result);
}
// Get the attribute name
if (!IsAttributeNameChar(c.AsChar))
{
throw new ParseError("Unexpected character.", cpos);
}
AddToCurrentRead(c);
while ((c = ReadChar(false)) != CharInfo.EOF && IsAttributeNameChar(c.AsChar))
{
AddToCurrentRead(c);
}
if (c != CharInfo.EOF)
{
SaveChar(c);
}
String attrName = GetCurrentRead(true);
ParsePosition attrPos = cpos;
// Whitespaces
while ((c = ReadChar(false)) != CharInfo.EOF && Char.IsWhiteSpace(c.AsChar))
{
;
}
// Attribute whithout value
if (c != '=')
{
SaveChar(c);
// Attribute whithout content
return(new ParsedAttribute()
{
Position = attrPos,
Name = attrName,
Value = null,
Quote = '\0'
});
}
// Whitespaces
while ((c = ReadChar(false)) != CharInfo.EOF && Char.IsWhiteSpace(c.AsChar))
{
;
}
// Search the value
if (c == 0 || c == '/' || c == '?' || c == '>')
{
_CurrentAttr = new ParsedAttribute()
{
Position = attrPos,
Name = attrName,
Value = null,
Quote = '\0'
};
if (c != CharInfo.EOF)
{
SaveChar(c);
}
throw new ParseError("Attribute value expected.", ReadPosition);
}
// Quoted value ?
_CurrentRead = null;
char quote = '\0';
if (c == '"' || c == '\'')
{
quote = c.AsChar;
while ((c = ReadChar(false)) != CharInfo.EOF && c != quote)
{
AddToCurrentRead(c);
}
_CurrentAttr = new ParsedAttribute()
{
Position = attrPos,
Name = attrName,
Value = HEntity.HtmlDecode(GetCurrentRead(true), RemoveUnknownOrInvalidEntities),
Quote = quote
};
if (c == CharInfo.EOF)
{
throw new ParseError("Unexpected end of file. Attribute is not closed.", ReadPosition);
}
var result = _CurrentAttr;
_CurrentAttr = null;
return(result);
}
// Unquoted value
AddToCurrentRead(c);
while ((c = ReadChar(false)) != CharInfo.EOF && !Char.IsWhiteSpace(c.AsChar) && c != '"' && c != '\'' && c != '=' && c != '<' && c != '>' && c != '`')
{
AddToCurrentRead(c);
}
SaveChar(c);
return(new ParsedAttribute()
{
Position = attrPos,
Name = attrName,
Value = HEntity.HtmlDecode(GetCurrentRead(true), RemoveUnknownOrInvalidEntities),
Quote = quote
});
}
/// <summary>
/// Parse the next element
/// </summary>
public ParsedToken Parse()
{
CharInfo c;
// If end of stream when stop here
if (EOF)
{
return(null);
}
// Current token defined
if (_CurrentToken != null)
{
// End tag out Doctype : error while end tag or doctype parsing, reset parser
if (_CurrentToken.TokenType == ParsedTokenType.EndTag || _CurrentToken.TokenType == ParsedTokenType.Doctype)
{
_CurrentRead = null;
_State = ParseState.Content;
ResetTagBuffer();
LastParsed = _CurrentToken;
_CurrentToken = null;
return(LastParsed);
}
}
// Current Attribute defined
if (_CurrentAttr != null)
{
LastParsed = _CurrentAttr;
_CurrentAttr = null;
return(LastParsed);
}
// Current Read not empty ?
if (_CurrentRead != null)
{
bool returnLast = true;
switch (_State)
{
// Returns a non closed comment
case ParseState.Comment:
String comment = GetCurrentRead(true);
comment = comment.Substring(4).TrimStart();
LastParsed = new ParsedComment()
{
Position = _CurrentPosition,
Text = HEntity.HtmlDecode(comment, RemoveUnknownOrInvalidEntities)
};
break;
// Returns a text
case ParseState.Content:
LastParsed = new ParsedText()
{
Position = _CurrentPosition,
Text = HEntity.HtmlDecode(GetCurrentRead(true), RemoveUnknownOrInvalidEntities)
};
break;
// Returns a text
case ParseState.Doctype:
case ParseState.ProcessInstruction:
case ParseState.EndTag:
case ParseState.Tag:
//LastParsed = new ParsedText() {
// Position = _CurrentPosition,
// Text = GetCurrentRead(true)
//};
_State = ParseState.Content;
LastParsed = ParseText();
break;
// We forget the result
//default:
// returnLast = false;
// break;
}
_State = ParseState.Content;
ResetTagBuffer();
if (returnLast)
{
return(LastParsed);
}
}
// Read loop
while (true)
{
// Read next char
c = ReadChar();
// EOF ?
if (c == CharInfo.EOF)
{
// Check unexpected EOF
if (_State != ParseState.Content)
{
_State = ParseState.Content;
ResetTagBuffer();
throw new ParseError("End of file unexpected.", ReadPosition);
}
// Stop the parsing
LastParsed = null;
EOF = true;
return(null);
}
// Other case
switch (_State)
{
// In text
case ParseState.Content:
if (c == '<')
{
LastParsed = ParseStartTag();
}
else
{
LastParsed = ParseText();
}
return(LastParsed);
// In tag or process instruction
case ParseState.Tag:
case ParseState.Doctype:
case ParseState.ProcessInstruction:
SaveChar(c);
LastParsed = ParseInTag();
return(LastParsed);
default:
break;
}
}
}
internal static bool TryParse(ref Tokenizer tokenizer, out IpAddressV6 result)
{
// Shortest IPv6 is 2 chars (::)
// Longest regular IPv6 is 39 chars (0000:0000:0000:0000:0000:0000:0000:0000)
// Longest IPv4 mapped IPv6 is 45 chars (0000:0000:0000:0000:0000:ffff:255.255.255.255)
if (tokenizer.Length < 2 || tokenizer.Length > 45)
{
result = default;
return(false);
}
ulong high = 0;
ulong low = 0;
byte segmentsRead = 0;
bool doReverse = false;
// First pass, try reading a mask from the end of the input
ParsedToken tkn = tokenizer.PeekReverse(false);
if (tkn.Type == TokenType.Number)
{
// Could be a number, therefore an IPv4 mapped IPv6
ParsedToken slashTkn = tokenizer.PeekReverse(false);
if (slashTkn.Type == TokenType.Dot)
{
// This could be an IPv4 mapped in IPv6
// Carry on, see where it gets us
tokenizer.ResetPeekOffsets();
}
else if (slashTkn.Type != TokenType.Number && slashTkn.Type != TokenType.Colon && slashTkn.Type != TokenType.DoubleColon && slashTkn.Type != TokenType.None)
{
// Any IPv6 should end on a number or double-colon
// Single-token IPv6's are allowed, so we check for None as well
result = default;
return(false);
}
}
// Test if this could be an IPv4 mapped IPv6
// This could be the case if the last two tokens are [Dot, Number]
// Like '::ffff:192.168.1.0'
tkn = tokenizer.PeekReverse(false);
if (tkn.Type == TokenType.Number)
{
// If the next-to-last is a Dot, pass it on
ParsedToken tmpTkn = tokenizer.PeekReverse(false);
tokenizer.ResetPeekOffsets();
if (tmpTkn.Type == TokenType.Dot)
{
return(TryReadIPv4MappedIPv6(tokenizer, out result));
}
}
tokenizer.ResetPeekOffsets();
// Read up till a double-colon, eof or slash
for (byte i = 0; i < 8; i++)
{
tkn = tokenizer.ParseAndAdvance(true);
if (tkn.Type == TokenType.None)
{
break;
}
if (i > 0)
{
// The read token MUST be a colon or a double-colon
if (tkn.Type == TokenType.Colon)
{
// Advance once more
tkn = tokenizer.ParseAndAdvance(true);
}
else if (tkn.Type != TokenType.DoubleColon)
{
result = default;
return(false);
}
}
// Read a number or double-colon
if (tkn.Type == TokenType.Number)
{
BitUtilities.SetTuplet(ref low, ref high, i, tkn.Value);
segmentsRead++;
}
else if (tkn.Type == TokenType.DoubleColon)
{
doReverse = true;
break;
}
else if (tkn.Type != TokenType.DoubleColon)
{
result = default;
return(false);
}
}
// Read reverse
if (doReverse)
{
byte toRead = (byte)(8 - segmentsRead);
for (byte i = 0; i < toRead; i++)
{
tkn = tokenizer.ParseAndAdvanceReverse(true);
if (tkn.Type == TokenType.None)
{
break;
}
if (i > 0)
{
// The read token MUST be a colon
if (tkn.Type != TokenType.Colon)
{
result = default;
return(false);
}
// Advance once more
tkn = tokenizer.ParseAndAdvanceReverse(true);
}
// Read a number
if (tkn.Type == TokenType.Number)
{
BitUtilities.SetTuplet(ref low, ref high, (byte)(7 - i), tkn.Value);
segmentsRead++;
}
else
{
result = default;
return(false);
}
}
}
result = new IpAddressV6(high, low);
return(true);
}
public static ValueProviderBase?TryParse(string typeToken, string variable, ITemplateParser tp)
{
var type = typeToken.TryBefore(":") ?? "";
var token = typeToken.TryAfter(":") ?? typeToken;
switch (type)
{
case "":
{
if (token.StartsWith("$"))
{
string v = token.TryBefore('.') ?? token;
if (!tp.Variables.TryGetValue(v, out ValueProviderBase? vp))
{
tp.AddError(false, "Variable '{0}' is not defined at this scope".FormatWith(v));
return(null);
}
if (!(vp is TokenValueProvider))
{
return(new ContinueValueProvider(token.TryAfter('.'), vp, tp.AddError));
}
}
ParsedToken result = ParsedToken.TryParseToken(token, SubTokensOptions.CanElement, tp.QueryDescription, tp.Variables, tp.AddError);
if (result.QueryToken != null && TranslateInstanceValueProvider.IsTranslateInstanceCanditate(result.QueryToken))
{
return new TranslateInstanceValueProvider(result, false, tp.AddError)
{
Variable = variable
}
}
;
else
{
return new TokenValueProvider(result, false)
{
Variable = variable
}
};
}
case "q":
{
ParsedToken result = ParsedToken.TryParseToken(token, SubTokensOptions.CanElement, tp.QueryDescription, tp.Variables, tp.AddError);
return(new TokenValueProvider(result, true)
{
Variable = variable
});
}
case "t":
{
ParsedToken result = ParsedToken.TryParseToken(token, SubTokensOptions.CanElement, tp.QueryDescription, tp.Variables, tp.AddError);
return(new TranslateInstanceValueProvider(result, true, tp.AddError)
{
Variable = variable
});
}
case "m":
return(new ModelValueProvider(token, tp.ModelType, tp.AddError)
{
Variable = variable
});
case "g":
return(new GlobalValueProvider(token, tp.AddError)
{
Variable = variable
});
case "d":
return(new DateValueProvider(token, tp.AddError)
{
Variable = variable
});
default:
tp.AddError(false, "{0} is not a recognized value provider (q:Query, t:Translate, m:Model, g:Global or just blank)");
return(null);
}
}
