private bool PullOctet(TokenizeResult tokens)
{
PushIndex();
StringBuilder sb = new StringBuilder();
sb.Append(PeekAndTake());
while (Peek.IsOctet())
{
sb.Append(PeekAndTake());
}
try
{
Convert.ToInt64(sb.ToString(), 8);
}
catch
{
ResetIndex();
return(false);
}
PopIndex();
tokens.Add(Token.LiteralValue(sb.ToString(), LiteralTokenType.Octet, this));
return(true);
}
private bool IsUnquoted()
{
return(!EndOfFile &&
!Peek.IsJsonPlusWhitespace() &&
!IsStartOfComment() &&
!Peek.IsNotInUnquoted());
}
private bool PullHexadecimal(TokenizeResult tokens)
{
if (!Matches("0x", "0X", "&h", "&H"))
{
return(false);
}
PushIndex();
StringBuilder sb = new StringBuilder();
Take(2);
sb.Append("0x");
while (Peek.IsHexadecimal())
{
sb.Append(PeekAndTake());
}
try
{
Convert.ToInt64(sb.ToString(), 16);
}
catch
{
ResetIndex();
return(false);
}
PopIndex();
tokens.Add(Token.LiteralValue(sb.ToString(), LiteralTokenType.Hexadecimal, this));
return(true);
}
public UnknownExpression(AstNode parent) : base(parent)
{
MarkStart();
while (!Peek.Is(TokenType.Newline, TokenType.End))
{
GetNext();
}
MarkEnd();
}
public void doOperationTest()
{
Stack <decimal> stack = new Stack <decimal>();
stack.Push(10);
Peek peek = new Peek();
Assert.AreEqual(10, peek.doOperation(stack));
}
private static MainWindow FindWindow(Peek sender)
{
Window window = Window.GetWindow(sender);
if (window is MainWindow)
{
return(window as MainWindow);
}
else
{
return(window.Owner as MainWindow);
}
}
private bool PullNonNewLineWhitespace(TokenizeResult tokens)
{
if (!Peek.IsJsonPlusWhitespaceExceptNewLine())
{
return(false);
}
StringBuilder sb = new StringBuilder();
while (Peek.IsJsonPlusWhitespaceExceptNewLine())
{
sb.Append(PeekAndTake());
}
tokens.Add(Token.LiteralValue(sb.ToString(), LiteralTokenType.Whitespace, this));
return(true);
}
private void Receive()
{
_ReceiveSync.WaitOne();
if (IsDisposing || IsDisposed)
{
return;
}
try
{
var buffer = Peek.Acquire();
var length = buffer.Length;
while (length > 0 && _Client != null)
{
length -= _Client.Receive(buffer, buffer.Length - length, length, SocketFlags.None);
if (!_Client.Connected || length <= 0)
{
break;
}
Thread.Sleep(10);
}
if (length > 0)
{
if (_DisplayRecvOutput)
{
ToConsole("Recv: Peek Failed at {0}/{1} bytes", buffer.Length - length, buffer.Length);
}
Peek.Free(buffer);
Dispose();
return;
}
var pid = BitConverter.ToUInt16(buffer, 0);
var sid = BitConverter.ToUInt16(buffer, 2);
if (!_ServerID.HasValue)
{
if (Portal.Transport is PortalServer)
{
_ServerID = ((PortalServer)Portal.Transport).Intern(sid);
}
else
{
_ServerID = sid;
}
if (_DisplayRecvOutput)
{
ToConsole("Recv: Server ID Assigned ({0})", _ServerID);
}
}
else if (Portal.IsServer && _ServerID != sid)
{
if (_DisplayRecvOutput)
{
ToConsole("Recv: Potential ServerID spoof: {0}", sid);
}
Dispose();
return;
}
var size = BitConverter.ToInt32(buffer, 4);
if (size < PortalPacket.MinSize || size > PortalPacket.MaxSize)
{
if (_DisplayRecvOutput)
{
ToConsole(
"Recv: Size Out Of Range for {0} at {1}/{2}-{3} bytes",
pid,
size,
PortalPacket.MinSize,
PortalPacket.MaxSize);
}
Peek.Free(buffer);
Dispose();
return;
}
length = size - buffer.Length;
if (length > 0 && buffer.Length != size)
{
Peek.Exchange(ref buffer, new byte[size]);
}
while (length > 0 && _Client != null)
{
length -= _Client.Receive(buffer, size - length, length, SocketFlags.None);
if (!_Client.Connected || length <= 0)
{
break;
}
Thread.Sleep(10);
}
if (length > 0)
{
if (_DisplayRecvOutput)
{
ToConsole("Recv: Failed for {0} at {1}/{2} bytes", pid, size - length, size);
}
Dispose();
return;
}
QueueReceive(buffer);
}
catch (Exception e)
{
ToConsole("Recv: Exception Thrown", e);
Dispose();
return;
}
_ReceiveSync.Set();
}
private bool PullNumbers(TokenizeResult tokens)
{
StringBuilder sb = new StringBuilder();
// Parse numbers
bool parsing = true;
Token lastValidToken = null;
// coefficient, significand, exponent
string state = "coefficient";
while (parsing)
{
switch (state)
{
case "coefficient":
// possible double number without coefficient
if (Matches("-.", "+.", "."))
{
state = "significand";
break;
}
PushIndex(); // long test index
if (Matches('+', '-'))
{
sb.Append(PeekAndTake());
}
// numbers could not start with a 0
if (!Peek.IsDigit() || Peek == '0')
{
ResetIndex(); // reset long test index
parsing = false;
break;
}
while (Peek.IsDigit())
{
sb.Append(PeekAndTake());
}
if (!long.TryParse(sb.ToString(), out _))
{
ResetIndex(); // reset long test index
parsing = false;
break;
}
PopIndex(); // end long test index
lastValidToken = Token.LiteralValue(sb.ToString(), LiteralTokenType.Integer, this);
state = "significand";
break;
case "significand":
// short logic, no significand, but probably have an exponent
if (!Matches("-.", "+.", "."))
{
state = "exponent";
break;
}
PushIndex(); // validate significand in number test
if (Matches('+', '-'))
{
sb.Insert(0, PeekAndTake());
}
sb.Append(PeekAndTake());
if (!Peek.IsDigit())
{
ResetIndex(); // reset validate significand in number test
parsing = false;
break;
}
while (Peek.IsDigit())
{
sb.Append(PeekAndTake());
}
if (!double.TryParse(sb.ToString(), out _))
{
ResetIndex(); // reset validate significand in number test
parsing = false;
break;
}
PopIndex(); // end validate significand in number test
lastValidToken = Token.LiteralValue(sb.ToString(), LiteralTokenType.Decimal, this);
state = "exponent";
break;
case "exponent":
// short logic, check if number is a double with exponent
if (!Matches('e', 'E'))
{
parsing = false;
break;
}
PushIndex(); // validate exponent
sb.Append(PeekAndTake());
// check for signed exponent
if (Matches('-', '+'))
{
sb.Append(PeekAndTake());
}
if (!Peek.IsDigit())
{
ResetIndex(); // reset validate exponent
parsing = false;
break;
}
while (Peek.IsDigit())
{
sb.Append(PeekAndTake());
}
if (!double.TryParse(sb.ToString(), out _))
{
ResetIndex(); // reset validate exponent
parsing = false;
break;
}
PopIndex(); // end validate exponent
lastValidToken = Token.LiteralValue(sb.ToString(), LiteralTokenType.Decimal, this);
parsing = false;
break;
}
}
if (lastValidToken == null)
{
return(false);
}
tokens.Add(lastValidToken);
return(true);
}
internal BraceCollectionExpression(
AstNode parent,
BraceCollectionType type = BraceCollectionType.Unknown
) : base(parent)
{
Expressions = new NodeList <Expression>(this);
Type = type;
MarkStartAndEat(OpenBrace);
if (!Peek.Is(CloseBrace))
{
var comprehension = false;
while (true)
{
Expression item = ParseInfixExpr(this);
if (comprehension)
{
Unit.Blame(
BlameType.CollectionInitializerCannotContainItemsAfterComprehension,
item
);
}
// map item (expr ':' expr)
if (MaybeEat(Colon))
{
if (Type == BraceCollectionType.Set)
{
Unit.ReportError("Single expression expected", Token);
}
Type = BraceCollectionType.Map;
item = new MapItemExpression(
this,
item,
ParseInfixExpr(this)
);
}
// set item (expr)
else
{
if (Type == BraceCollectionType.Map)
{
Unit.ReportError("'Key : Value' expression expected", Token);
}
Type = BraceCollectionType.Set;
}
if (Peek.Is(KeywordFor))
{
item = new ForComprehension(this, item);
comprehension = true;
}
Expressions.Add(item);
if (Peek.Is(CloseBrace))
{
break;
}
Eat(Comma);
}
}
MarkEndAndEat(CloseBrace);
if (Expressions.Count == 0)
{
Unit.Blame(BlameType.EmptyCollectionLiteralNotSupported, this);
}
}
private bool Receive(bool wait)
{
try
{
if ((!wait && _NoReceive) || !IsAlive)
{
return(false);
}
if (wait)
{
var timer = new Stopwatch();
var timeout = _Client.ReceiveTimeout;
timer.Start();
while (Pending < Peek.Size)
{
if (!IsAlive || (Portal.Ticks % 1000 == 0 && !IsConnected))
{
timer.Stop();
return(false);
}
if (Pending < 0 || Pending >= Peek.Size)
{
timer.Reset();
break;
}
if (timeout > 0 && timer.ElapsedMilliseconds >= timeout)
{
timer.Stop();
break;
}
Thread.Sleep(1);
}
}
if ((!wait && _NoReceive) || !IsAlive || Pending < Peek.Size)
{
return(false);
}
var peek = Peek.Acquire();
var head = 0;
while (head < peek.Length && _Client != null)
{
head += _Client.Receive(peek, head, peek.Length - head, SocketFlags.None);
if (_Client == null || !_Client.Connected || head >= peek.Length)
{
break;
}
}
if (head < peek.Length)
{
if (_DisplayRecvOutput)
{
ToConsole("Recv: Peek Failed at {0} / {1} bytes", head, peek.Length);
}
Peek.Free(ref peek);
Dispose();
return(false);
}
var pid = BitConverter.ToUInt16(peek, 0);
if (GetHandler(pid) == null)
{
if (_DisplayRecvOutput)
{
ToConsole("Recv: Unknown Packet ({0})", pid);
}
Peek.Free(ref peek);
Dispose();
return(false);
}
var sid = BitConverter.ToUInt16(peek, 2);
if (IsRemoteClient)
{
if (!_IsSeeded || !_ServerID.HasValue)
{
_ServerID = sid;
_IsSeeded = true;
}
else if (_ServerID != sid)
{
if (_DisplayRecvOutput)
{
ToConsole("Recv: Server ID Spoofed ({0})", sid);
}
Peek.Free(ref peek);
Dispose();
return(false);
}
}
else if (IsLocalClient)
{
if (!_IsSeeded)
{
_IsSeeded = true;
}
if (!_ServerID.HasValue)
{
_ServerID = sid;
}
}
var size = BitConverter.ToInt32(peek, 4);
if (size < PortalPacket.MinSize || size > PortalPacket.MaxSize)
{
if (_DisplayRecvOutput)
{
ToConsole(
"Recv: Size Out Of Range for {0} at {1} / {2} - {3} bytes",
pid,
size,
PortalPacket.MinSize,
PortalPacket.MaxSize);
}
Peek.Free(ref peek);
Dispose();
return(false);
}
var buffer = new PortalBuffer(size);
for (var i = 0; i < peek.Length; i++)
{
buffer[i] = peek[i];
}
Peek.Free(ref peek);
if (size > head)
{
var length = head + buffer.Receive(_Client, head, size - head);
if (length < size)
{
if (_DisplayRecvOutput)
{
ToConsole("Recv: Failed for {0} at {1} / {2} bytes", pid, length, size);
}
buffer.Dispose();
Dispose();
return(false);
}
}
if (!QueueReceive(buffer))
{
buffer.Dispose();
return(false);
}
return(true);
}
catch (Exception e)
{
ToConsole("Recv: Exception Thrown", e);
Dispose();
return(false);
}
}
public void getNumberOfValuesTest()
{
Peek peek = new Peek();
Assert.AreEqual(1, peek.getNumberOfValues());
}
public void getOperatorTest()
{
Peek peek = new Peek();
Assert.AreEqual("peek", peek.getOperator());
}
public void getNameTest()
{
Peek peek = new Peek();
Assert.AreEqual("Peek", peek.getName());
}
private void Receive()
{
_ReceiveSync.WaitOne();
var buffer = Peek.Acquire();
var size = buffer.Length;
while (size > 0 && _Client != null)
{
size -= _Client.Receive(buffer, buffer.Length - size, size, SocketFlags.Peek);
if (!_Client.Connected)
{
break;
}
Thread.Sleep(10);
}
if (size > 0)
{
ToConsole("Recv: Peek Failed at {0}/{1} bytes", buffer.Length - size, buffer.Length);
Peek.Free(buffer);
Dispose();
return;
}
var pid = buffer[0];
var sid = BitConverter.ToUInt16(buffer, 1);
if (!_ServerID.HasValue)
{
_ServerID = sid;
ToConsole("Recv: Server ID Assigned ({0})", _ServerID);
}
size = BitConverter.ToUInt16(buffer, 3);
if (size < PortalPacket.MinSize || size > PortalPacket.MaxSize)
{
ToConsole(
"Recv: Size Out Of Range for {0} at {1}/{2}-{3} bytes",
pid,
size,
PortalPacket.MinSize,
PortalPacket.MaxSize);
Peek.Free(buffer);
Dispose();
return;
}
Peek.Exchange(ref buffer, new byte[size]);
if (size > 0)
{
while (size > 0 && _Client != null)
{
size -= _Client.Receive(buffer, buffer.Length - size, size, SocketFlags.None);
if (!_Client.Connected)
{
break;
}
Thread.Sleep(10);
}
if (size > 0)
{
ToConsole("Recv: Failed for {0} at {1}/{2} bytes", pid, buffer.Length - size, buffer.Length);
Dispose();
return;
}
}
_ReceiveSync.Set();
QueueReceive(buffer);
}
internal bool PeekKind(SqlKind kind)
{
SqlKind?k = Peek.FirstOrDefault()?.Kind;
return(kind == k);
}
internal bool PeekKind(params SqlKind[] kinds)
{
SqlKind?k = Peek.FirstOrDefault()?.Kind;
return(kinds.Any(x => x == k));
}
//ls|grep F>test
public void MoveNext()
{
currentText = string.Empty;
isInsideQuotes = (char)0;
switch (currentType)
{
case TokenType.Pipeline:
case TokenType.RedirectOutputSet:
case TokenType.RedirectOutputAppend:
case TokenType.RedirectInput:
case TokenType.Start:
currentType = TokenType.ProgramName;
while (Can && !Peek.IsWhiteSpace() && !IsSpecialMeaningChar(Peek))
{
currentText += Eat();
}
break;
case TokenType.ProgramName:
default:
if (IsSpecialMeaningChar(Peek))
{
if (Peek == '|')
{
currentType = TokenType.Pipeline;
currentText += Eat();
}
if (Peek == '>')
{
currentType = TokenType.RedirectOutputSet;
currentText += Eat();
if (Peek == '>')
{
currentType = TokenType.RedirectOutputAppend;
currentText += Eat();
}
}
if (Peek == '<')
{
currentType = TokenType.RedirectInput;
currentText += Eat();
}
break;
}
currentType = TokenType.Argument;
while (Can)
{
if (isInsideQuotes == (char)0) // is not inside quotes
{
if (Peek == '"' || Peek == '\'')
{
// starting quote
isInsideQuotes = Eat();
continue;
}
if (argumentsDoSplitByWhiteChar && Peek.IsWhiteSpace())
{
break;
}
if (IsSpecialMeaningChar(Peek))
{
break;
}
currentText += Eat();
}
else // is inside quotes
{
if (isInsideQuotes == Peek)
{
Eat();
isInsideQuotes = (char)0;
break; // end quote, end argument
}
currentText += Eat();
}
}
break;
}
// skip white chars
while (Can && Peek.IsWhiteSpace())
{
Eat();
}
}
