public SqlBinaryExpression(string sql, SqlExpression left, RawToken @operator, SqlExpression right)
: base(sql, CreateChildren(left, right))
{
this.Left = left;
this.Operator = @operator.WithParent(this);
this.Right = right;
}
private void ParseDecorator(RawTemplate template, ref RawToken token, RawTokenEnumerator enumerator, ref FlatTokenParserState state, ref RawTokenDecorator decorator)
{
var next = enumerator.Next();
if (string.IsNullOrWhiteSpace(next))
{
return;
}
switch (next)
{
case "}":
token.Decorators.Add(decorator);
template.Tokens.Add(token);
token = new RawToken();
decorator = new RawTokenDecorator();
state = FlatTokenParserState.InPreamble;
break;
case ",":
token.Decorators.Add(decorator);
decorator = new RawTokenDecorator();
break;
case "(":
state = FlatTokenParserState.InDecoratorArgument;
break;
default:
decorator.AppendName(next);
break;
}
}
public SqlParenthesizedExpression(string sql, RawToken openParen, SqlExpression expression, RawToken closeParen)
: base(sql, CreateChildren(expression))
{
this.OpenParen = openParen.WithParent(this);
this.Expression = expression;
this.CloseParen = closeParen.WithParent(this);
}
public static Token Exchange(RawToken raw)
{
if (raw.Lexeme == "(")
{
return(new Token(TokenType.LParen));
}
else if (raw.Lexeme == ")")
{
return(new Token(TokenType.RParen));
}
else if (raw.Lexeme == "[")
{
return(new Token(TokenType.LBracket));
}
else if (raw.Lexeme == "]")
{
return(new Token(TokenType.RBracket));
}
else if (raw.Lexeme == "{")
{
return(new Token(TokenType.LBrace));
}
else if (raw.Lexeme == "}")
{
return(new Token(TokenType.RBrace));
}
//UNFINISHED!
}
public ResTarget(string sql, SqlExpression value, RawToken @as, SqlSimpleName name)
: base(sql, CreateChildren(value, name))
{
this.Value = value;
this.As = @as.WithParent(this);
this.Name = name;
}
void RequestToken()
{
logger.Info("Requesting token");
using (var httpClient = new HttpClient())
{
using (var request = new HttpRequestMessage(new HttpMethod("POST"), tokenURL))
{
var base64authorization = Convert.ToBase64String(Encoding.ASCII.GetBytes($"{ClientID}:{ClientSecret}"));
request.Headers.TryAddWithoutValidation("Authorization", $"Basic {base64authorization}");
request.Content = new StringContent("grant_type=client_credentials", Encoding.UTF8, "application/x-www-form-urlencoded");
var response = httpClient.SendAsync(request);
response.Wait();
var data = response.Result.Content.ReadAsStringAsync();
data.Wait();
token = JsonConvert.DeserializeObject <RawToken>(data.Result);
expires = DateTime.UtcNow.AddSeconds(token.expires_in);
}
}
#if DEBUG
logger.Debug("[DEBUG] Access token: {0}", token.access_token);
#endif
}
public SqlQualifiedName(string sql, SqlSimpleName prefix, RawToken dot, SqlSimpleName identifier)
: base(sql, CreateChildren(prefix, identifier))
{
this.Prefix = prefix;
this.Dot = dot.WithParent(this);
this.Identifier = identifier;
}
public SqlInvocation(string sql, SqlName name, RawToken openParen, SqlArgumentList argumentList, RawToken closeParen)
: base(sql, CreateChildren(name, argumentList))
{
this.Name = name;
this.OpenParen = openParen.WithParent(this);
this.ArgumentList = argumentList;
this.CloseParen = closeParen.WithParent(this);
}
private void Parse()
{
this.Claims = new NameValueCollection();
if (RawToken.StartsWith("wrap_access_token="))
{
RawToken = RawToken.Replace("wrap_access_token=", "");
}
foreach (var rawNameValue in RawToken.Split(new[] { '&' }, StringSplitOptions.RemoveEmptyEntries))
{
if (rawNameValue.StartsWith("HMACSHA256="))
{
continue;
}
var nameValue = rawNameValue.Split('=');
if (nameValue.Length != 2)
{
throw new InvalidSecurityTokenException(string.Format(
"Invalid token contains a name/value pair missing an = character: '{0}'", rawNameValue));
}
var key = HttpUtility.UrlDecode(nameValue[0]);
if (this.Claims.AllKeys.Contains(key))
{
throw new InvalidSecurityTokenException("Duplicated name token.");
}
var values = HttpUtility.UrlDecode(nameValue[1]);
switch (key)
{
case Saml2Constants.Elements.Audience:
this.Audience = values;
break;
case "ExpiresOn":
this.ExpiresOn = ulong.Parse(values).ToDateTimeFromEpoch();
break;
case Saml2Constants.Elements.Issuer:
this.Issuer = values;
break;
default:
foreach (var value in values.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries))
{
this.Claims.Add(key, value);
}
break;
}
}
}
public bool IsValidSignature(string signatureKey)
{
var result = false;
const string separator = "&" + SwtConstants.HmacSha256 + "=";
var elements = RawToken.Split(new string[] { separator }, StringSplitOptions.None);
if (elements.Length == 2)
{
var validSignature = HttpUtility.UrlEncode(CalculateSignature(elements[0], signatureKey));
result = string.Equals(validSignature, elements[1], StringComparison.InvariantCulture);
}
return(result);
}
private static void Tokenize(List <int> parserPriorities, List <Token> tokens)
{
for (int index = 0; index < parserPriorities.Count; index++)
{
int curParserPriority = parserPriorities[index];
bool tokenAdded = false;
do
{
tokenAdded = false;
for (int tokenIndex = 0; tokenIndex < tokens.Count; tokenIndex++)
{
RawToken rawToken = tokens[tokenIndex] as RawToken;
Token precedentToken = (tokenIndex > 0) ? tokens[tokenIndex - 1] : null;
if (rawToken != null)
{
FilterCriterionToken filterToken;
int startIndex;
int length;
if (FilterParser.ExtractFirstCriterion(precedentToken, rawToken, curParserPriority, out filterToken, out startIndex, out length))
{
tokens.RemoveAt(tokenIndex);
if (startIndex > 0)
{
tokens.Insert(tokenIndex, new RawToken(rawToken.Value.Substring(0, startIndex)));
tokenIndex++;
}
tokens.Insert(tokenIndex, filterToken);
tokenIndex++;
if (startIndex + length < rawToken.Value.Length)
{
tokens.Insert(tokenIndex, new RawToken(rawToken.Value.Substring(startIndex + length)));
}
tokenAdded = true;
break;
}
}
}
}while(tokenAdded);
}
}
/// <summary>
/// Appends the specified token to this expression.
/// </summary>
/// <param name="token">The token.</param>
/// <exception cref="System.InvalidOperationException"></exception>
public void Append(RawToken token)
{
if (IsFrozen)
{
throw new InvalidOperationException(FrozenErrorMsg);
}
if (_rawToken == null)
{
_rawToken = token;
}
else
{
_rawToken.Append(token);
}
}
private void ParsePreamble(ref RawToken token, RawTokenEnumerator enumerator, ref FlatTokenParserState state)
{
var next = enumerator.Next();
switch (next)
{
case "{":
state = FlatTokenParserState.InTokenName;
break;
default:
if (token.Preamble == null)
{
token.Preamble = string.Empty;
}
token.Preamble += next;
break;
}
}
private void ProcessToken()
{
string payload = RawToken.Split('.') [1];
var bytes = ParseBase64WithoutPadding(payload);
var json = Encoding.ASCII.GetString(bytes);
var dictionary = JsonConvert.DeserializeObject <Dictionary <string, object> > (json);
if (dictionary.TryGetValue("role", out object role))
{
Role = role.ToString();
}
if (dictionary.TryGetValue("exp", out object expiryInSeconds))
{
CalculateExpiry((Int64)expiryInSeconds);
}
if (dictionary.TryGetValue("nameid", out object id))
{
Id = Guid.Parse(id.ToString());
}
}
public OptimizerResult OptimizeExpression(string expression)
{
var cleanExpression = expression.RemoveSpaces().RemoveOuterBrackets();
var isFunctionRecursion = IsFunctionRecursion(expression);
if (cleanExpression.Length > _optimalExpressionLength || isFunctionRecursion)
{
if (TryOptimizeByOperatorSplit(cleanExpression, out var result) ||
TryOptimizeByArguments(cleanExpression, out result) ||
TryOptimizeByRecursiveFunction(cleanExpression, out result) && isFunctionRecursion)
{
return(result);
}
}
var rawToken = new RawToken(expression);
return(new OptimizerResult(rawToken));
}
public RawTemplate Parse(string pattern, TokenizerOptions options)
{
var template = new RawTemplate();
template.Options = options.Clone();
var enumerator = new RawTokenEnumerator(pattern);
if (enumerator.IsEmpty)
{
return(template);
}
var state = FlatTokenParserState.AtStart;
var token = new RawToken();
var decorator = new RawTokenDecorator();
var argument = string.Empty;
var frontMatterName = new StringBuilder();
var frontMatterValue = new StringBuilder();
while (enumerator.IsEmpty == false)
{
switch (state)
{
case FlatTokenParserState.AtStart:
ParseStart(enumerator, ref state);
break;
case FlatTokenParserState.InFrontMatter:
ParseFrontMatter(enumerator, ref frontMatterName, ref state);
break;
case FlatTokenParserState.InFrontMatterComment:
ParseFrontMatterComment(enumerator, ref state);
break;
case FlatTokenParserState.InFrontMatterOption:
ParseFrontMatterOption(enumerator, ref frontMatterName, ref state);
break;
case FlatTokenParserState.InFrontMatterOptionValue:
ParseFrontMatterOptionValue(template, enumerator, ref frontMatterName, ref frontMatterValue, ref state);
break;
case FlatTokenParserState.InPreamble:
ParsePreamble(ref token, enumerator, ref state);
break;
case FlatTokenParserState.InTokenName:
ParseTokenName(template, ref token, enumerator, ref state);
break;
case FlatTokenParserState.InDecorator:
ParseDecorator(template, ref token, enumerator, ref state, ref decorator);
break;
case FlatTokenParserState.InDecoratorArgument:
ParseDecoratorArgument(enumerator, ref state, ref decorator, ref argument);
break;
case FlatTokenParserState.InDecoratorArgumentSingleQuotes:
ParseDecoratorArgumentInSingleQuotes(enumerator, ref state, ref decorator, ref argument);
break;
case FlatTokenParserState.InDecoratorArgumentDoubleQuotes:
ParseDecoratorArgumentInDoubleQuotes(enumerator, ref state, ref decorator, ref argument);
break;
case FlatTokenParserState.InDecoratorArgumentRunOff:
ParseDecoratorArgumentRunOff(enumerator, ref state, ref decorator, ref argument);
break;
default:
throw new TokenizerException($"Unknown FlatTokenParserState: {state}");
}
}
// Append current token if it has contents
// Note: allow empty token values, as these will serve to truncate the last
// token in the template
if (string.IsNullOrWhiteSpace(token.Preamble) == false)
{
template.Tokens.Add(token);
}
return(template);
}
public SqlPrefixUnaryExpression(string sql, RawToken @operator, SqlExpression operand)
: base(sql, CreateChildren(operand))
{
this.Operator = @operator.WithParent(this);
this.Operand = operand;
}
public WhereClause(string sql, RawToken keyword, SqlBinaryExpression condition)
: base(sql, CreateChildren(condition))
{
this.Keyword = keyword.WithParent(this);
this.Condition = condition;
}
//private static bool ExtractFirstCriterion( List<Token> rawTokens, int tokenIndex, int parserPriority, out FilterCriterionToken filterToken, out int startIndex, out int length )
private static bool ExtractFirstCriterion(Token precedentToken, RawToken rawToken, int parserPriority, out FilterCriterionToken filterToken, out int startIndex, out int length)
{
//RawToken rawToken = rawTokens[ tokenIndex ] as RawToken;
Type foundCriterionType = null;
filterToken = null;
startIndex = int.MaxValue;
length = 0;
foreach (Type type in FilterParser.RegisteredFilterCriterionTypes)
{
CriterionDescriptorAttribute attribute = ( CriterionDescriptorAttribute )type.GetCustomAttributes(typeof(CriterionDescriptorAttribute), true)[0];
if (( int )attribute.ParserPriority == parserPriority)
{
if (!string.IsNullOrEmpty(attribute.Pattern))
{
string separator = attribute.Pattern.Replace("@", "");
int foundIndex = -1;
if (attribute.Pattern.StartsWith("@"))
{
// The keyword can be anywhere in the token (there can be characters
// before the token).
foundIndex = rawToken.Value.IndexOf(separator);
}
//else if( ( rawTokens[ tokenIndex + 1 ] as AtomicStringToken ) != null )
//{
//}
else
{
// The keyword must be the first non whitespace character.
if (rawToken.Value.TrimStart(null).StartsWith(separator))
{
foundIndex = rawToken.Value.IndexOf(separator);
}
}
if ((foundIndex >= 0) &&
((foundIndex < startIndex) ||
((foundIndex == startIndex) && (separator.Length > length))))
{
if (type == typeof(EndsWithFilterCriterion) && (precedentToken as AtomicStringToken) != null)
{
foundCriterionType = typeof(StartsWithFilterCriterion);
}
else
{
foundCriterionType = type;
}
startIndex = foundIndex;
length = separator.Length;
}
}
else
{
if (type != typeof(ContainsFilterCriterion))
{
throw new DataGridInternalException("Missing pattern in attribute: " + type.Name);
}
}
}
}
if (foundCriterionType != null)
{
filterToken = new FilterCriterionToken(( FilterCriterion )Activator.CreateInstance(foundCriterionType));
}
return(filterToken != null);
}
public FromClause(string sql, RawToken keyword, RangeVar rangeVar)
: base(sql, CreateChildren(rangeVar))
{
this.Keyword = keyword.WithParent(this);
this.RangeVar = rangeVar;
}
private static string TypeAndValue(string sql, RawToken token)
{
return($"{token.Kind}: {sql.Substring(token.Start, token.Length)}");
}
/// <summary>
/// Create list of tokens from epl
/// </summary>
/// <param name="epl">EPL code</param>
/// <param name="listener">Error listener</param>
/// <returns>List of tokens</returns>
public static IList <EPLCommand> Parse(string epl, IErrorListener listener)
{
if (epl == null)
{
throw new ArgumentNullException("epl");
}
if (!epl.EndsWith(Environment.NewLine))
{
epl += Environment.NewLine;
}
IList <EPLCommand> commands = new List <EPLCommand>();
// Get list of commands, sorted by length descending
string[] commandList = EPLCommandHelper.CommandDefinition.Select(item => item.Key).OrderByDescending(item => item.Length).ToArray();
var eplTokenizer = new Lexer.Tokenizer(new Lexer.ParserConfiguration(), listener);
eplTokenizer.Parse(epl);
var tokens = eplTokenizer.Tokens;
RawToken lastToken = null;
RawToken token = null;
EPLCommand lastCommand = null;
int lineNumber = 1;
int paramCounter = 0;
ParserState state = ParserState.ExpectNewCommand;
int _qCommandExists = 0;
int _RCommandExists = 0;
while (tokens.Count > 0)
{
lastToken = token;
token = tokens.PopFirst();
// Parse x-command
if (token.Content.StartsWith(";"))
{
lineNumber++;
state = ParserState.ExpectNewCommand;
}
else if (token.Content == "{" && state == ParserState.ExpectParameter)
{
StringBuilder sb = new StringBuilder();
sb.Append("{");
while (tokens.Count > 0)
{
token = tokens.PopFirst();
if (token.Content == "}")
{
sb.Append(token.Content);
break;
}
else if (token.Content == Environment.NewLine)
{
listener.Error("Expected token }", lineNumber, token.Index.Item1, token.Index.Item2);
}
else
{
sb.Append(token.Content);
}
}
// Set as command
if (lastCommand != null)
{
string[] newParamArr = new string[paramCounter + 1];
newParamArr[paramCounter] = sb.ToString();
if (lastCommand.Parameter != null)
{
for (int i = 0; i < paramCounter; i++)
{
newParamArr[i] = lastCommand.Parameter[i];
}
}
// Set token content
lastCommand.Parameter = newParamArr;
paramCounter++;
state = ParserState.ExpectNewCommand | ParserState.ExpectParamSeperator;
}
state = ParserState.ExpectParamSeperator | ParserState.ExpectNewCommand;
}
// Parse command data
else if (token.Content.StartsWith("\"") && token.Content.EndsWith("\"") && state == ParserState.ExpectParameter && token.Content.Length > 1)
{
if (lastCommand != null)
{
lastCommand.Data = token.Content.Remove(0, 1);
lastCommand.Data = lastCommand.Data.Remove(lastCommand.Data.Length - 1, 1);
}
state = ParserState.ExpectParamSeperator | ParserState.ExpectNewCommand;
}
else if (token.Content == "@{" && state == ParserState.ExpectNewCommand)
{
StringBuilder sb = new StringBuilder();
while (tokens.Count > 0)
{
token = tokens.PopFirst();
if (token.Content == "}@")
{
break;
}
else
{
if (!sb.ToString().EndsWith(Environment.NewLine))
{
sb.Append(" ");
}
sb.Append(token.Content);
}
}
commands.Add(new ScriptCommand()
{
Data = sb.ToString()
});
}
else if (token.Content == "," && (state & ParserState.ExpectParamSeperator) == ParserState.ExpectParamSeperator)
{
state = ParserState.ExpectParameter;
}
else if (token.Content == Environment.NewLine && (state == ParserState.ExpectNewCommand || (state & ParserState.ExpectParamSeperator) == ParserState.ExpectParamSeperator))
{
state = ParserState.ExpectNewCommand;
lineNumber++;
}
else if (IsCommand(commandList, token.Content) && (state & ParserState.ExpectNewCommand) == ParserState.ExpectNewCommand || (state & ParserState.ExpectParamSeperator) == ParserState.ExpectParamSeperator)
{
// go through the list of commands
lastCommand = null;
paramCounter = 0;
foreach (string cmd in commandList)
{
if (token.Content.StartsWith(cmd))
{
lastCommand = EPLCommandHelper.GetInstance(cmd);
lastCommand.Token = token;
if (lastCommand is UnkownCommand)
{
(lastCommand as UnkownCommand).CommandName = cmd;
}
else if (lastCommand is LabelWidthCommand)
{
_qCommandExists = lineNumber;
}
else if (lastCommand is RCommand)
{
_RCommandExists = lineNumber;
}
string newTokenContent = token.Content.Remove(0, cmd.Length);
if (newTokenContent == "" && (tokens.Count == 0 || tokens.PeekFirst().Content == Environment.NewLine))
{
state = ParserState.ExpectNewCommand;
}
else
{
state = ParserState.ExpectParameter;
if (!string.IsNullOrWhiteSpace(newTokenContent))
{
// Add first parameter value again
tokens.PushFront(new Lexer.RawToken(newTokenContent, new Tuple <int, int>(0, 0), new Tuple <int, int>(0, 0)));
}
}
break;
}
}
if (lastCommand != null)
{
commands.Add(lastCommand);
}
}
else if (state == ParserState.ExpectParameter && token.Content != Environment.NewLine)
{
if (lastCommand != null)
{
string[] newParamArr = new string[paramCounter + 1];
newParamArr[paramCounter] = token.Content;
if (lastCommand.Parameter != null)
{
for (int i = 0; i < paramCounter; i++)
{
newParamArr[i] = lastCommand.Parameter[i];
}
}
// Set token content
lastCommand.Parameter = newParamArr;
paramCounter++;
state = ParserState.ExpectNewCommand | ParserState.ExpectParamSeperator;
}
}
else
{
listener.Error("Unexpected token near: " + (lastToken ?? token).Content, lineNumber, 0, 0);
}
}
if (_qCommandExists > 0 && _RCommandExists > 0)
{
if (_qCommandExists < _RCommandExists)
{
listener.Error("If the R-Command is sent after the q-command, the image buffer will be reformatted to printer width.", _RCommandExists, 0, 0);
}
else
{
listener.Error("The R-command forces the printer to use the full width of the print head as the width of the label/image buffer.", _qCommandExists, 0, 0);
}
}
return(commands);
}
public SqlParameter(string sql, RawToken at, SqlSimpleName identifier)
: base(sql, CreateChildren(identifier))
{
this.At = at.WithParent(this);
this.Identifier = identifier;
}
private void ParseTokenName(RawTemplate template, ref RawToken token, RawTokenEnumerator enumerator, ref FlatTokenParserState state)
{
var next = enumerator.Next();
var peek = enumerator.Peek();
switch (next)
{
case "{":
throw new ParsingException($"Unexpected character '{{' in token '{token.Name}'", enumerator);
case "}":
template.Tokens.Add(token);
token = new RawToken();
state = FlatTokenParserState.InPreamble;
break;
case "$":
token.TerminateOnNewline = true;
switch (peek)
{
case "?":
case "*":
case "}":
case ":":
break;
default:
throw new ParsingException($"Invalid character '{peek}' in token '{token.Name}'", enumerator);
}
break;
case "?":
token.Optional = true;
switch (peek)
{
case "$":
case "*":
case "}":
case ":":
break;
default:
throw new ParsingException($"Invalid character '{peek}' in token '{token.Name}'", enumerator);
}
break;
case "*":
token.Repeating = true;
token.Optional = true;
switch (peek)
{
case "$":
case "?":
case "}":
case ":":
break;
default:
throw new ParsingException($"Invalid character '{peek}' in token '{token.Name}'", enumerator);
}
break;
case ":":
state = FlatTokenParserState.InDecorator;
break;
default:
if (token.Name == null)
{
token.Name = string.Empty;
}
if (ValidTokenNameCharacters.Contains(next))
{
token.Name += next;
}
else
{
throw new ParsingException($"Invalid character '{next}' in token '{token.Name}'", enumerator);
}
break;
}
}
