public override object VisitUnaryOperatorExpression(UnaryOperatorExpression unaryOperatorExpression, object data)
{
if (unaryOperatorExpression.Op == UnaryOperatorType.Not) {
return unaryOperatorExpression.Expression.AcceptVisitor(this, data) == SymbolDefined ? null : SymbolDefined;
} else {
return null;
}
}
public virtual object VisitUnaryOperatorExpression(UnaryOperatorExpression unaryOperatorExpression, object data) {
Debug.Assert((unaryOperatorExpression != null));
Debug.Assert((unaryOperatorExpression.Expression != null));
return unaryOperatorExpression.Expression.AcceptVisitor(this, data);
}
void PrimaryExpr(
#line 1888 "Frames/cs.ATG"
out Expression pexpr) {
#line 1890 "Frames/cs.ATG"
TypeReference type = null;
Expression expr;
pexpr = null;
#line 1895 "Frames/cs.ATG"
Location startLocation = la.Location;
if (la.kind == 113) {
lexer.NextToken();
#line 1897 "Frames/cs.ATG"
pexpr = new PrimitiveExpression(true, "true");
} else if (la.kind == 72) {
lexer.NextToken();
#line 1898 "Frames/cs.ATG"
pexpr = new PrimitiveExpression(false, "false");
} else if (la.kind == 90) {
lexer.NextToken();
#line 1899 "Frames/cs.ATG"
pexpr = new PrimitiveExpression(null, "null");
} else if (la.kind == 2) {
lexer.NextToken();
#line 1900 "Frames/cs.ATG"
pexpr = new PrimitiveExpression(t.literalValue, t.val) { LiteralFormat = t.literalFormat };
} else if (
#line 1901 "Frames/cs.ATG"
StartOfQueryExpression()) {
QueryExpression(
#line 1902 "Frames/cs.ATG"
out pexpr);
} else if (
#line 1903 "Frames/cs.ATG"
IdentAndDoubleColon()) {
Identifier();
#line 1904 "Frames/cs.ATG"
type = new TypeReference(t.val);
Expect(10);
#line 1905 "Frames/cs.ATG"
pexpr = new TypeReferenceExpression(type);
Identifier();
#line 1906 "Frames/cs.ATG"
if (type.Type == "global") { type.IsGlobal = true; type.Type = t.val ?? "?"; } else type.Type += "." + (t.val ?? "?");
} else if (StartOf(19)) {
Identifier();
#line 1910 "Frames/cs.ATG"
pexpr = new IdentifierExpression(t.val);
if (la.kind == 48 ||
#line 1913 "Frames/cs.ATG"
IsGenericInSimpleNameOrMemberAccess()) {
if (la.kind == 48) {
ShortedLambdaExpression(
#line 1912 "Frames/cs.ATG"
(IdentifierExpression)pexpr, out pexpr);
} else {
#line 1914 "Frames/cs.ATG"
List<TypeReference> typeList;
TypeArgumentList(
#line 1915 "Frames/cs.ATG"
out typeList, false);
#line 1916 "Frames/cs.ATG"
((IdentifierExpression)pexpr).TypeArguments = typeList;
}
}
} else if (
#line 1918 "Frames/cs.ATG"
IsLambdaExpression()) {
LambdaExpression(
#line 1919 "Frames/cs.ATG"
out pexpr);
} else if (la.kind == 20) {
lexer.NextToken();
Expr(
#line 1922 "Frames/cs.ATG"
out expr);
Expect(21);
#line 1922 "Frames/cs.ATG"
pexpr = new ParenthesizedExpression(expr);
} else if (StartOf(35)) {
#line 1925 "Frames/cs.ATG"
string val = null;
switch (la.kind) {
case 52: {
lexer.NextToken();
#line 1926 "Frames/cs.ATG"
val = "System.Boolean";
break;
}
case 54: {
lexer.NextToken();
#line 1927 "Frames/cs.ATG"
val = "System.Byte";
break;
}
case 57: {
lexer.NextToken();
#line 1928 "Frames/cs.ATG"
val = "System.Char";
break;
}
case 62: {
lexer.NextToken();
#line 1929 "Frames/cs.ATG"
val = "System.Decimal";
break;
}
case 66: {
lexer.NextToken();
#line 1930 "Frames/cs.ATG"
val = "System.Double";
break;
}
case 75: {
lexer.NextToken();
#line 1931 "Frames/cs.ATG"
val = "System.Single";
break;
}
case 82: {
lexer.NextToken();
#line 1932 "Frames/cs.ATG"
val = "System.Int32";
break;
}
case 87: {
lexer.NextToken();
#line 1933 "Frames/cs.ATG"
val = "System.Int64";
break;
}
case 91: {
lexer.NextToken();
#line 1934 "Frames/cs.ATG"
val = "System.Object";
break;
}
case 102: {
lexer.NextToken();
#line 1935 "Frames/cs.ATG"
val = "System.SByte";
break;
}
case 104: {
lexer.NextToken();
#line 1936 "Frames/cs.ATG"
val = "System.Int16";
break;
}
case 108: {
lexer.NextToken();
#line 1937 "Frames/cs.ATG"
val = "System.String";
break;
}
case 116: {
lexer.NextToken();
#line 1938 "Frames/cs.ATG"
val = "System.UInt32";
break;
}
case 117: {
lexer.NextToken();
#line 1939 "Frames/cs.ATG"
val = "System.UInt64";
break;
}
case 120: {
lexer.NextToken();
#line 1940 "Frames/cs.ATG"
val = "System.UInt16";
break;
}
case 123: {
lexer.NextToken();
#line 1941 "Frames/cs.ATG"
val = "System.Void";
break;
}
}
#line 1943 "Frames/cs.ATG"
pexpr = new TypeReferenceExpression(new TypeReference(val, true)) { StartLocation = t.Location, EndLocation = t.EndLocation };
} else if (la.kind == 111) {
lexer.NextToken();
#line 1946 "Frames/cs.ATG"
pexpr = new ThisReferenceExpression(); pexpr.StartLocation = t.Location; pexpr.EndLocation = t.EndLocation;
} else if (la.kind == 51) {
lexer.NextToken();
#line 1948 "Frames/cs.ATG"
pexpr = new BaseReferenceExpression(); pexpr.StartLocation = t.Location; pexpr.EndLocation = t.EndLocation;
} else if (la.kind == 89) {
NewExpression(
#line 1951 "Frames/cs.ATG"
out pexpr);
} else if (la.kind == 115) {
lexer.NextToken();
Expect(20);
if (
#line 1955 "Frames/cs.ATG"
NotVoidPointer()) {
Expect(123);
#line 1955 "Frames/cs.ATG"
type = new TypeReference("System.Void", true);
} else if (StartOf(10)) {
TypeWithRestriction(
#line 1956 "Frames/cs.ATG"
out type, true, true);
} else SynErr(207);
Expect(21);
#line 1958 "Frames/cs.ATG"
pexpr = new TypeOfExpression(type);
} else if (la.kind == 63) {
lexer.NextToken();
Expect(20);
Type(
#line 1960 "Frames/cs.ATG"
out type);
Expect(21);
#line 1960 "Frames/cs.ATG"
pexpr = new DefaultValueExpression(type);
} else if (la.kind == 105) {
lexer.NextToken();
Expect(20);
Type(
#line 1961 "Frames/cs.ATG"
out type);
Expect(21);
#line 1961 "Frames/cs.ATG"
pexpr = new SizeOfExpression(type);
} else if (la.kind == 58) {
lexer.NextToken();
Expect(20);
Expr(
#line 1962 "Frames/cs.ATG"
out expr);
Expect(21);
#line 1962 "Frames/cs.ATG"
pexpr = new CheckedExpression(expr);
} else if (la.kind == 118) {
lexer.NextToken();
Expect(20);
Expr(
#line 1963 "Frames/cs.ATG"
out expr);
Expect(21);
#line 1963 "Frames/cs.ATG"
pexpr = new UncheckedExpression(expr);
} else if (la.kind == 64) {
lexer.NextToken();
AnonymousMethodExpr(
#line 1964 "Frames/cs.ATG"
out expr);
#line 1964 "Frames/cs.ATG"
pexpr = expr;
} else SynErr(208);
#line 1966 "Frames/cs.ATG"
if (pexpr != null) {
if (pexpr.StartLocation.IsEmpty)
pexpr.StartLocation = startLocation;
if (pexpr.EndLocation.IsEmpty)
pexpr.EndLocation = t.EndLocation;
}
while (StartOf(36)) {
if (la.kind == 31 || la.kind == 32) {
#line 1974 "Frames/cs.ATG"
startLocation = la.Location;
if (la.kind == 31) {
lexer.NextToken();
#line 1976 "Frames/cs.ATG"
pexpr = new UnaryOperatorExpression(pexpr, UnaryOperatorType.PostIncrement);
} else if (la.kind == 32) {
lexer.NextToken();
#line 1977 "Frames/cs.ATG"
pexpr = new UnaryOperatorExpression(pexpr, UnaryOperatorType.PostDecrement);
} else SynErr(209);
} else if (la.kind == 47) {
PointerMemberAccess(
#line 1980 "Frames/cs.ATG"
out pexpr, pexpr);
} else if (la.kind == 15) {
MemberAccess(
#line 1981 "Frames/cs.ATG"
out pexpr, pexpr);
} else if (la.kind == 20) {
lexer.NextToken();
#line 1985 "Frames/cs.ATG"
List<Expression> parameters = new List<Expression>();
#line 1986 "Frames/cs.ATG"
pexpr = new InvocationExpression(pexpr, parameters); pexpr.StartLocation = startLocation;
if (StartOf(26)) {
Argument(
#line 1987 "Frames/cs.ATG"
out expr);
#line 1987 "Frames/cs.ATG"
SafeAdd(pexpr, parameters, expr);
while (la.kind == 14) {
lexer.NextToken();
Argument(
#line 1988 "Frames/cs.ATG"
out expr);
#line 1988 "Frames/cs.ATG"
SafeAdd(pexpr, parameters, expr);
}
}
Expect(21);
} else {
#line 1994 "Frames/cs.ATG"
List<Expression> indices = new List<Expression>();
pexpr = new IndexerExpression(pexpr, indices);
lexer.NextToken();
Expr(
#line 1997 "Frames/cs.ATG"
out expr);
#line 1997 "Frames/cs.ATG"
SafeAdd(pexpr, indices, expr);
while (la.kind == 14) {
lexer.NextToken();
Expr(
#line 1998 "Frames/cs.ATG"
out expr);
#line 1998 "Frames/cs.ATG"
SafeAdd(pexpr, indices, expr);
}
Expect(19);
#line 2001 "Frames/cs.ATG"
if (pexpr != null) {
pexpr.StartLocation = startLocation;
pexpr.EndLocation = t.EndLocation;
}
}
}
}
public sealed override object VisitUnaryOperatorExpression(UnaryOperatorExpression unaryOperatorExpression, object data) {
this.BeginVisit(unaryOperatorExpression);
object result = this.TrackedVisitUnaryOperatorExpression(unaryOperatorExpression, data);
this.EndVisit(unaryOperatorExpression);
return result;
}
public virtual object TrackedVisitUnaryOperatorExpression(UnaryOperatorExpression unaryOperatorExpression, object data) {
return base.VisitUnaryOperatorExpression(unaryOperatorExpression, data);
}
public override object VisitUnaryOperatorExpression(UnaryOperatorExpression unaryOperatorExpression, object data)
{
base.VisitUnaryOperatorExpression(unaryOperatorExpression, data);
if (unaryOperatorExpression.Op == UnaryOperatorType.Not) {
if (unaryOperatorExpression.Expression is BinaryOperatorExpression) {
unaryOperatorExpression.Expression = new ParenthesizedExpression(unaryOperatorExpression.Expression);
}
ParenthesizedExpression pe = unaryOperatorExpression.Expression as ParenthesizedExpression;
if (pe != null) {
BinaryOperatorExpression boe = pe.Expression as BinaryOperatorExpression;
if (boe != null && boe.Op == BinaryOperatorType.ReferenceEquality) {
boe.Op = BinaryOperatorType.ReferenceInequality;
ReplaceCurrentNode(pe);
}
}
}
return null;
}
void UnaryExpr(
#line 1909 "VBNET.ATG"
out Expression uExpr) {
#line 1911 "VBNET.ATG"
Expression expr;
UnaryOperatorType uop = UnaryOperatorType.None;
bool isUOp = false;
while (la.kind == 18 || la.kind == 19 || la.kind == 22) {
if (la.kind == 19) {
lexer.NextToken();
#line 1915 "VBNET.ATG"
uop = UnaryOperatorType.Plus; isUOp = true;
} else if (la.kind == 18) {
lexer.NextToken();
#line 1916 "VBNET.ATG"
uop = UnaryOperatorType.Minus; isUOp = true;
} else {
lexer.NextToken();
#line 1917 "VBNET.ATG"
uop = UnaryOperatorType.Dereference; isUOp = true;
}
}
ExponentiationExpr(
#line 1919 "VBNET.ATG"
out expr);
#line 1921 "VBNET.ATG"
if (isUOp) {
uExpr = new UnaryOperatorExpression(expr, uop);
} else {
uExpr = expr;
}
}
void NotExpr(
#line 1810 "VBNET.ATG"
out Expression outExpr) {
#line 1811 "VBNET.ATG"
UnaryOperatorType uop = UnaryOperatorType.None;
while (la.kind == 150) {
lexer.NextToken();
#line 1812 "VBNET.ATG"
uop = UnaryOperatorType.Not;
}
ComparisonExpr(
#line 1813 "VBNET.ATG"
out outExpr);
#line 1814 "VBNET.ATG"
if (uop != UnaryOperatorType.None)
outExpr = new UnaryOperatorExpression(outExpr, uop);
}
public override object VisitUnaryOperatorExpression (UnaryOperatorExpression unaryOperatorExpression, object data)
{
string name = GetOperatorName (unaryOperatorExpression.Op);
if (!String.IsNullOrEmpty (name)) {
IReturnType returnType = GetTypeSafe (unaryOperatorExpression.Expression);
IType type = returnType != null ? this.resolver.Dom.GetType (returnType) : null;
if (type != null) {
int level;
IMethod op = FindOperator (type, name, out level);
if (op != null) {
return CreateResult (op.ReturnType);
}
}
}
return Resolve (unaryOperatorExpression.Expression);
}
public virtual object VisitUnaryOperatorExpression(UnaryOperatorExpression unaryOperatorExpression, object data) {
Debug.Assert((unaryOperatorExpression != null));
Debug.Assert((unaryOperatorExpression.Expression != null));
nodeStack.Push(unaryOperatorExpression.Expression);
unaryOperatorExpression.Expression.AcceptVisitor(this, data);
unaryOperatorExpression.Expression = ((Expression)(nodeStack.Pop()));
return null;
}
public virtual object VisitUnaryOperatorExpression(UnaryOperatorExpression unaryOperatorExpression, object data) {
throw new global::System.NotImplementedException("UnaryOperatorExpression");
}
public override object VisitUnaryOperatorExpression(UnaryOperatorExpression unaryOperatorExpression, object data)
{
CodeExpression var;
CodeAssignStatement assign;
switch (unaryOperatorExpression.Op) {
case UnaryOperatorType.Minus:
if (unaryOperatorExpression.Expression is PrimitiveExpression) {
PrimitiveExpression expression = (PrimitiveExpression)unaryOperatorExpression.Expression;
if (expression.Value is int) {
return new CodePrimitiveExpression(- (int)expression.Value);
}
if (expression.Value is System.UInt32 || expression.Value is System.UInt16) {
return new CodePrimitiveExpression(Int32.Parse("-" + expression.StringValue));
}
if (expression.Value is long) {
return new CodePrimitiveExpression(- (long)expression.Value);
}
if (expression.Value is double) {
return new CodePrimitiveExpression(- (double)expression.Value);
}
if (expression.Value is float) {
return new CodePrimitiveExpression(- (float)expression.Value);
}
}
return new CodeBinaryOperatorExpression(new CodePrimitiveExpression(0),
CodeBinaryOperatorType.Subtract,
(CodeExpression)unaryOperatorExpression.Expression.AcceptVisitor(this, data));
case UnaryOperatorType.Plus:
return unaryOperatorExpression.Expression.AcceptVisitor(this, data);
case UnaryOperatorType.PostIncrement:
// emulate i++, with i = i + 1
var = (CodeExpression)unaryOperatorExpression.Expression.AcceptVisitor(this, data);
assign = new CodeAssignStatement(var,
new CodeBinaryOperatorExpression(var,
CodeBinaryOperatorType.Add,
new CodePrimitiveExpression(1)));
AddStmt(assign);
return assign;
//return new CodeAssignStatement(var,
// new CodeBinaryOperatorExpression(var,
// CodeBinaryOperatorType.Add,
// new CodePrimitiveExpression(1)));
// RG: needs to return an Expression - Not a Statement
//return new CodeBinaryOperatorExpression(var,
// CodeBinaryOperatorType.Assign,
// new CodeBinaryOperatorExpression(var,
// CodeBinaryOperatorType.Add,
// new CodePrimitiveExpression(1)));
case UnaryOperatorType.PostDecrement:
// emulate i--, with i = i - 1
var = (CodeExpression)unaryOperatorExpression.Expression.AcceptVisitor(this, data);
assign = new CodeAssignStatement(var,
new CodeBinaryOperatorExpression(var,
CodeBinaryOperatorType.Subtract,
new CodePrimitiveExpression(1)));
AddStmt(assign);
return assign;
//return new CodeAssignStatement(var,
// new CodeBinaryOperatorExpression(var,
// CodeBinaryOperatorType.Subtract,
// new CodePrimitiveExpression(1)));
// RG: needs to return an Expression - Not a Statement
//return new CodeBinaryOperatorExpression(var,
// CodeBinaryOperatorType.Assign,
// new CodeBinaryOperatorExpression(var,
// CodeBinaryOperatorType.Subtract,
// new CodePrimitiveExpression(1)));
case UnaryOperatorType.Decrement:
// emulate --i, with i = i - 1
var = (CodeExpression)unaryOperatorExpression.Expression.AcceptVisitor(this, data);
assign = new CodeAssignStatement(var,
new CodeBinaryOperatorExpression(var,
CodeBinaryOperatorType.Subtract,
new CodePrimitiveExpression(1)));
AddStmt(assign);
return assign;
//return new CodeAssignStatement(var,
// new CodeBinaryOperatorExpression(var,
// CodeBinaryOperatorType.Subtract,
// new CodePrimitiveExpression(1)));
//return new CodeBinaryOperatorExpression(var,
// CodeBinaryOperatorType.Assign,
// new CodeBinaryOperatorExpression(var,
// CodeBinaryOperatorType.Subtract,
// new CodePrimitiveExpression(1)));
case UnaryOperatorType.Increment:
// emulate ++i, with i = i + 1
var = (CodeExpression)unaryOperatorExpression.Expression.AcceptVisitor(this, data);
assign = new CodeAssignStatement(var,
new CodeBinaryOperatorExpression(var,
CodeBinaryOperatorType.Add,
new CodePrimitiveExpression(1)));
AddStmt(assign);
return assign;
//return new CodeAssignStatement(var,
// new CodeBinaryOperatorExpression(var,
// CodeBinaryOperatorType.Add,
// new CodePrimitiveExpression(1)));
//return new CodeBinaryOperatorExpression(var,
// CodeBinaryOperatorType.Assign,
// new CodeBinaryOperatorExpression(var,
// CodeBinaryOperatorType.Add,
// new CodePrimitiveExpression(1)));
// RG:
case UnaryOperatorType.Not:
// emulate !a with a == false
var = (CodeExpression)unaryOperatorExpression.Expression.AcceptVisitor(this, data);
CodeBinaryOperatorExpression cboe = var as CodeBinaryOperatorExpression;
if (cboe != null && cboe.Operator == CodeBinaryOperatorType.IdentityEquality) {
return new CodeBinaryOperatorExpression(cboe.Left, CodeBinaryOperatorType.IdentityInequality, cboe.Right);
} else {
return new CodeBinaryOperatorExpression(var,CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression(false));
}
default:
throw new NotSupportedException("CodeDom does not support Unary Operators");
}
}