/// <summary>
/// Initializes a new instance of the <see cref="UnaryExpressionTranslationUnit"/> class.
/// </summary>
/// <param name="nestingLevel"></param>
protected UnaryExpressionTranslationUnit(int nestingLevel)
: base(nestingLevel)
{
this.operand = null;
this.operatorToken = OperatorToken.Undefined;
this.unaryPosition = UnaryPosition.Postfix;
}
/// <summary>
/// Initializes a new instance of the <see cref="BinaryExpressionTranslationUnit"/> class.
/// </summary>
/// <param name="nestingLevel"></param>
protected BinaryExpressionTranslationUnit(int nestingLevel)
: base(nestingLevel)
{
this.leftOperand = null;
this.rightOperand = null;
this.operatorToken = OperatorToken.Undefined;
}
private static void MakeRPN()
{
var opStack = new Stack <Token>();
var newList = new List <Token>();
foreach (var token in _tokenList)
{
if (token is VariableToken || token is LogicValueToken)
{
newList.Add(token);
continue;
}
if (token is OperatorToken)
{
var current = token as OperatorToken;
var currentPriority = current.Priority;
OperatorToken peek = null;
if (opStack.Count > 0)
{
peek = opStack.Peek() as OperatorToken;
}
while (opStack.Count > 0 && peek != null && peek.Priority >= currentPriority)
{
newList.Add(opStack.Pop());
peek = (opStack.Count > 0) ? opStack.Peek() as OperatorToken : null;
}
opStack.Push(token);
continue;
}
if (token is OpenParenthesisToken)
{
opStack.Push(token);
continue;
}
if (token is CloseParenthesisToken)
{
while (opStack.Count > 0 && !(opStack.Peek() is OpenParenthesisToken))
{
newList.Add(opStack.Pop());
}
if (opStack.Count == 0)
{
throw new Exception("RPN: Unpaired parentheses");
}
opStack.Pop();
continue;
}
throw new Exception("RPN: Unsupported token");
}
newList.AddRange(opStack);
_tokenList = newList;
}
private Token?GetNextToken()
{
if (IsEoF || m_current == '\0')
{
return(null);
}
Token?result = null;
char c = m_current;
(int, int)location = (m_line, m_column);
switch (c)
{
case '.':
case ',':
case ':':
case ';':
case '[':
case ']':
case '(':
case ')':
case '{':
case '}':
{
Advance();
result = new DelimiterToken(location, (DelimiterKind)c);
} break;
case '$': throw new NotImplementedException(); // interpolated string literals
case '"':
{
result = ReadString();
} break;
default:
{
if (char.IsDigit(c) || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_')
{
result = ReadNumberOrIdentifierOrKeyword();
}
else if (IsOperatorCharacter(c))
{
var operatorImage = new StringBuilder();
while (!IsEoF && IsOperatorCharacter(m_current))
{
operatorImage.Append(m_current);
Advance();
}
result = new OperatorToken(location, operatorImage.ToString());
}
} break;
}
EatWhiteSpace();
return(result);
}
public OperationExpressionSegment(OperatorToken token)
{
if (token == null)
{
throw new ArgumentNullException("token");
}
Token = token;
}
private static QueryExpression ParseFunction(QueryExpression subQuery, List <Token> tokens, int startToken, int numTokens, FunctionToken functionToken)
{
if (!(tokens[startToken] is VariableToken))
{
throw new CSExpressionException("Function call " + functionToken.Function + " called with incorrect parameters");
}
QueryExpression newQuery = (QueryExpression)EvalVariable(((VariableToken)tokens[startToken]).Variable, subQuery);
string fieldExpression;
switch (functionToken.Function)
{
case "HAS": fieldExpression = "*"; break;
case "COUNT": fieldExpression = "count(*)"; break;
case "COUNTDISTINCT": fieldExpression = "count(distinct " + newQuery.FieldName + ")"; break;
default: fieldExpression = functionToken.Function + "(" + newQuery.FieldName + ")"; break;
}
if (numTokens > 1)
{
if (!(tokens[startToken + 1] is OperatorToken))
{
throw new CSExpressionException("Expected WHERE");
}
OperatorToken whereToken = (OperatorToken)tokens[startToken + 1];
if (whereToken.Operator.ToUpper() != "WHERE")
{
throw new CSExpressionException("Expected WHERE");
}
if (numTokens < 3)
{
throw new CSExpressionException("Expected expression after WHERE");
}
newQuery.Expression += " AND ";
newQuery = Parse(newQuery, tokens, startToken + 2, numTokens - 2);
}
string selectSql = newQuery.Table.Schema.DB.BuildSelectSQL(newQuery.Table.TableName, newQuery.Table.TableAlias, new[] { fieldExpression }, null, newQuery.Joins.BuildJoinExpressions(), newQuery.Expression, null, 1, 0, false, false);
if (functionToken.Function == "HAS")
{
subQuery.Expression += "EXISTS ";
}
subQuery.Expression += "(" + selectSql + ")";
return(subQuery);
}
public BinaryOperatorNode(OperatorToken token, INode leftNode, INode rightNode)
{
Contract.Requires <ArgumentNullException>(token != null);
Contract.Requires <ArgumentNullException>(leftNode != null);
Contract.Requires <ArgumentNullException>(rightNode != null);
this.token = token;
this.leftNode = leftNode;
this.rightNode = rightNode;
}
public static void TestGetNextTokenOnOperator()
{
const string input = "$a=42";
var token = Lexer.GetNextToken(input, 2);
var correctToken = new OperatorToken(Operator.Assign);
Assert.Equal(correctToken, token);
}
void GenerationTest()
{
var refer = OperatorToken.GenerateReference();
var referenceValues = refer.OrderBy(p => p.Key).ToList();
var manualValue = ManualReference.OrderBy(p => p.Key).ToList();
Assert.Equal(referenceValues, manualValue);
}
public override string EvaluateOperator(OperatorToken token)
{
if (token is SignOperatorToken)
{
return(String.Format("{0} {1}",
token.SubTokens[1].Evaluate(this), token.Symbol));
}
return(String.Format("{0} {1} {2}",
token.SubTokens[0].Evaluate(this), token.SubTokens[1].Evaluate(this), token.Symbol));
}
public void Do()
{
(int Line, int Column)loc = m_originalToken.Location;
var firstPart = new OperatorToken(loc, m_imageSplit);
var secondPart = new OperatorToken((loc.Line, loc.Column + m_imageSplit.Length), m_originalToken.Image.Substring(m_imageSplit.Length));
m_tokens.Insert(m_index, firstPart);
m_tokens[m_index + 1] = secondPart;
}
public override int GetHashCode()
{
unchecked
{
int hashCode = (UniqueName != null ? UniqueName.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (OperatorToken != null ? OperatorToken.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ Version.GetHashCode();
return(hashCode);
}
}
private void PushOperator(OperatorToken op)
{
// Here we use openParenthesisToken as sentinel token
while (this.operators.Peek().Precedence > op.NewPushPrecedence)
{
this.PopOperator();
}
this.operators.Push(op);
}
public bool TryTokenize(byte currentByte, IInputBytes inputBytes, out IToken token)
{
token = null;
if (ReadHelper.IsWhitespace(currentByte))
{
return(false);
}
var builder = stringBuilder;
builder.Append((char)currentByte);
while (inputBytes.MoveNext())
{
if (ReadHelper.IsWhitespace(inputBytes.CurrentByte))
{
break;
}
if (inputBytes.CurrentByte == '<' || inputBytes.CurrentByte == '[' ||
inputBytes.CurrentByte == '/' || inputBytes.CurrentByte == ']' ||
inputBytes.CurrentByte == '>' || inputBytes.CurrentByte == '(' ||
inputBytes.CurrentByte == ')')
{
break;
}
builder.Append((char)inputBytes.CurrentByte);
}
var text = builder.ToString();
builder.Clear();
switch (text)
{
case "true":
token = BooleanToken.True;
break;
case "false":
token = BooleanToken.False;
break;
case "null":
token = NullToken.Instance;
break;
default:
token = OperatorToken.Create(text);
break;
}
return(true);
}
void LexerSmokeTestSecond()
{
var sourceCode =
@"fn+let-const*as/while//hello
continue:=if->(else=> _==int){""as\nc\rc\tc""
<=p>1.5E-3!=231231231231</p>
}
";
var expectedTokens = new Token[]
{
new KeywordToken(Keyword.Fn, (0, 0)), new OperatorToken(Operator.Plus, (0, 2)), new KeywordToken(Keyword.Let, (0, 3)),
new OperatorToken(Operator.Minus, (0, 6)), new KeywordToken(Keyword.Const, (0, 7)), new OperatorToken(Operator.Mult, (0, 12)),
new KeywordToken(Keyword.As, (0, 13)), new OperatorToken(Operator.Divide, (0, 15)), new KeywordToken(Keyword.While, (0, 16)),
new KeywordToken(Keyword.Continue, (1, 0)), new OperatorToken(Operator.Colon, (1, 8)), new OperatorToken(Operator.Assign, (1, 9)),
new KeywordToken(Keyword.If, (1, 10)), new OperatorToken(Operator.Arrow, (1, 12)), new OperatorToken(Operator.LeftParen, (1, 14)),
new KeywordToken(Keyword.Else, (1, 15)), new OperatorToken(Operator.Assign, (1, 19)), new OperatorToken(Operator.GreaterThan, (1, 20)),
new IdentifierToken("_", (1, 22)), new OperatorToken(Operator.Equal, (1, 23)), new IdentifierToken("int", (1, 25)),
new OperatorToken(Operator.RightParen, (1, 28)), new OperatorToken(Operator.LeftBrace, (1, 29)),
new StringLiteralToken("as\nc\rc\tc", (1, 30)),
new OperatorToken(Operator.LessEqual, (2, 0)), new IdentifierToken("p", (2, 2)), new OperatorToken(Operator.GreaterThan, (2, 3)),
new DoubleLiteralToken(1.5E-3, (2, 4)), new OperatorToken(Operator.NotEqual, (2, 10)), new UInt64LiteralToken(231231231231, (2, 12)),
new OperatorToken(Operator.LessThan, (2, 24)), new OperatorToken(Operator.Divide, (2, 25)), new IdentifierToken("p", (2, 26)),
new OperatorToken(Operator.GreaterThan, (2, 27)),
new OperatorToken(Operator.RightBrace, (3, 0)),
};
var lexer = new Lexer(sourceCode);
var tokens = lexer.Parse().ToList();
Assert.Equal(expectedTokens.Length, tokens.Count);
for (var i = 0; i < expectedTokens.Length; i++)
{
var expectedToken = expectedTokens[i];
var actualToken = tokens[i];
AssertJsonEqual(expectedToken, actualToken);
}
}
public MemoryImmediate(
OperatorToken leftBracket,
IntegerToken immediateAddress,
OperatorToken rightBracket)
: base(
OperandType.MemoryImmediate,
leftBracket,
immediateAddress,
rightBracket)
{
ImmediateAddress = immediateAddress;
}
public override string EvaluateOperator(OperatorToken token)
{
if (token is SignOperatorToken)
{
return(evalSignOperator(token as SignOperatorToken));
}
int precedence = OperatorProperties.GetPrecedence(token);
string exprLeft = evalOperatorSubToken(precedence, token.SubTokens[0]);
string exprRight = evalOperatorSubToken(precedence, token.SubTokens[1]);
return(exprLeft + token.Symbol + exprRight);
}
public void Visit(OperatorToken operatorToken)
{
CreateOperatorExpression(operatorToken);
if (!mIsNegated && !mWasMultiplication)
{
FillOperation();
}
else
{
mWasMultiplication = false;
mIsNegated = false;
}
}
/// <summary>
///
/// </summary>
/// <param name="body"></param>
/// <param name="operatorToken"></param>
/// <param name="unaryPosition"></param>
/// <returns></returns>
public static UnaryExpressionTranslationUnit Create(ITranslationUnit body, OperatorToken operatorToken, UnaryPosition unaryPosition)
{
if (body == null)
{
throw new ArgumentNullException(nameof(body));
}
return(new UnaryExpressionTranslationUnit(AutomaticNestingLevel)
{
Operand = body,
operatorToken = operatorToken,
unaryPosition = unaryPosition
});
}
public BinaryExper GetFieldResult(Token t, out int number)
{
BinaryExper now_exper = new BinaryExper();
int LP_count = 1;
List <Token> inter_tokens = new List <Token>();
inter_tokens.Add(new OperatorToken(0, inter_tokens.Count, "KEEP"));
inter_tokens.Add(new OperatorToken(0, inter_tokens.Count, "="));
for (int i = 1; i < q.Count - 1; i++)
{
string v = q[t.seq + i].GetValue();
if (v != "}")
{
if (v == "{")
{
LP_count++;
}
Token nt = q[t.seq + i];
nt.seq = inter_tokens.Count;
inter_tokens.Add(nt);
}
else
{
LP_count--;
Token nt = q[t.seq + i];
nt.seq = inter_tokens.Count;
if (LP_count == 0)
{
break;
}
else
{
inter_tokens.Add(nt);
}
}
}
Token nt2 = new OperatorToken(0, inter_tokens.Count, ";"); nt2.seq = inter_tokens.Count; inter_tokens.Add(nt2);
// BinaryExper vvv = new BinaryExper(GetValueFromTokens(inter_tokens));
// vvv.Calculate();
Parser p = new Parser(inter_tokens); p.Start();
BinaryExper vvv = new BinaryExper();
number = inter_tokens.Count - 3;
now_exper = vvv;
return(now_exper);
}
/*
* unary_operator : '&' | '*' | '+' | '-' | '~' | '!'
*/
private IParseResult ParseUnaryOperator()
{
OperatorToken token = null;
if (Accept(new []
{
OperatorType.BITAND, OperatorType.MULT, OperatorType.ADD,
OperatorType.SUB, OperatorType.TILDE, OperatorType.NOT
}, ref token))
{
return(new SuccessParseResult(new UnaryOperator(token)));
}
return(new SuccessParseResult(new NullStat()));
}
private static void HandleOperator(OperatorToken token, ISeekableTokenScanner scanner, PreviousTokenSet set, List <DictionaryToken> dictionaries)
{
switch (token.Data)
{
case "dict":
var number = ((NumericToken)set[0]).Int;
var dictionary = ReadDictionary(number, scanner);
dictionaries.Add(dictionary);
break;
default:
return;
}
}
public BinaryExper GetResultFromBrackets(Token t, out int number)
{
BinaryExper now_exper = new BinaryExper();
int LP_count = 1;
List <Token> inter_tokens = new List <Token>();
inter_tokens.Add(new OperatorToken(0, inter_tokens.Count, "KEEP"));
inter_tokens.Add(new OperatorToken(0, inter_tokens.Count, "="));
for (int i = 1; i < q.Count - 1; i++)
{
string v = q[t.seq + i].GetValue();
if (v != ")")
{
if (v == "(")
{
LP_count++;
}
Token nt = q[t.seq + i];
nt.seq = inter_tokens.Count;
inter_tokens.Add(nt);
}
else
{
LP_count--;
Token nt = q[t.seq + i];
nt.seq = inter_tokens.Count;
if (LP_count == 0)
{
break;
}
else
{
inter_tokens.Add(nt);
}
}
}
Token nt2 = new OperatorToken(0, inter_tokens.Count, ";"); nt2.seq = inter_tokens.Count; inter_tokens.Add(nt2);
BinaryExper vvv = new BinaryExper(GetValueFromTokens(inter_tokens));
vvv.Calculate();
number = inter_tokens.Count - 3;
return(vvv);
}
/// <summary>
/// Performs the evaluation of the specified operator token
/// </summary>
private static NumericToken Evaluate(OperatorToken token, Stack <Token> operands)
{
try
{
var arguments = new NumericToken[token.Value.Operands];
for (var i = 0; i < token.Value.Operands; i++)
{
arguments[i] = (NumericToken)operands.Pop();
}
return(token.Value.Evaluate(arguments));
}
catch (InvalidOperationException e) when(!operands.Any())
{
throw new EvaluationException(
$"Insufficient operands for operator '{token.Value}' @ char: {token.Index}", e);
}
}
/// <summary>
///
/// </summary>
/// <param name="lhand"></param>
/// <param name="rhand"></param>
/// <param name="operatorToken"></param>
/// <returns></returns>
public static BinaryExpressionTranslationUnit Create(ITranslationUnit lhand, ITranslationUnit rhand, OperatorToken operatorToken)
{
if (rhand == null)
{
throw new ArgumentNullException(nameof(rhand));
}
if (lhand == null)
{
throw new ArgumentNullException(nameof(lhand));
}
return new BinaryExpressionTranslationUnit(AutomaticNestingLevel)
{
LeftOperand = lhand,
RightOperand = rhand,
operatorToken = operatorToken
};
}
private int Operator()
{
char ch = data[chBaseIndex];
if (OperatorToken.Map.ContainsKey(ch))
{
OperatorToken op = new OperatorToken();
op.m_Operator = OperatorToken.Map[ch];
int chNewBaseIndex = chBaseIndex + 1;
AttachDebugData(op, DebugRanges, chBaseIndex, chNewBaseIndex - 1);
Tokens.Add(op);
chBaseIndex = chNewBaseIndex;
}
return(chBaseIndex);
}
/// <summary>
/// Parses a set of brackets containing arguments.
/// </summary>
/// <param name="scope">The scope for this token.</param>
/// <param name="openBracketToken">The open bracket token.</param>
/// <param name="sig">(optional) A signature for the function being called.</param>
/// <returns>A new argument token.</returns>
/// <remarks>This function assumes the opening bracket has already been read from the stream.</remarks>
public static ArgsToken Parse(Scope scope, OperatorToken openBracketToken, FunctionSignature sig)
{
var code = scope.Code;
var ret = new ArgsToken(scope, openBracketToken);
var argIndex = 0;
scope = scope.Clone();
scope.Hint |= ScopeHint.SuppressStatementStarts;
ret._sig = sig;
var args = sig != null?sig.Arguments.ToArray() : ArgumentDescriptor.EmptyArray;
while (code.SkipWhiteSpace())
{
code.Peek();
if (code.Text == ")")
{
ret.AddToken(new OperatorToken(scope, code.MovePeekedSpan(), ")"));
ret._terminated = true;
return(ret);
}
if (code.Text == ",")
{
ret.AddToken(new OperatorToken(scope, code.MovePeekedSpan(), ","));
argIndex++;
continue;
}
var dataType = argIndex < args.Length ? args[argIndex].DataType : null;
var exp = ExpressionToken.TryParse(scope, _endTokens, expectedDataType: dataType);
if (exp != null)
{
ret.AddToken(exp);
}
else
{
break;
}
}
return(ret);
}
public bool Visit(OperatorToken token, out int precendence)
{
switch (token.OperatorType)
{
case OperatorToken.OperatorTypes.Plus:
case OperatorToken.OperatorTypes.Minus:
precendence = 1;
return(true);
case OperatorToken.OperatorTypes.Multiply:
case OperatorToken.OperatorTypes.Divide:
precendence = 2;
return(true);
default:
precendence = 0;
return(false);
}
}
public void Process(char character)
{
if (NumberToken.IsNumber(character))
{
Number(character);
}
else if (OperatorToken.IsOperator(character))
{
Operator(character);
}
else if (Lexer.END_OF_EQUATION == character)
{
EndOfEquation();
}
else
{
throw new UnsupportedCharacterException(character);
}
}
private static ITranslationUnit BuildBinaryExpressionTranslationUnit(BinaryExpressionSyntax expression, SemanticModel semanticModel)
{
OperatorToken token = OperatorToken.Undefined;
switch (expression.Kind())
{
case SyntaxKind.AddExpression:
token = OperatorToken.Addition;
break;
case SyntaxKind.MultiplyExpression:
token = OperatorToken.Multiplication;
break;
case SyntaxKind.DivideExpression:
token = OperatorToken.Divide;
break;
case SyntaxKind.SubtractExpression:
token = OperatorToken.Subtraction;
break;
case SyntaxKind.EqualsExpression:
token = OperatorToken.LogicalEquals;
break;
case SyntaxKind.NotEqualsExpression:
token = OperatorToken.NotEquals;
break;
}
if (token == OperatorToken.Undefined)
{
throw new InvalidOperationException("Binary operator could not be detected!");
}
BinaryExpression binaryExpressionHelper = new BinaryExpression(expression, semanticModel);
ITranslationUnit leftHandOperand = new ExpressionTranslationUnitBuilder(binaryExpressionHelper.LeftHandOperand, semanticModel).Build();
ITranslationUnit rightHandOperand = new ExpressionTranslationUnitBuilder(binaryExpressionHelper.RightHandOperand, semanticModel).Build();
return(BinaryExpressionTranslationUnit.Create(leftHandOperand, rightHandOperand, token));
}
public override string EvaluateOperator(OperatorToken token)
{
if (token is SignOperatorToken)
{
return(evalSignOperator(token as SignOperatorToken));
}
switch (token.Symbol)
{
// Arithmetic operators
case ParserSymbols.Multiply:
return($"{evalSub(token, 0)}<mo>⋅</mo>{evalSub(token, 1)}");
case ParserSymbols.Divide:
return($"<mfrac><mrow>{evalSub(token, 0)}</mrow><mrow>{evalSub(token, 1)}</mrow></mfrac>");
case ParserSymbols.Power:
return($"<msup><mrow>{evalSub(token, 0)}</mrow><mrow>{evalSub(token, 1)}</mrow></msup>");
case ParserSymbols.Modulo:
return($"{evalSub(token, 0)}<mo>mod</mo>{evalSub(token, 1)}");
// Comparison operators
case ParserSymbols.LessEqual:
return($"{evalSub(token, 0)}<mo>≤</mo>{evalSub(token, 1)}");
case ParserSymbols.GreaterEqual:
return($"{evalSub(token, 0)}<mo>≥</mo>{evalSub(token, 1)}");
case ParserSymbols.NotEqual:
return($"{evalSub(token, 0)}<mo>≠</mo>{evalSub(token, 1)}");
// Boolean/ bitwise operators
case ParserSymbols.And:
return($"{evalSub(token, 0)}<mo>∧</mo>{evalSub(token, 1)}");
case ParserSymbols.Or:
return($"{evalSub(token, 0)}<mo>∨</mo>{evalSub(token, 1)}");
default:
return($"{evalSub(token, 0)}<mo>{token.Symbol}</mo>{evalSub(token, 1)}");
}
}
private IParseResult ParseBinaryExp <T>(Parser parser, IEnumerable <OperatorType> availableOperators)
where T : BinaryExp
{
var left = parser();
if (!left.IsSuccess || left.IsNullStat())
{
return(left);
}
OperatorToken op = null;
// ReSharper disable once PossibleMultipleEnumeration
while (Accept(availableOperators, ref op))
{
var right = parser();
if (!right.IsSuccess)
{
return(right);
}
if (right.IsNullStat())
{
return(ExpectedExpressionFailure());
}
var constructor =
typeof(T).GetConstructor(new[] { typeof(OperatorToken), typeof(ExpNode), typeof(ExpNode), typeof(Position) });
if (constructor == null)
{
throw new ArgumentException($"{typeof(T)} not suitable for creating BinaryExp");
}
var leftExpNode = left.ResultNode as ExpNode;
var @object = constructor.Invoke(new object[]
{ op, leftExpNode, right.ResultNode as ExpNode, leftExpNode.StartNodePosition });
left = new SuccessParseResult(@object as Node);
}
return(left);
}
private static void ProcessOperator(Stack <Expression> expressionStack, OperatorToken oper)
{
if (oper is BinaryOperatorToken)
{
if (expressionStack.Count < 2)
{
throw new ExpressionParseException($"Missing argument(s) for {oper.DisplayString} operator");
}
var rightExp = expressionStack.Pop();
var leftExp = expressionStack.Pop();
expressionStack.Push(ExpressionBuilder.Arithmetic(leftExp, ((BinaryOperatorToken)oper).Operator, rightExp));
}
else if (oper is UnaryMinusToken)
{
if (expressionStack.Count() < 1)
{
throw new ExpressionParseException($"Missing argument(s) for {oper.DisplayString} operator");
}
expressionStack.Push(ExpressionBuilder.UnaryMinus(expressionStack.Pop()));
}
}
/// <summary>
///
/// </summary>
/// <param name="operatorToken"></param>
/// <param name="number1"></param>
/// <param name="number2"></param>
/// <returns></returns>
public static ITranslationUnit BuildExpressionTranslationUnit(OperatorToken operatorToken, int number1, int number2)
{
return BinaryExpressionTranslationUnit.Create(
LiteralTranslationUnit<int>.Create(number1), LiteralTranslationUnit<int>.Create(number2), operatorToken);
}
/// <summary>
///
/// </summary>
/// <param name="body"></param>
/// <param name="operatorToken"></param>
/// <param name="unaryPosition"></param>
/// <returns></returns>
public static UnaryExpressionTranslationUnit Create(ITranslationUnit body, OperatorToken operatorToken, UnaryPosition unaryPosition)
{
if (body == null)
{
throw new ArgumentNullException(nameof(body));
}
return new UnaryExpressionTranslationUnit(AutomaticNestingLevel)
{
Operand = body,
operatorToken = operatorToken,
unaryPosition = unaryPosition
};
}
protected BinaryExpression(Expression left, OperatorToken @operator, Expression right)
{
Left = left;
Operator = @operator;
Right = right;
}
public DivBinaryExpression(Expression left, OperatorToken @operator, Expression right)
: base(left, @operator, right)
{
}
private bool IsLowerPrecedence(OperatorToken command)
{
if (functions.Count == 0) return false;
return PriorityLevel(command) < PriorityLevel(functions[0]);
}
public ParenthesisExpression(OperatorToken left, Expression expression, OperatorToken right)
{
Left = left;
Expression = expression;
Right = right;
}
private void PushOperator(OperatorToken token)
{
functions.Add(token);
}
/*
* Method: FindNextToken
*
* Find the next token. Return 'true' if one was found. False, otherwise.
*/
internal override bool FindNextToken()
{
int startPosition = _reader.Position;
// VB docs claim whitespace is Unicode category Zs. However,
// this category does not contain tabs. Assuming a less restrictive
// definition for whitespace...
if (_reader.SinkWhiteSpace())
{
while (_reader.SinkWhiteSpace())
{
}
// Now, we need to check for the line continuation character.
if (_reader.SinkLineContinuationCharacter()) // Line continuation is '_'
{
// Save the current position because we may need to come back here.
int savePosition = _reader.Position - 1;
// Skip all whitespace after the '_'
while (_reader.SinkWhiteSpace())
{
}
// Now, skip all the newlines.
// Need at least one newline for this to count as line continuation.
int count = 0;
while (_reader.SinkNewLine())
{
++count;
}
if (count > 0)
{
current = new VisualBasicTokenizer.LineContinuationToken();
return true;
}
// Otherwise, fall back to plain old whitespace.
_reader.Position = savePosition;
}
current = new WhitespaceToken();
return true;
}
// Line terminators are separate from whitespace and are significant.
else if (_reader.SinkNewLine())
{
// We want one token per line terminator.
current = new VisualBasicTokenizer.LineTerminatorToken();
return true;
}
// Check for a comment--either those that start with ' or rem.
else if (_reader.SinkLineCommentStart())
{
// Skip to the first EOL.
_reader.SinkToEndOfLine();
current = new CommentToken();
return true;
}
// Identifier or keyword?
else if
(
// VB allows escaping of identifiers by surrounding them with []
// In other words,
// Date is a keyword but,
// [Date] is an identifier.
_reader.CurrentCharacter == '[' ||
_reader.MatchNextIdentifierStart()
)
{
bool escapedIdentifier = false;
if (_reader.CurrentCharacter == '[')
{
escapedIdentifier = true;
_reader.SinkCharacter();
// Now, the next character must be an identifier start.
if (!_reader.SinkIdentifierStart())
{
current = new ExpectedIdentifierToken();
return true;
}
}
// Sink the rest of the identifier.
while (_reader.SinkIdentifierPart())
{
}
// If this was an escaped identifier the we need to get the terminating ']'.
if (escapedIdentifier)
{
if (!_reader.Sink("]"))
{
current = new ExpectedIdentifierToken();
return true;
}
}
else
{
// Escaped identifiers are not allowed to have trailing type character.
_reader.SinkTypeCharacter(); // Type character is optional.
}
// An identifier that is only a '_' is illegal because it is
// ambiguous with line continuation
string identifierOrKeyword = _reader.GetCurrentMatchedString(startPosition);
if (identifierOrKeyword == "_" || identifierOrKeyword == "[_]" || identifierOrKeyword == "[]")
{
current = new ExpectedIdentifierToken();
return true;
}
// Make an upper-case version in order to check whether this may be a keyword.
string upper = identifierOrKeyword.ToUpper(CultureInfo.InvariantCulture);
switch (upper)
{
default:
if (Array.IndexOf(s_keywordList, upper) >= 0)
{
current = new KeywordToken();
return true;
}
// Create the token.
current = new IdentifierToken();
// Trim off the [] if this is an escaped identifier.
if (escapedIdentifier)
{
current.InnerText = identifierOrKeyword.Substring(1, identifierOrKeyword.Length - 2);
}
return true;
case "FALSE":
case "TRUE":
current = new BooleanLiteralToken();
return true;
}
}
// Is it a hex integer?
else if (_reader.SinkHexIntegerPrefix())
{
if (!_reader.SinkMultipleHexDigits())
{
current = new ExpectedValidHexDigitToken();
return true;
}
// Sink a suffix if there is one.
_reader.SinkIntegerSuffix();
current = new HexIntegerLiteralToken();
return true;
}
// Is it an octal integer?
else if (_reader.SinkOctalIntegerPrefix())
{
if (!_reader.SinkMultipleOctalDigits())
{
current = new VisualBasicTokenizer.ExpectedValidOctalDigitToken();
return true;
}
// Sink a suffix if there is one.
_reader.SinkIntegerSuffix();
current = new VisualBasicTokenizer.OctalIntegerLiteralToken();
return true;
}
// Is it a decimal integer?
else if (_reader.SinkMultipleDecimalDigits())
{
// Sink a suffix if there is one.
_reader.SinkDecimalIntegerSuffix();
current = new DecimalIntegerLiteralToken();
return true;
}
// Preprocessor line
else if (_reader.CurrentCharacter == '#')
{
if (_reader.SinkIgnoreCase("#if"))
{
current = new OpenConditionalDirectiveToken();
}
else if (_reader.SinkIgnoreCase("#end if"))
{
current = new CloseConditionalDirectiveToken();
}
else
{
current = new PreprocessorToken();
}
_reader.SinkToEndOfLine();
return true;
}
// Is it a separator?
else if (_reader.SinkSeparatorCharacter())
{
current = new VisualBasicTokenizer.SeparatorToken();
return true;
}
// Is it an operator?
else if (_reader.SinkOperator())
{
current = new OperatorToken();
return true;
}
// A string?
else if (_reader.Sink("\""))
{
do
{
// Inside a verbatim string "" is treated as a special character
while (_reader.Sink("\"\""))
{
}
}
while (!_reader.EndOfLines && _reader.SinkCharacter() != '\"');
// Can't end a file inside a string
if (_reader.EndOfLines)
{
current = new EndOfFileInsideStringToken();
return true;
}
current = new StringLiteralToken();
return true;
}
// We didn't recognize the token, so this is a syntax error.
_reader.SinkCharacter();
current = new UnrecognizedToken();
return true;
}
/// <summary>
///
/// </summary>
/// <param name="operatorToken"></param>
/// <param name="number"></param>
/// <param name="postfix"></param>
/// <returns></returns>
public static ITranslationUnit BuildExpressionTranslationUnit(OperatorToken operatorToken, int number, bool postfix = true)
{
return UnaryExpressionTranslationUnit.Create(
LiteralTranslationUnit<int>.Create(number), operatorToken,
postfix ? UnaryExpressionTranslationUnit.UnaryPosition.Postfix : UnaryExpressionTranslationUnit.UnaryPosition.Prefix);
}
private int PriorityLevel(OperatorToken command)
{
switch (command) {
case OperatorToken.OpenParen:
return 1;
case OperatorToken.LogicalAnd:
case OperatorToken.LogicalOr:
case OperatorToken.LogicalNot:
return 2;
case OperatorToken.LogicalEqual:
case OperatorToken.LogicalNotEqual:
case OperatorToken.GreaterThan:
case OperatorToken.LessThan:
case OperatorToken.GreaterThanOrEqual:
case OperatorToken.LessThanOrEqual:
return 3;
case OperatorToken.Plus:
case OperatorToken.Minus:
return 4;
case OperatorToken.Multiply:
case OperatorToken.Divide:
case OperatorToken.Modulus:
return 5;
case OperatorToken.CloseParen:
return 6;
default:
return 0;
}
}
private static Token[] GetInfixTokens(string term)
{
//Leerzeichen entfernen und in Kleinbuchstaben konvertieren
term = term.Replace(" ", string.Empty).ToLowerInvariant();
var tokens = new List<Token>();
//mit RegEx alle Zahlen aussortieren
var numbers = parserRegEx.Matches(term);
term = parserRegEx.Replace(term, "1");
var sb = new StringBuilder(term);
//Term in Tokens teilen
var numberIndex = 0;
while (sb.Length > 0)
{
var validToken = false;
//Zahlen prüfen
if (sb.StartsWith("1"))
{
var t = new NumberToken();
t.ParseFromString(numbers[numberIndex].Groups["number"].Value);
tokens.Add(t);
numberIndex++;
//term = ReduceString(term, 1);
sb.Remove(0, 1);
validToken = true;
}
//Operatoren prüfen
if (!validToken)
for (int i = 0; i < operators.Length; i++)
{
var token = operators[i];
if (sb.StartsWith(token))
{
var t = new OperatorToken();
if ((token == '+' || token == '-') && (tokens.Count == 0 || tokens.Last().GetName() == "(")) //Vorzeichen
{
if (token == '-')
t.ParseFromString("!");
}
else
t.ParseFromString(token.ToString());
tokens.Add(t);
//term = ReduceString(term, 1);
sb.Remove(0, 1);
validToken = true;
break;
}
}
//Funktionen prüfen
if (!validToken)
for (int i = 0; i < functions.Length; i++)
{
var token = functions[i];
if (sb.StartsWith(token))
{
var t = new FunctionToken();
t.ParseFromString(token);
tokens.Add(t);
//term = ReduceString(term, token.Length);
sb.Remove(0, token.Length);
validToken = true;
break;
}
}
//Rest prüfen
if (!validToken)
{
if (sb.StartsWith("pi")) //Pi
{
var t = new NumberToken();
t.ParseFromString(System.Math.PI.ToString());
tokens.Add(t);
//term = ReduceString(term, 2);
sb.Remove(0, 2);
}
else if (sb.StartsWith("e")) //e
{
var t = new NumberToken();
t.ParseFromString(System.Math.E.ToString());
tokens.Add(t);
//term = ReduceString(term, 1);
sb.Remove(0, 1);
}
else if (sb.StartsWith("(")) //öffnende Klammer
{
var t = new SpecialToken();
t.ParseFromString("(");
tokens.Add(t);
//term = ReduceString(term, 1);
sb.Remove(0, 1);
}
else if (sb.StartsWith(")")) //schließende Klammer
{
var t = new SpecialToken();
t.ParseFromString(")");
tokens.Add(t);
//term = ReduceString(term, 1);
sb.Remove(0, 1);
}
else if (sb.StartsWith(";")) //Argumenttrennzeichen
{
var t = new SpecialToken();
t.ParseFromString(";");
tokens.Add(t);
//term = ReduceString(term, 1);
sb.Remove(0, 1);
}
else //Token nicht bekannt
throw new ArgumentException("Dieser Term enthält einen ungültigen Token.");
}
}
return tokens.ToArray();
}
