public ExprOp Parse(InputTextStream inStream, AmountParseFlagsEnum flags = AmountParseFlagsEnum.PARSE_DEFAULT, string originalString = null)
{
try
{
ExprOp topNode = ParseValueExpr(inStream, flags);
if (UseLookahead)
{
UseLookahead = false;
Lookahead.Rewind(inStream);
}
Lookahead.Clear();
return(topNode);
}
catch
{
if (!String.IsNullOrEmpty(originalString))
{
ErrorContext.Current.AddErrorContext("While parsing value expression:");
int endPos = inStream.Pos;
int pos = endPos > 0 ? endPos - Lookahead.Length : 0;
ErrorContext.Current.AddErrorContext(ErrorContext.LineContext(originalString, pos, endPos));
}
throw;
}
}
public ExprOp ParseOrExpr(InputTextStream inStream, AmountParseFlagsEnum tFlags)
{
ExprOp node = ParseAndExpr(inStream, tFlags);
if (node != null && !tFlags.HasFlag(AmountParseFlagsEnum.PARSE_SINGLE))
{
while (true)
{
ExprToken tok = NextToken(inStream, tFlags | AmountParseFlagsEnum.PARSE_OP_CONTEXT);
if (tok.Kind == ExprTokenKind.KW_OR)
{
ExprOp prev = node;
node = new ExprOp(OpKindEnum.O_OR);
node.Left = prev;
node.Right = ParseAndExpr(inStream, tFlags);
if (node.Right == null)
{
throw new ParseError(String.Format(ParseError.ParseError_OperatorNotFollowedByArgument, tok.Symbol));
}
}
else
{
PushToken(tok);
break;
}
}
}
return(node);
}
public ExprOp ParseAssingExpr(InputTextStream inStream, AmountParseFlagsEnum tFlags)
{
ExprOp node = ParseLambdaExpr(inStream, tFlags);
if (node != null && !tFlags.HasFlag(AmountParseFlagsEnum.PARSE_SINGLE))
{
while (true)
{
ExprToken tok = NextToken(inStream, tFlags | AmountParseFlagsEnum.PARSE_OP_CONTEXT);
if (tok.Kind == ExprTokenKind.ASSIGN)
{
ExprOp prev = node;
node = new ExprOp(OpKindEnum.O_DEFINE);
node.Left = prev;
ExprOp scope = new ExprOp(OpKindEnum.SCOPE);
scope.Left = ParseLambdaExpr(inStream, tFlags);
node.Right = scope;
}
else
{
PushToken(tok);
break;
}
}
}
return(node);
}
public ExprOp ParseValueTerm(InputTextStream inStream, AmountParseFlagsEnum tFlags)
{
ExprOp node = null;
ExprToken tok = NextToken(inStream, tFlags);
switch (tok.Kind)
{
case ExprTokenKind.VALUE:
node = new ExprOp(OpKindEnum.VALUE);
node.AsValue = tok.Value;
break;
case ExprTokenKind.IDENT:
string ident = tok.Value.AsString;
node = new ExprOp(OpKindEnum.IDENT);
node.AsIdent = ident;
break;
case ExprTokenKind.LPAREN:
node = ParseValueExpr(inStream, (tFlags | AmountParseFlagsEnum.PARSE_PARTIAL) & ~AmountParseFlagsEnum.PARSE_SINGLE);
tok = NextToken(inStream, tFlags, ExprTokenKind.RPAREN);
break;
default:
PushToken(tok);
break;
}
return(node);
}
/// <summary>
/// Ported from parse_single_expression
/// </summary>
private Expr ParseSingleExpression(InputTextStream inStream, bool singleExpr = true)
{
string p = inStream.RemainSource;
int pIndex = inStream.Pos;
Expr expr = new Expr();
expr.Parse(inStream, singleExpr ? AmountParseFlagsEnum.PARSE_SINGLE : AmountParseFlagsEnum.PARSE_PARTIAL, p);
if (inStream.Eof)
{
expr.Text = p;
}
else
{
expr.Text = p.Substring(0, inStream.Pos - pIndex);
inStream.Pos--;
// Don't gobble up any whitespace
while (char.IsWhiteSpace(inStream.Peek))
{
inStream.Pos--;
}
}
return(expr);
}
public ExprOp ParseCallExpr(InputTextStream inStream, AmountParseFlagsEnum tFlags)
{
ExprOp node = ParseValueTerm(inStream, tFlags);
if (node != null && !tFlags.HasFlag(AmountParseFlagsEnum.PARSE_SINGLE))
{
while (true)
{
ExprToken tok = NextToken(inStream, tFlags | AmountParseFlagsEnum.PARSE_OP_CONTEXT);
if (tok.Kind == ExprTokenKind.LPAREN)
{
ExprOp prev = node;
node = new ExprOp(OpKindEnum.O_CALL);
node.Left = prev;
PushToken(tok); // let the parser see the '(' again
node.Right = ParseValueExpr(inStream, tFlags | AmountParseFlagsEnum.PARSE_SINGLE);
}
else
{
PushToken(tok);
break;
}
}
}
return(node);
}
public ExprOp Parse(InputTextStream inStream, AmountParseFlagsEnum flags = AmountParseFlagsEnum.PARSE_DEFAULT, string originalString = null)
{
try
{
ExprOp topNode = ParseValueExpr(inStream, flags);
if (UseLookahead)
{
UseLookahead = false;
Lookahead.Rewind(inStream);
}
Lookahead.Clear();
return(topNode);
}
catch
{
if (!String.IsNullOrEmpty(originalString))
{
ErrorContext.Current.AddErrorContext("While parsing value expression:");
int endPos = inStream.Pos;
int pos = endPos > 0 ? endPos - Lookahead.Length : 0;
Logger.Current.Debug("parser.error", () => String.Format("original_string = '{0}'", originalString));
Logger.Current.Debug("parser.error", () => String.Format(" pos = {0}", pos));
Logger.Current.Debug("parser.error", () => String.Format(" end_pos = {0}", endPos));
Logger.Current.Debug("parser.error", () => String.Format(" token kind = {0}", Lookahead.Kind));
Logger.Current.Debug("parser.error", () => String.Format(" token length = {0}", Lookahead.Length));
ErrorContext.Current.AddErrorContext(ErrorContext.LineContext(originalString, pos, endPos));
}
throw;
}
}
public ExprOp ParseUnaryExpr(InputTextStream inStream, AmountParseFlagsEnum tFlags)
{
ExprOp node = null;
ExprToken tok = NextToken(inStream, tFlags);
switch (tok.Kind)
{
case ExprTokenKind.EXCLAM:
{
ExprOp term = ParseDotExpr(inStream, tFlags);
if (term == null)
{
throw new ParseError(String.Format(ParseError.ParseError_OperatorNotFollowedByArgument, tok.Symbol));
}
// A very quick optimization
if (term.Kind == OpKindEnum.VALUE)
{
term.AsValue.InPlaceNot();
node = term;
}
else
{
node = new ExprOp(OpKindEnum.O_NOT);
node.Left = term;
}
break;
}
case ExprTokenKind.MINUS:
{
ExprOp term = ParseDotExpr(inStream, tFlags);
if (term == null)
{
throw new ParseError(String.Format(ParseError.ParseError_OperatorNotFollowedByArgument, tok.Symbol));
}
// A very quick optimization
if (term.Kind == OpKindEnum.VALUE)
{
term.AsValue.InPlaceNegate();
node = term;
}
else
{
node = new ExprOp(OpKindEnum.O_NEG);
node.Left = term;
}
break;
}
default:
PushToken(tok);
node = ParseDotExpr(inStream, tFlags);
break;
}
return(node);
}
public void ExprParser_ParseUnaryExpr_MINUS_Produces_O_NEG()
{
var parser = new ExprParser();
var inStream = new InputTextStream("-SOMETHING");
var exprOp = parser.ParseUnaryExpr(inStream, AmountParseFlagsEnum.PARSE_DEFAULT);
Assert.AreEqual(OpKindEnum.O_NEG, exprOp.Kind);
}
static internal ErrorCode InternalUpdateState32(State32 state, byte[] input, int offset, int length)
{
InputTextStream p = new InputTextStream(input, offset);
long bEnd = p.Position + length;
state.total_len += (ulong)length;
if (state.memsize + length < 16) /* fill in tmp buffer */
{
Array.Copy(input, offset, state.mem32, state.memsize, length);
state.memsize += (uint)length;
return(ErrorCode.XXH_OK);
}
if (state.memsize > 0) /* some data left from previous update */
{
Array.Copy(input, offset, state.mem32, state.memsize, 16 - state.memsize);
{
InputTextStream p32 = new InputTextStream(state.mem32);
state.v1 = XXH32_round(state.v1, p32.ReadUInt32());
state.v2 = XXH32_round(state.v2, p32.ReadUInt32());
state.v3 = XXH32_round(state.v3, p32.ReadUInt32());
state.v4 = XXH32_round(state.v4, p32.ReadUInt32());
}
p.Skip(16 - (int)state.memsize);
state.memsize = 0;
}
if (p.Position <= bEnd - 16)
{
long limit = bEnd - 16;
uint v1 = state.v1;
uint v2 = state.v2;
uint v3 = state.v3;
uint v4 = state.v4;
do
{
v1 = XXH32_round(v1, p.ReadUInt32());
v2 = XXH32_round(v2, p.ReadUInt32());
v3 = XXH32_round(v3, p.ReadUInt32());
v4 = XXH32_round(v4, p.ReadUInt32());
}while (p.Position <= limit);
state.v1 = v1;
state.v2 = v2;
state.v3 = v3;
state.v4 = v4;
}
if (p.Position < bEnd)
{
Array.Copy(input, p.Position, state.mem32, 0, bEnd - p.Position);
state.memsize = (uint)(bEnd - p.Position);
}
return(ErrorCode.XXH_OK);
}
public void InputTextStream_ReadInt_ReturnsDefaultValueIfNoDigits()
{
InputTextStream stream = new InputTextStream("()");
char nextChar;
int result = stream.ReadInt(25, out nextChar);
Assert.Equal(25, result);
Assert.Equal('(', nextChar);
}
public void InputTextStream_ReadInt_ReadsIntegerValue()
{
InputTextStream stream = new InputTextStream("12345)");
char nextChar;
int result = stream.ReadInt(0, out nextChar);
Assert.Equal(12345, result);
Assert.Equal(')', nextChar);
}
public void ParseIdent(InputTextStream inStream)
{
Kind = ExprTokenKind.IDENT;
string buf;
char c;
Length = inStream.ReadInto(out buf, out c, ch => char.IsLetterOrDigit(ch) || ch == '_');
Value = Value.Get(buf, true); // [DM] It equals to 'value.set_string(buf);'
}
public void ExprTokenTests_ParseIdent_DetectsIdentifiers()
{
String source = "ident ident1 ident_2";
InputTextStream inStream = new InputTextStream(source);
ExprToken token = new ExprToken();
Func <int> act = () => { token.ParseIdent(inStream); return(0); };
ReadAndCheckTokenProps(act, ref token, inStream, 0, ExprTokenKind.IDENT, 5, Value.Get("ident"), String.Empty);
ReadAndCheckTokenProps(act, ref token, inStream, 0, ExprTokenKind.IDENT, 6, Value.Get("ident1"), String.Empty);
ReadAndCheckTokenProps(act, ref token, inStream, 0, ExprTokenKind.IDENT, 7, Value.Get("ident_2"), String.Empty);
}
static internal ulong InternalDigestState64(State64 state)
{
InputTextStream p = new InputTextStream(state.mem64);
long bEnd = state.memsize;
ulong h64;
if (state.total_len >= 32)
{
ulong v1 = state.v1;
ulong v2 = state.v2;
ulong v3 = state.v3;
ulong v4 = state.v4;
h64 = XXH_rotl64(v1, 1) + XXH_rotl64(v2, 7) + XXH_rotl64(v3, 12) + XXH_rotl64(v4, 18);
h64 = XXH64_mergeRound(h64, v1);
h64 = XXH64_mergeRound(h64, v2);
h64 = XXH64_mergeRound(h64, v3);
h64 = XXH64_mergeRound(h64, v4);
}
else
{
h64 = state.v3 + PRIME64_5;
}
h64 += state.total_len;
while (p.Position + 8 <= bEnd)
{
ulong k1 = XXH64_round(0, p.ReadUInt64());
h64 ^= k1;
h64 = XXH_rotl64(h64, 27) * PRIME64_1 + PRIME64_4;
}
if (p.Position + 4 <= bEnd)
{
h64 ^= (ulong)(p.ReadUInt32()) * PRIME64_1;
h64 = XXH_rotl64(h64, 23) * PRIME64_2 + PRIME64_3;
}
while (p.Position < bEnd)
{
h64 ^= p.ReadByte() * PRIME64_5;
h64 = XXH_rotl64(h64, 11) * PRIME64_1;
}
h64 ^= h64 >> 33;
h64 *= PRIME64_2;
h64 ^= h64 >> 29;
h64 *= PRIME64_3;
h64 ^= h64 >> 32;
return(h64);
}
private void ReadAndCheckTokenProps(Func <int> act, ref ExprToken token, InputTextStream inStream, int expectedResult, ExprTokenKind expectedKind, int expectedLength, Value expectedValue, string expectedSymbol)
{
inStream.PeekNextNonWS();
token.Clear();
int result = act();
Assert.Equal(expectedResult, result);
Assert.Equal(expectedKind, token.Kind);
Assert.Equal(expectedLength, token.Length);
Assert.True(expectedValue.IsEqualTo(token.Value));
Assert.Equal(expectedSymbol, token.Symbol);
}
public void ExprParser_Parse_HandlesDivExpression()
{
string expr = "4/3";
InputTextStream inStream = new InputTextStream(expr);
ExprParser parser = new ExprParser();
ExprOp result = parser.Parse(inStream);
Assert.IsNotNull(result);
Assert.AreEqual(OpKindEnum.O_DIV, result.Kind);
Assert.AreEqual(4, result.Left.AsValue.AsLong);
Assert.AreEqual(3, result.Right.AsValue.AsLong);
}
public void ExprParser_Parse_HandlesMultExpression()
{
string expr = "2*3";
InputTextStream inStream = new InputTextStream(expr);
ExprParser parser = new ExprParser();
ExprOp result = parser.Parse(inStream);
Assert.NotNull(result);
Assert.Equal(OpKindEnum.O_MUL, result.Kind);
Assert.Equal(2, result.Left.AsValue.AsLong);
Assert.Equal(3, result.Right.AsValue.AsLong);
}
public void ExprParser_Parse_HandlesSubtractExpression()
{
string expr = "4 - 3"; // #fix-expr-parser - note that '4-3' does not work (parse_quantity issue)
InputTextStream inStream = new InputTextStream(expr);
ExprParser parser = new ExprParser();
ExprOp result = parser.Parse(inStream);
Assert.IsNotNull(result);
Assert.AreEqual(OpKindEnum.O_SUB, result.Kind);
Assert.AreEqual(4, result.Left.AsValue.AsLong);
Assert.AreEqual(3, result.Right.AsValue.AsLong);
}
public ExprToken NextToken(InputTextStream inStream, AmountParseFlagsEnum tFlags, ExprTokenKind?expecting = null)
{
if (UseLookahead)
{
UseLookahead = false;
}
else
{
Lookahead.Next(inStream, tFlags);
}
if (expecting.HasValue && Lookahead.Kind != expecting.Value)
{
Lookahead.Expected(expecting.Value);
}
return(Lookahead);
}
public void ExprTokenTests_Next_DetectsTokensInLine()
{
String source = "& && | || ( ) [2015/10/15] 'ASD' \"qwe\" {22} ! != !~ - -> + * ? : /\\\\s/ = =~ == < <= > >= . , ; and my_ident , 23";
InputTextStream inStream = new InputTextStream(source);
ExprToken token = new ExprToken();
Func <int> act = () => { token.Next(inStream, AmountParseFlagsEnum.PARSE_NO_MIGRATE); return(0); };
ReadAndCheckTokenProps(act, ref token, inStream, 0, ExprTokenKind.KW_AND, 1, Value.Empty, "&");
ReadAndCheckTokenProps(act, ref token, inStream, 0, ExprTokenKind.KW_AND, 2, Value.Empty, "&");
ReadAndCheckTokenProps(act, ref token, inStream, 0, ExprTokenKind.KW_OR, 1, Value.Empty, "|");
ReadAndCheckTokenProps(act, ref token, inStream, 0, ExprTokenKind.KW_OR, 2, Value.Empty, "|");
ReadAndCheckTokenProps(act, ref token, inStream, 0, ExprTokenKind.LPAREN, 1, Value.Empty, "(");
ReadAndCheckTokenProps(act, ref token, inStream, 0, ExprTokenKind.RPAREN, 1, Value.Empty, ")");
ReadAndCheckTokenProps(act, ref token, inStream, 0, ExprTokenKind.VALUE, 12, Value.Get(new Date(2015, 10, 15)), "[");
ReadAndCheckTokenProps(act, ref token, inStream, 0, ExprTokenKind.VALUE, 5, Value.Get("ASD"), "'");
ReadAndCheckTokenProps(act, ref token, inStream, 0, ExprTokenKind.VALUE, 5, Value.Get("qwe"), "\"");
ReadAndCheckTokenProps(act, ref token, inStream, 0, ExprTokenKind.VALUE, 2, Value.Get(new Amount(22)), "{");
ReadAndCheckTokenProps(act, ref token, inStream, 0, ExprTokenKind.EXCLAM, 1, Value.Empty, "!");
ReadAndCheckTokenProps(act, ref token, inStream, 0, ExprTokenKind.NEQUAL, 2, Value.Empty, "!=");
ReadAndCheckTokenProps(act, ref token, inStream, 0, ExprTokenKind.NMATCH, 2, Value.Empty, "!~");
ReadAndCheckTokenProps(act, ref token, inStream, 0, ExprTokenKind.MINUS, 1, Value.Empty, "-");
ReadAndCheckTokenProps(act, ref token, inStream, 0, ExprTokenKind.ARROW, 2, Value.Empty, "->");
ReadAndCheckTokenProps(act, ref token, inStream, 0, ExprTokenKind.PLUS, 1, Value.Empty, "+");
ReadAndCheckTokenProps(act, ref token, inStream, 0, ExprTokenKind.STAR, 1, Value.Empty, "*");
ReadAndCheckTokenProps(act, ref token, inStream, 0, ExprTokenKind.QUERY, 1, Value.Empty, "?");
ReadAndCheckTokenProps(act, ref token, inStream, 0, ExprTokenKind.COLON, 1, Value.Empty, ":");
ReadAndCheckTokenProps(act, ref token, inStream, 0, ExprTokenKind.VALUE, 5, Value.Get(new Mask("\\s")), "/");
ReadAndCheckTokenProps(act, ref token, inStream, 0, ExprTokenKind.ASSIGN, 1, Value.Empty, "=");
ReadAndCheckTokenProps(act, ref token, inStream, 0, ExprTokenKind.MATCH, 2, Value.Empty, "=~");
ReadAndCheckTokenProps(act, ref token, inStream, 0, ExprTokenKind.EQUAL, 2, Value.Empty, "==");
ReadAndCheckTokenProps(act, ref token, inStream, 0, ExprTokenKind.LESS, 1, Value.Empty, "<");
ReadAndCheckTokenProps(act, ref token, inStream, 0, ExprTokenKind.LESSEQ, 2, Value.Empty, "<=");
ReadAndCheckTokenProps(act, ref token, inStream, 0, ExprTokenKind.GREATER, 1, Value.Empty, ">");
ReadAndCheckTokenProps(act, ref token, inStream, 0, ExprTokenKind.GREATEREQ, 2, Value.Empty, ">=");
ReadAndCheckTokenProps(act, ref token, inStream, 0, ExprTokenKind.DOT, 1, Value.Empty, ".");
ReadAndCheckTokenProps(act, ref token, inStream, 0, ExprTokenKind.COMMA, 1, Value.Empty, ",");
ReadAndCheckTokenProps(act, ref token, inStream, 0, ExprTokenKind.SEMI, 1, Value.Empty, ";");
ReadAndCheckTokenProps(act, ref token, inStream, 0, ExprTokenKind.KW_AND, 3, Value.Empty, "&");
ReadAndCheckTokenProps(act, ref token, inStream, 0, ExprTokenKind.IDENT, 8, Value.Get("my_ident"), "m");
ReadAndCheckTokenProps(act, ref token, inStream, 0, ExprTokenKind.COMMA, 1, Value.Empty, ","); // divider
ReadAndCheckTokenProps(act, ref token, inStream, 0, ExprTokenKind.VALUE, 2, Value.Get(new Amount("23")), "2");
}
public void ExprTokenTests_ParseReservedWord_DetectsReservedWords()
{
String source = "and div else false if or not true anything";
InputTextStream inStream = new InputTextStream(source);
ExprToken token = new ExprToken();
Func <int> act = () => token.ParseReservedWord(inStream);
ReadAndCheckTokenProps(act, ref token, inStream, 1, ExprTokenKind.KW_AND, 3, Value.Empty, "&");
ReadAndCheckTokenProps(act, ref token, inStream, 1, ExprTokenKind.KW_DIV, 3, Value.Empty, "/");
ReadAndCheckTokenProps(act, ref token, inStream, 1, ExprTokenKind.KW_ELSE, 4, Value.Empty, "else");
ReadAndCheckTokenProps(act, ref token, inStream, 1, ExprTokenKind.VALUE, 5, Value.False, "false");
ReadAndCheckTokenProps(act, ref token, inStream, 1, ExprTokenKind.KW_IF, 2, Value.Empty, "if");
ReadAndCheckTokenProps(act, ref token, inStream, 1, ExprTokenKind.KW_OR, 2, Value.Empty, "|");
ReadAndCheckTokenProps(act, ref token, inStream, 1, ExprTokenKind.EXCLAM, 3, Value.Empty, "!");
ReadAndCheckTokenProps(act, ref token, inStream, 1, ExprTokenKind.VALUE, 4, Value.True, "true");
ReadAndCheckTokenProps(act, ref token, inStream, 0, ExprTokenKind.UNKNOWN, 8, Value.Empty, String.Empty);
ReadAndCheckTokenProps(act, ref token, inStream, -1, ExprTokenKind.UNKNOWN, 0, Value.Empty, String.Empty);
}
public void ExprParser_Parse_HandlesAddExpression()
{
string expr = "2+3";
InputTextStream inStream = new InputTextStream(expr);
ExprParser parser = new ExprParser();
ExprOp result = parser.Parse(inStream);
Assert.IsNotNull(result);
Assert.AreEqual(OpKindEnum.O_ADD, result.Kind);
Assert.AreEqual(2, result.Left.AsValue.AsLong);
Assert.AreEqual(3, result.Right.AsValue.AsLong);
// Just in case...
EmptyScope scope = new EmptyScope();
Value val = result.Calc(scope);
Assert.AreEqual(5, val.AsLong);
}
public ExprOp ParseCommaExpr(InputTextStream inStream, AmountParseFlagsEnum tFlags)
{
ExprOp node = ParseQuerycolonExpr(inStream, tFlags);
if (node != null && !tFlags.HasFlag(AmountParseFlagsEnum.PARSE_SINGLE))
{
ExprOp next = null;
while (true)
{
ExprToken tok = NextToken(inStream, tFlags | AmountParseFlagsEnum.PARSE_OP_CONTEXT);
if (tok.Kind == ExprTokenKind.COMMA)
{
if (next == null)
{
ExprOp prev = node;
node = new ExprOp(OpKindEnum.O_CONS);
node.Left = prev;
next = node;
}
ExprToken ntok = NextToken(inStream, tFlags);
PushToken(ntok);
if (ntok.Kind == ExprTokenKind.RPAREN)
{
break;
}
ExprOp chain = new ExprOp(OpKindEnum.O_CONS);
chain.Left = ParseQuerycolonExpr(inStream, tFlags);
next.Right = chain;
next = chain;
}
else
{
PushToken(tok);
break;
}
}
}
return(node);
}
public void ExprParser_Parse_HandlesExpressionsWithParenthesises()
{
string expr = "2+(3*(4 - 1)/5)";
InputTextStream inStream = new InputTextStream(expr);
ExprParser parser = new ExprParser();
ExprOp result = parser.Parse(inStream);
Assert.IsNotNull(result);
Assert.AreEqual(OpKindEnum.O_ADD, result.Kind);
Assert.AreEqual(2, result.Left.AsValue.AsLong);
Assert.AreEqual(OpKindEnum.O_DIV, result.Right.Kind);
Assert.AreEqual(5, result.Right.Right.AsValue.AsLong);
Assert.AreEqual(OpKindEnum.O_MUL, result.Right.Left.Kind);
Assert.AreEqual(3, result.Right.Left.Left.AsValue.AsLong);
Assert.AreEqual(OpKindEnum.O_SUB, result.Right.Left.Right.Kind);
Assert.AreEqual(4, result.Right.Left.Right.Left.AsValue.AsLong);
Assert.AreEqual(1, result.Right.Left.Right.Right.AsValue.AsLong);
}
internal static uint InternalDigestState32(State32 state)
{
var p = new InputTextStream(state.mem32);
long bEnd = state.memsize;
uint h32;
if (state.total_len >= 16)
{
h32 = XXH_rotl32(state.v1, 1) + XXH_rotl32(state.v2, 7) + XXH_rotl32(state.v3, 12) +
XXH_rotl32(state.v4, 18);
}
else
{
h32 = state.seed + PRIME32_5;
}
h32 += (uint)state.total_len;
while (p.Position + 4 <= bEnd)
{
h32 += p.ReadUInt32() * PRIME32_3;
h32 = XXH_rotl32(h32, 17) * PRIME32_4;
}
while (p.Position < bEnd)
{
h32 += p.ReadByte() * PRIME32_5;
h32 = XXH_rotl32(h32, 11) * PRIME32_1;
}
h32 ^= h32 >> 15;
h32 *= PRIME32_2;
h32 ^= h32 >> 13;
h32 *= PRIME32_3;
h32 ^= h32 >> 16;
return(h32);
}
public override void Parse(InputTextStream inStream, AmountParseFlagsEnum flags = AmountParseFlagsEnum.PARSE_DEFAULT, string originalString = null)
{
ExprParser parser = new ExprParser();
int startPos = inStream.Pos;
Op = parser.Parse(inStream, flags, originalString);
int endPos = inStream.Pos;
if (!String.IsNullOrEmpty(originalString))
{
Text = originalString;
}
else if (endPos > startPos)
{
inStream.Pos = startPos;
Text = inStream.RemainSource.Substring(0, endPos - startPos);
inStream.Pos = endPos;
}
else
{
Text = "<stream>";
}
}
public ExprOp ParseValueExpr(InputTextStream inStream, AmountParseFlagsEnum tFlags)
{
ExprOp node = ParseAssingExpr(inStream, tFlags);
if (node != null && !tFlags.HasFlag(AmountParseFlagsEnum.PARSE_SINGLE))
{
ExprOp chain = null;
while (true)
{
ExprToken tok = NextToken(inStream, tFlags | AmountParseFlagsEnum.PARSE_OP_CONTEXT);
if (tok.Kind == ExprTokenKind.SEMI)
{
ExprOp seq = new ExprOp(OpKindEnum.O_SEQ);
if (chain == null)
{
seq.Left = node;
node = seq;
}
else
{
seq.Left = chain.Right;
chain.Right = seq;
}
seq.Right = ParseAssingExpr(inStream, tFlags);
chain = seq;
}
else
{
PushToken(tok);
break;
}
}
}
return(node);
}
public int ParseReservedWord(InputTextStream inStream)
{
char c = inStream.Peek;
if (Array.IndexOf(ReservedWordLetters, c) >= 0)
{
string buf;
Length = inStream.ReadInto(out buf, out c, ch => char.IsLetter(ch));
if (buf == "and")
{
Symbol = "&";
Kind = ExprTokenKind.KW_AND;
return(1);
}
if (buf == "div")
{
Symbol = "/";
Kind = ExprTokenKind.KW_DIV;
return(1);
}
if (buf == "else")
{
Symbol = "else";
Kind = ExprTokenKind.KW_ELSE;
return(1);
}
if (buf == "false")
{
Symbol = "false";
Kind = ExprTokenKind.VALUE;
Value = Value.False;
return(1);
}
if (buf == "if")
{
Symbol = "if";
Kind = ExprTokenKind.KW_IF;
return(1);
}
if (buf == "or")
{
Symbol = "|";
Kind = ExprTokenKind.KW_OR;
return(1);
}
if (buf == "not")
{
Symbol = "!";
Kind = ExprTokenKind.EXCLAM;
return(1);
}
if (buf == "true")
{
Symbol = "true";
Kind = ExprTokenKind.VALUE;
Value = Value.True;
return(1);
}
return(0);
}
return(-1);
}
public void Rewind(InputTextStream inStream)
{
inStream.Pos = inStream.Pos - Length;
}
