public void DefaultValues()
{
var sut = new NullExpression();
Assert.AreNotEqual(0, sut.GetHashCode());
Assert.AreNotEqual(1, sut.GetHashCode());
}
public void ToStringIsImplemented()
{
var actual = new NullExpression().ToString();
var expected = "NullExpression";
Assert.AreEqual(expected, actual);
}
public void Visit(NullExpression nullExpression)
{
if (_innerVisitor != null)
{
nullExpression.Accept(_innerVisitor);
}
}
public void Equality()
{
var a = new NullExpression();
var b = new NullExpression();
Assert.AreEqual(a, b);
Assert.AreEqual(a.GetHashCode(), b.GetHashCode());
}
public override Object Visit(NullExpression node, Object obj)
{
NullExpression clonedNullExpression = new NullExpression(node.Location);
//if (node.ExpressionType != null)
//clonedNullExpression.ExpressionType = node.ExpressionType.CloneType(this.typeVariableMappings,this.typeExpresionVariableMapping);
return(clonedNullExpression);
}
public override object Visit(NullExpression node, object obj)
{
if (node.Location == ((AstNode)obj).Location || found)
{
found = true;
return(this.table);
}
return(base.Visit(node, obj));
}
private Expression ParseExpression()
{
Expression value;
if (_tokenStream.IsEmpty())
{
value = new NullExpression();
}
else
{
Token tok = PeekToken();
if (tok == ReferenceStartToken || tok == OldReferenceStartToken)
{
value = ParseReference();
}
else if (tok.type == TokenType.Number ||
(IsIdentifier(tok) && !IsKeyword(tok)))
{
value = ParsePrimitive();
}
else if (IsQuotedString(tok))
{
value = ParseString();
}
else if (tok == LSquareToken)
{
value = ParseCollection();
}
else if (tok == LBraceToken)
{
value = ParseObject();
}
else if (tok == LParenToken)
{
value = ParseCast();
}
else if (tok == NewToken)
{
value = ParseConstructedObject();
}
else
{
throw new ParseException(string.Format("Unexpected token: {0} at Line: {1}, Position: {2}", tok, tok.linenumber, tok.position));
}
}
return(value);
}
public static NullExpression Create(
AphidExpressionContext context_aphidExpressionContext,
int value_i,
int value_i1
)
{
NullExpression nullExpression
= new NullExpression(context_aphidExpressionContext);
((AphidExpression)nullExpression).Index = value_i;
((AphidExpression)nullExpression).Length = value_i1;
return(nullExpression);
// TODO: Edit factory method of NullExpression
// This method should be able to configure the object in all possible ways.
// Add as many parameters as needed,
// and assign their values to each field by using the API.
}
public void EqOrNullShouldWorkAsOfficialRestriction()
{
const string propertyName = "name";
const string propertyValue = "something";
var equalsOrNullWinthNull = new EqOrNullExpression(propertyName, null);
var equalsOrNullWinthValue = new EqOrNullExpression(propertyName, propertyValue);
var nullExpression = new NullExpression(propertyName);
var equalsExpression = new SimpleExpression(propertyName, propertyValue, " = ", false);
Assert.That(equalsOrNullWinthNull.ToString(), Is.EqualTo(nullExpression.ToString()));
IEnumerable <IProjection> actual = equalsOrNullWinthNull.GetProjections();
IEnumerable <IProjection> expected = nullExpression.GetProjections();
AssertAreEquivalent(actual, expected);
Assert.That(equalsOrNullWinthValue.ToString(), Is.EqualTo(equalsExpression.ToString()));
actual = equalsOrNullWinthNull.GetProjections();
expected = equalsExpression.GetProjections();
AssertAreEquivalent(actual, expected);
}
private ICriterion BuildCriterion(QueryMember member, IEnumerator values)
{
ICriterion criterion;
WhereOperator wo;
if (!Enum.TryParse(member.Type.ToString(), out wo))
{
wo = WhereOperator.Equal;
}
switch (wo)
{
case WhereOperator.Between:
criterion = new BetweenExpression(member.PropertyName, values.NextValue(), values.NextValue());
break;
case WhereOperator.In:
criterion = new InExpression(member.PropertyName, values.NextValue <object[]>());
break;
case WhereOperator.Null:
criterion = new NullExpression(member.PropertyName);
break;
default:
criterion = new SimpleExpression(member.PropertyName, wo, values.NextValue());
break;
}
if (member.HasNot)
{
criterion = new NotExpression(criterion);
}
return(criterion);
}
public void NullExpressionProducesNull()
{
var expression = new NullExpression();
Assert.AreEqual("null;", expression.ToString());
}
public override void Accept(NullExpression nil)
{
methodBuilder.EmitInstruction(nil.Location, Opcode.LoadNull);
}
public abstract Object Visit(NullExpression node, Object obj);
public void NullExpressionProducesNull()
{
var expression = new NullExpression();
Assert.AreEqual("null;", expression.ToString());
}
public virtual T Visit(NullExpression expression)
{
return(default(T));
}
public virtual TReturn Visit(NullExpression node, TParam param) => throw new NotImplementedException();
private static void WriteNull(CodeTextBuilder code, NullExpression expression)
{
JavaScriptLiteralWriter.WriteLiteral(code, null);
}
public NullParameter(NullParameter parameter) : base(parameter)
{
Expression = parameter.Expression;
}
public override void Accept(NullExpression nil)
{
nil.Visit(parentVisitor);
methodBuilder.EmitInstruction(nil.Location, Opcode.LoadLocal, temporary);
methodBuilder.EmitInstruction(nil.Location, Opcode.BinOp, (int)BinaryOperation.Equals);
}
public int Visit(NullExpression expression)
{
_writer.Write("null");
return(0);
}
private Expression DoExpression(bool doOperator = true)
{
Expression ret = null;
if (Take(LexemeKind.LeftParenthesis, out _))
{
ret = DoExpression();
if (Take(LexemeKind.QuestionMark, out _))
{
ret = DoTernaryOperator(ret);
}
Take(LexemeKind.RightParenthesis, "closing parentheses");
}
else if (Take(LexemeKind.String, out var str))
{
if (float.TryParse(str.Content, NumberStyles.Float, CultureInfo.InvariantCulture, out var f))
{
ret = new NumberLiteralExpression(f);
}
else if (Current.Kind == LexemeKind.Exclamation)
{
ret = DoFunctionCall(str.Content);
}
else
{
if (Current.Kind == LexemeKind.LeftParenthesis)
{
ret = DoCommandExpression(str.Content);
}
else
{
Error($"unxpected string '{str.Content}' found");
}
}
}
else if (Take(LexemeKind.QuotedString, out var quotedStr))
{
ret = new StringLiteralExpression(quotedStr.Content);
}
else if (Take(LexemeKind.Exclamation, out _))
{
ret = DoNegateOperator();
}
else if (Take(LexemeKind.Keyword, out var keyword))
{
if (keyword.Content == "null")
{
ret = new NullExpression();
}
else if (keyword.Content == "true")
{
ret = new BooleanLiteralExpression(true);
}
else if (keyword.Content == "false")
{
ret = new BooleanLiteralExpression(false);
}
else
{
Error($"unexpected keyword: '{keyword.Content}'");
}
}
else if (Take(LexemeKind.Dollar, out _))
{
Push();
if (Take(LexemeKind.String, out _) && Take(LexemeKind.EqualsAssign, out _))
{
Pop();
ret = DoVariableAssign();
}
else
{
Pop();
string name = Take(LexemeKind.String, "variable name").Content;
ret = new VariableAccessExpression(name);
if (Take(LexemeKind.Increment, out _))
{
ret = new UnaryOperatorExpression(Operator.IncrementByOne, ret);
}
else if (Take(LexemeKind.Decrement, out _))
{
ret = new UnaryOperatorExpression(Operator.DecrementByOne, ret);
}
}
}
while (Take(LexemeKind.Dot, out _))
{
ret = new MemberAccessExpression(ret, Take(LexemeKind.String, "member name").Content);
if (Take(LexemeKind.Exclamation, out _))
{
ret = DoMemberCall(ret);
}
}
if (ret != null && doOperator)
{
ret = Take(LexemeKind.QuestionMark, out _)
? DoTernaryOperator(ret)
: (DoOperatorChain(ret) ?? ret);
}
return(ret);
}
public override void Accept(NullExpression nil)
{
nil.Visit(functionCompiler);
}
public Expression VisitNull(NullExpression node)
{
return(node);
}
public virtual Expression Visit(NullExpression expression)
{
return(expression);
}
public Expression ParseFactor()
{
Expression exp;
switch (_currentToken.TokenType)
{
case AphidTokenType.LeftBrace:
exp = ParseObjectExpression();
break;
case AphidTokenType.LeftBracket:
exp = ParseArrayExpression();
break;
case AphidTokenType.LeftParenthesis:
NextToken();
exp = ParseExpression();
Match(AphidTokenType.RightParenthesis);
break;
case AphidTokenType.String:
exp = ParseStringExpression();
break;
case AphidTokenType.Number:
exp = ParseNumberExpression();
break;
case AphidTokenType.Identifier:
exp = ParseIdentifierExpression();
break;
case AphidTokenType.functionOperator:
exp = ParseFunctionExpression();
break;
case AphidTokenType.forKeyword:
exp = ParseForExpression();
break;
case AphidTokenType.retKeyword:
exp = ParseReturnExpression();
break;
case AphidTokenType.trueKeyword:
exp = new BooleanExpression(true);
NextToken();
break;
case AphidTokenType.falseKeyword:
exp = new BooleanExpression(false);
NextToken();
break;
case AphidTokenType.thisKeyword:
exp = new ThisExpression();
NextToken();
break;
case AphidTokenType.ifKeyword:
exp = ParseIfExpression();
break;
case AphidTokenType.LoadScriptOperator:
exp = ParseLoadScriptExpression();
break;
case AphidTokenType.LoadLibraryOperator:
exp = ParseLoadLibraryExpression();
break;
case AphidTokenType.nullKeyword:
exp = new NullExpression();
NextToken();
break;
case AphidTokenType.breakKeyword:
exp = new BreakExpression();
NextToken();
break;
case AphidTokenType.HexNumber:
exp = new NumberExpression((decimal)Convert.ToInt64(_currentToken.Lexeme.Substring(2), 16));
NextToken();
break;
default:
throw new AphidParserException(_currentToken);
}
switch (_currentToken.TokenType)
{
case AphidTokenType.LeftBracket:
if (exp is ArrayExpression)
{
break;
}
NextToken();
var key = ParseExpression();
Match(AphidTokenType.RightBracket);
exp = new ArrayAccessExpression(exp, key);
break;
}
return(exp);
}
public void Visit(NullExpression expression)
{
Write("NULL");
}
public virtual TReturn Visit(NullExpression node, TParam param)
{
return(DefaultReturn);
}
public Expression VisitNull(NullExpression expression)
{
NullVisited = true;
return(expression);
}
protected virtual void EmitNullExpression(NullExpression expression, bool isStatement = false) =>
Append("null");
public override Object Visit(NullExpression node, Object obj)
{
return(null);
}
public Expression ParseFactor()
{
Expression exp;
switch (_currentToken.TokenType)
{
case AphidTokenType.LeftBrace:
exp = ParseObjectExpression();
break;
case AphidTokenType.LeftBracket:
exp = ParseArrayExpression();
break;
case AphidTokenType.LeftParenthesis:
NextToken();
exp = ParseExpression();
Match(AphidTokenType.RightParenthesis);
break;
case AphidTokenType.String:
exp = ParseStringExpression();
break;
case AphidTokenType.Number:
exp = ParseNumberExpression();
break;
case AphidTokenType.MinusOperator:
NextToken();
var numExp = ParseNumberExpression();
numExp.Value *= -1;
exp = numExp;
break;
case AphidTokenType.Identifier:
exp = ParseIdentifierExpression();
if (_currentToken.TokenType == AphidTokenType.definedKeyword)
{
NextToken();
exp = new UnaryOperatorExpression(AphidTokenType.definedKeyword, exp)
{
IsPostfix = true
};
}
break;
case AphidTokenType.functionOperator:
exp = ParseFunctionExpression();
break;
//case AphidTokenType.forKeyword:
// exp = ParseForExpression();
// break;
case AphidTokenType.retKeyword:
case AphidTokenType.deleteKeyword:
exp = ParseUnaryExpression();
break;
case AphidTokenType.trueKeyword:
exp = new BooleanExpression(true);
NextToken();
break;
case AphidTokenType.falseKeyword:
exp = new BooleanExpression(false);
NextToken();
break;
case AphidTokenType.thisKeyword:
exp = new ThisExpression();
NextToken();
break;
//case AphidTokenType.extendKeyword:
// exp = ParseExtendExpression();
// break;
//case AphidTokenType.ifKeyword:
// exp = ParseIfExpression();
// break;
case AphidTokenType.LoadScriptOperator:
exp = ParseLoadScriptExpression();
break;
case AphidTokenType.LoadLibraryOperator:
exp = ParseLoadLibraryExpression();
break;
case AphidTokenType.nullKeyword:
exp = new NullExpression();
NextToken();
break;
case AphidTokenType.breakKeyword:
exp = new BreakExpression();
NextToken();
break;
case AphidTokenType.HexNumber:
exp = new NumberExpression((decimal)Convert.ToInt64(_currentToken.Lexeme.Substring(2), 16));
NextToken();
break;
case AphidTokenType.PatternMatchingOperator:
var matchExp = new PatternMatchingExpression();
NextToken();
Match(AphidTokenType.LeftParenthesis);
matchExp.TestExpression = ParseExpression();
Match(AphidTokenType.RightParenthesis);
while (true)
{
var tests = new List <Expression>();
while (true)
{
tests.Add(ParseExpression());
if (_currentToken.TokenType == AphidTokenType.Comma)
{
NextToken();
}
else
{
break;
}
}
if (_currentToken.TokenType == AphidTokenType.ColonOperator)
{
NextToken();
var b = ParseExpression();
foreach (var t in tests)
{
matchExp.Patterns.Add(new Tuple <Expression, Expression>(t, b));
}
}
else
{
matchExp.Patterns.Add(new Tuple <Expression, Expression>(null, tests[0]));
}
if (_currentToken.TokenType == AphidTokenType.Comma)
{
NextToken();
}
else
{
break;
}
}
exp = matchExp;
break;
default:
throw new AphidParserException(_currentToken);
}
return(exp);
}
public NullParameter(NullParameter parameter) : base(parameter)
{
Expression = parameter.Expression;
}
