public override void VisitPostfixExpression(PostfixExpression x)
{
if (PushSelectionRange(x))
{
base.VisitPostfixExpression(x);
}
}
ISemantic E(PostfixExpression ex)
{
if (ex is PostfixExpression_MethodCall)
{
return(E((PostfixExpression_MethodCall)ex, !ctxt.Options.HasFlag(ResolutionOptions.ReturnMethodReferencesOnly)));
}
var foreExpr = E(ex.PostfixForeExpression);
if (foreExpr is AliasedType)
{
foreExpr = DResolver.StripAliasSymbol((AbstractType)foreExpr);
}
if (foreExpr == null)
{
if (eval)
{
return(null);
}
else
{
ctxt.LogError(new NothingFoundError(ex.PostfixForeExpression));
return(null);
}
}
if (ex is PostfixExpression_Access)
{
var r = E((PostfixExpression_Access)ex, foreExpr, true);
ctxt.CheckForSingleResult(r, ex);
return(r != null && r.Length != 0 ? r[0] : null);
}
else if (ex is PostfixExpression_Increment)
{
return(E((PostfixExpression_Increment)ex, foreExpr));
}
else if (ex is PostfixExpression_Decrement)
{
return(E((PostfixExpression_Decrement)foreExpr));
}
// myArray[0]; myArray[0..5];
// opIndex/opSlice ?
if (foreExpr is MemberSymbol)
{
foreExpr = DResolver.StripMemberSymbols((AbstractType)foreExpr);
}
if (ex is PostfixExpression_Slice)
{
return(E((PostfixExpression_Slice)ex, foreExpr));
}
else if (ex is PostfixExpression_Index)
{
return(E((PostfixExpression_Index)ex, foreExpr));
}
return(null);
}
public virtual void VisitPostfixExpression(PostfixExpression x)
{
if (x.PostfixForeExpression != null)
{
x.PostfixForeExpression.Accept(this);
}
}
AbstractType EvalForeExpression(PostfixExpression ex)
{
var foreExpr = ex.PostfixForeExpression != null?ex.PostfixForeExpression.Accept(this) : null;
if (foreExpr == null)
{
ctxt.LogError(new NothingFoundError(ex.PostfixForeExpression));
}
return(foreExpr);
}
private static int RpneLength(PostfixExpression value)
{
var r = 1;
foreach (var element in value.Elements)
{
r += 1;
if (element.Operation == PostfixExpression.Operation.Constant)
{
Debug.Assert(element.NumberSpec != null, "element.numberSpec != null");
r += NumberLength(element.NumberSpec.Value);
}
}
return(r);
}
AbstractType EvalForeExpression(PostfixExpression ex)
{
var foreExpr = ex.PostfixForeExpression != null?ex.PostfixForeExpression.Accept(this) : null;
if (foreExpr is AliasedType)
{
foreExpr = DResolver.StripAliasSymbol(foreExpr);
}
if (foreExpr == null)
{
ctxt.LogError(new NothingFoundError(ex.PostfixForeExpression));
}
return(foreExpr);
}
private void ButtonCalculateMath_Click(object sender, EventArgs e)
{
textBoxMathOutput.Clear();
var text = ReplaceConsts(richTextBoxMathInput.Text.Replace(" ", null));
try
{
if (checkBoxUseParams.Checked && richTextBoxMathInput.Lines.Length > 1)
{
foreach (var line in richTextBoxMathInput.Lines.Skip(1))
{
text = ReplaceConsts(richTextBoxMathInput.Lines[0].Replace(" ", null));
var parameters = line.Replace(" ", null).Split(';', StringSplitOptions.RemoveEmptyEntries);
var pairs = parameters.Select(param =>
{
var keyValueArr = param.Split('=');
return(new KeyValuePair <string, string>(keyValueArr[0], keyValueArr[1]));
});
foreach (var pair in pairs)
{
text = text.Replace(pair.Key, pair.Value);
}
var inputLemexes = _mathLexemeParser.Parse(text);
var exp = new PostfixExpression <double>(inputLemexes);
var result = exp.Calculate();
var value = result.Value;
textBoxMathOutput.Text += value.ToString(CultureInfo.InvariantCulture) + Environment.NewLine;
}
}
else
{
var inputLemexes = _mathLexemeParser.Parse(text);
var exp = new PostfixExpression <double>(inputLemexes);
var result = exp.Calculate();
var value = result.Value;
textBoxMathOutput.Text = value.ToString(CultureInfo.InvariantCulture);
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
private void button2_Click(object sender, EventArgs e)
{
var text = richTextBox2.Text.Replace(" ", null);
try
{
var inputLemexes = _logicLexemeParser.Parse(text);
var exp = new PostfixExpression <bool>(inputLemexes);
var result = exp.Calculate();
var value = result.Value;
textBox2.Text = value ? "1" : "0";
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
private void button3_Click(object sender, EventArgs e)
{
var text = ReplaceConsts(richTextBox3.Text);
try
{
var inputLexemes = _matrixLexemeParser.Parse(text);
var exp = new PostfixExpression <Matrix>(inputLexemes);
var result = exp.Calculate();
var value = result.Value;
textBox3.Text = value.ToString();
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
ISemantic E(PostfixExpression ex)
{
if (ex is PostfixExpression_MethodCall)
return E((PostfixExpression_MethodCall)ex, !ctxt.Options.HasFlag(ResolutionOptions.ReturnMethodReferencesOnly));
var foreExpr=E(ex.PostfixForeExpression);
if(foreExpr is AliasedType)
foreExpr = DResolver.StripAliasSymbol((AbstractType)foreExpr);
if (foreExpr == null)
{
if (eval)
throw new EvaluationException(ex.PostfixForeExpression, "Evaluation returned empty result");
else
{
ctxt.LogError(new NothingFoundError(ex.PostfixForeExpression));
return null;
}
}
if (ex is PostfixExpression_Access)
{
bool ufcs=false;
var r = E((PostfixExpression_Access)ex, out ufcs, foreExpr, true);
ctxt.CheckForSingleResult(r, ex);
return r != null && r.Length != 0 ? r[0] : null;
}
else if (ex is PostfixExpression_Increment)
return E((PostfixExpression_Increment)ex, foreExpr);
else if (ex is PostfixExpression_Decrement)
return E((PostfixExpression_Decrement)foreExpr);
// myArray[0]; myArray[0..5];
// opIndex/opSlice ?
if(foreExpr is MemberSymbol)
foreExpr = DResolver.StripMemberSymbols((AbstractType)foreExpr);
if (ex is PostfixExpression_Slice)
return E((PostfixExpression_Slice)ex, foreExpr);
else if(ex is PostfixExpression_Index)
return E((PostfixExpression_Index)ex, foreExpr);
return null;
}
private string FormatPostfixExpression(PostfixExpression data)
{
var sb = new StringBuilder();
foreach (var element in data.Elements)
{
if (element.Operation == PostfixExpression.Operation.Constant)
{
Debug.Assert(element.NumberSpec != null, "element.numberSpec != null");
sb.Append($"{FormatNumber(element.NumberSpec.Value)} ");
}
else
{
var c = element.Operation switch
{
PostfixExpression.Operation.Add => "+",
PostfixExpression.Operation.Subtract => "-",
PostfixExpression.Operation.Multiply => "*",
PostfixExpression.Operation.Divide => "/",
PostfixExpression.Operation.Remainder => "%",
PostfixExpression.Operation.Equals => "==",
PostfixExpression.Operation.Greater => ">",
PostfixExpression.Operation.Less => "<",
PostfixExpression.Operation.Negate => "neg",
PostfixExpression.Operation.AbsoluteValue => "abs",
PostfixExpression.Operation.BitwiseAnd => "&",
PostfixExpression.Operation.BitwiseNot => "~",
PostfixExpression.Operation.BitwiseOr => "|",
PostfixExpression.Operation.BitwiseXor => "^",
PostfixExpression.Operation.LeftShift => "<<",
PostfixExpression.Operation.RightShift => ">>",
_ => throw new ArgumentException(),
};
sb.Append($"{c} ");
}
}
if (sb.Length > 0)
{
sb.Remove(sb.Length - 1, 1);
}
return(sb.ToString());
}
void HandleIndexSliceExpression(PostfixExpression x)
{
res.IsMethodArguments = true;
res.ParsedExpression = x;
var overloads = new List <AbstractType>();
if (x.PostfixForeExpression == null)
{
return;
}
var b = ExpressionTypeEvaluation.EvaluateType(x.PostfixForeExpression, ctxt);
var bases = AmbiguousType.TryDissolve(b);
var ov = TypeDeclarationResolver.ResolveFurtherTypeIdentifier(ExpressionTypeEvaluation.OpSliceIdHash, bases, ctxt, x, false);
if (ov != null)
{
overloads.AddRange(ov);
}
ov = TypeDeclarationResolver.ResolveFurtherTypeIdentifier(ExpressionTypeEvaluation.OpIndexIdHash, bases, ctxt, x, false);
if (ov != null)
{
overloads.AddRange(ov);
}
if (overloads.Count == 0)
{
b = DResolver.StripMemberSymbols(b);
var toTypeDecl = new DTypeToTypeDeclVisitor();
var aa = b as AssocArrayType;
if (aa != null)
{
var retType = aa.ValueType != null?aa.ValueType.Accept(toTypeDecl) : null;
var dm = new DMethod {
Name = "opIndex",
Type = retType
};
dm.Parameters.Add(new DVariable {
Name = "index",
Type = aa.KeyType != null ? aa.KeyType.Accept(toTypeDecl) : null
});
overloads.Add(new MemberSymbol(dm, aa.ValueType, x));
if ((aa is ArrayType) && !(aa as ArrayType).IsStaticArray)
{
dm = new DMethod
{
Name = "opSlice",
Type = retType
};
overloads.Add(new MemberSymbol(dm, aa.ValueType, x));
}
}
else if (b is PointerType)
{
b = (b as PointerType).Base;
var dm = new DMethod
{
Name = "opIndex",
Type = b != null?b.Accept(toTypeDecl) : null
};
dm.Parameters.Add(new DVariable
{
Name = "index",
Type = new IdentifierDeclaration("size_t")
});
overloads.Add(new MemberSymbol(dm, b, x));
}
}
res.ResolvedTypesOrMethods = overloads.ToArray();
}
public override void visit_postfix_expression(PostfixExpression expr)
{
expr.accept_children(this);
}
public virtual Expression VisitLiftedPostfixExpression(PostfixExpression pExpr) {
if (pExpr == null) return null;
if (!this.typeSystem.IsNullableType(pExpr.Type)) { Debug.Assert(false); return null; }
LRExpression lrExpr = this.VisitTargetExpression(pExpr.Expression) as LRExpression;
if (lrExpr == null) return null;
TypeNode urType = this.typeSystem.RemoveNullableWrapper(pExpr.Type);
TypeNode paramType = urType;
LocalList locals = lrExpr.Temporaries;
ExpressionList subs = lrExpr.SubexpressionsToEvaluateOnce;
StatementList statements = new StatementList();
BlockExpression result = new BlockExpression(new Block(statements));
for (int i = 0, n = locals.Count; i < n; i++)
statements.Add(new AssignmentStatement(locals[i], subs[i]));
EnumNode eType = urType as EnumNode;
if (eType != null) urType = eType.UnderlyingType;
Local temp = new Local(Identifier.Empty, pExpr.Type);
Local tempNew = new Local(Identifier.Empty, pExpr.Type);
Expression e = this.typeSystem.ExplicitCoercion(lrExpr.Expression, pExpr.Type, this.TypeViewer);
statements.Add(new AssignmentStatement(temp, this.VisitExpression(e)));
Method hasValue = this.GetTypeView(pExpr.Type).GetMethod(StandardIds.getHasValue);
Method getValueOrDefault = this.GetTypeView(pExpr.Type).GetMethod(StandardIds.GetValueOrDefault);
Method ctor = this.GetTypeView(pExpr.Type).GetMethod(StandardIds.Ctor, paramType);
Block pushValue = new Block();
Block done = new Block();
Expression tempHasValue = new MethodCall(new MemberBinding(new UnaryExpression(temp, NodeType.AddressOf), hasValue), null);
statements.Add(new Branch(tempHasValue, pushValue));
statements.Add(new AssignmentStatement(new AddressDereference(new UnaryExpression(tempNew, NodeType.AddressOf), pExpr.Type), new Literal(null, CoreSystemTypes.Object)));
statements.Add(new Branch(null, done));
statements.Add(pushValue);
Expression value = new MethodCall(new MemberBinding(new UnaryExpression(temp, NodeType.AddressOf), getValueOrDefault), null);
value.Type = paramType;
Expression one = GetOneOfType(urType);
Expression newUVal = new BinaryExpression(value, one, pExpr.Operator, urType is Pointer ? urType : one.Type);
Construct cons = new Construct(new MemberBinding(null, ctor), new ExpressionList(newUVal));
result.Type = ctor.DeclaringType;
statements.Add(new AssignmentStatement(tempNew, cons));
statements.Add(done);
Expression target = this.VisitTargetExpression(lrExpr.Expression);
MethodCall mcall = target as MethodCall;
if (mcall != null) {
mcall.Operands.Add(tempNew);
statements.Add(new ExpressionStatement(mcall));
} else if (target != null) {
if (target.Type is Reference) {
Local temp2 = new Local(Identifier.Empty, pExpr.Type);
statements.Add(new AssignmentStatement(temp2, tempNew));
tempNew = temp2;
target = new AddressDereference(target, pExpr.Type);
}
statements.Add(new AssignmentStatement(target, tempNew));
}
statements.Add(new ExpressionStatement(temp));
result.Type = pExpr.Type;
result.SourceContext = pExpr.SourceContext;
result.Block.SourceContext = pExpr.SourceContext;
return result;
}
public override Expression VisitPostfixExpression(PostfixExpression pExpr){
if (pExpr == null) return null;
if (this.typeSystem.IsNullableType(pExpr.Type))
return VisitLiftedPostfixExpression(pExpr);
StatementList statements = new StatementList();
BlockExpression result = new BlockExpression(new Block(statements));
LRExpression lrExpr = this.VisitTargetExpression(pExpr.Expression) as LRExpression;
if (lrExpr == null) return null;
LocalList locals = lrExpr.Temporaries;
ExpressionList subs = lrExpr.SubexpressionsToEvaluateOnce;
for (int i = 0, n = locals.Count; i < n; i++)
statements.Add(new AssignmentStatement(locals[i], subs[i],pExpr.SourceContext));
TypeNode rType = pExpr.Type;
EnumNode eType = rType as EnumNode;
if (eType != null) rType = eType.UnderlyingType;
Local temp = new Local(Identifier.Empty, rType);
Expression e = this.typeSystem.AutoDereferenceCoercion(lrExpr.Expression);
statements.Add(new AssignmentStatement(temp, this.VisitExpression(e), pExpr.SourceContext));
Expression newVal = null;
if (pExpr.OperatorOverload != null){
ExpressionList arguments = new ExpressionList(1);
arguments.Add(this.VisitExpression(lrExpr.Expression));
newVal = new MethodCall(new MemberBinding(null, pExpr.OperatorOverload), arguments, NodeType.Call, rType);
}else{
Expression one = Literal.Int32One;
if (rType == SystemTypes.Int64 || rType == SystemTypes.UInt64)
one = Literal.Int64One;
else if (rType == SystemTypes.Double)
one = Literal.DoubleOne;
else if (rType == SystemTypes.Single)
one = Literal.SingleOne;
else if (rType is Pointer){
Literal elementType = new Literal(((Pointer)rType).ElementType, SystemTypes.Type);
UnaryExpression sizeOf = new UnaryExpression(elementType, NodeType.Sizeof, SystemTypes.Int32);
one = PureEvaluator.EvalUnaryExpression(elementType, sizeOf);
if (one == null) one = sizeOf;
}
newVal = new BinaryExpression(temp, one, pExpr.Operator, rType is Pointer ? rType : one.Type);
newVal = this.typeSystem.ExplicitCoercion(newVal, lrExpr.Type, this.TypeViewer);
}
Expression target = this.VisitTargetExpression(lrExpr.Expression);
MethodCall mcall = target as MethodCall;
if (mcall != null){
mcall.Operands.Add(newVal);
statements.Add(new ExpressionStatement(mcall));
}else if (target != null){
if (target.Type is Reference){
Local temp2 = new Local(Identifier.Empty, rType);
statements.Add(new AssignmentStatement(temp2, newVal));
newVal = temp2;
target = new AddressDereference(target, rType);
}
statements.Add(new AssignmentStatement(target, newVal,pExpr.SourceContext));
}
statements.Add(new ExpressionStatement(temp));
result.Type = pExpr.Type;
result.SourceContext = pExpr.SourceContext;
result.Block.SourceContext = pExpr.SourceContext;
return result;
}
public override Expression VisitPostfixExpression(PostfixExpression pExpr) {
if (pExpr == null) return null;
Expression e = this.VisitTargetExpression(pExpr.Expression);
e = this.CheckForGetAccessor(e);
if (e == null) return null;
pExpr.Expression = new LRExpression(e);
TypeNode t = pExpr.Type;
if (t == null) return null;
t = this.typeSystem.RemoveNullableWrapper(t);
if (!t.IsPrimitiveNumeric && t != SystemTypes.Char && !(t is EnumNode) && !(t is Pointer) && pExpr.OperatorOverload == null) {
this.HandleError(pExpr, Error.NoSuchOperator, pExpr.Operator == NodeType.Add ? "++" : "--", this.GetTypeName(t));
return null;
}
if (t is Pointer && ((Pointer)t).ElementType == SystemTypes.Void) {
this.HandleError(pExpr, Error.VoidError);
return null;
}
return pExpr;
}
public override Expression VisitPostfixExpression(PostfixExpression pExpr){
if (pExpr == null) return null;
Expression e = pExpr.Expression = this.VisitTargetExpression(pExpr.Expression);
if (e == null) return null;
pExpr.Type = this.typeSystem.Unwrap(e.Type);
Method overload = pExpr.OperatorOverload = this.GetPrefixOrPostfixOperatorOverload(e, pExpr.Type, pExpr.Operator);
if (overload != null)
pExpr.Type = overload.ReturnType;
return pExpr;
}
public void VisitPostfixExpression(PostfixExpression countOperation)
{
VisitExpression(countOperation.Expression);
object v = ReturnValue;
if (v != null) {
switch (countOperation.Operator) {
case TokenType.Inc:
ReturnValue = ConvertToNumber(v) + 1;
break;
case TokenType.Dec:
ReturnValue = ConvertToNumber(v) - 1;
break;
}
} else {
ReturnValue = double.NaN;
}
}
/// <summary>
/// The following are rules for C expressions.
/// </summary>
public static void SetExpressionRules()
{
// expression
// : assignment-expression [ ',' assignment-expression ]*
Expression.Is(
AssignmentExpression
.OneOrMore(Comma)
.Then(exprs => {
if (exprs.Count == 1)
{
return(exprs[0]);
}
return(AssignmentList.Create(exprs));
})
);
// primary-expression
// : identifier # Cannot be a typedef name.
// | constant
// | string-literal
// | '(' expression ')'
PrimaryExpression.Is(
Either(Variable)
.Or(Constant)
.Or(StringLiteral)
.Or(
(LeftParen).Then(Expression).Then(RightParen)
)
);
// An identifier for a variable must not be defined as a typedef name.
Variable.Is(
Identifier.Check(result => !result.Environment.IsTypedefName(result.Result)).Then(AST.Variable.Create)
);
// constant
// : const-char
// : const-int
// : const-float
Constant.Is(
Either(ConstChar)
.Or(ConstInt)
.Or(ConstFloat)
);
// constant-expression
// : conditional-expression
//
// Note:
// The size of an array should be a constant.
// Note that the check is actually performed in semantic analysis.
ConstantExpression.Is(
ConditionalExpression
);
// conditional-expression
// : logical-or-expression [ '?' expression ':' conditional-expression ]?
ConditionalExpression.Is(
(LogicalOrExpression)
.Then(
Given <Expr>()
.Then(Question)
.Then(Expression)
.Then(Colon)
.Then(ConditionalExpression)
.Then(AST.ConditionalExpression.Create)
.Optional()
)
);
// assignment-expression
// : unary-expression assignment-operator assignment-expression # first-set = first-set(unary-expression)
// | conditional-expression # first-set = first-set(cast-expression) = first-set(unary-expression) ++ { '(' }
//
// Note:
// Assignment operators are:
// '=', '*=', '/=', '%=', '+=', '-=', '<<=', '>>=', '&=', '^=', '|='
AssignmentExpression.Is(
Either(
AssignmentOperator(
UnaryExpression,
AssignmentExpression,
BinaryOperatorBuilder.Create(Assign, Assignment.Create),
BinaryOperatorBuilder.Create(MultAssign, AST.MultAssign.Create),
BinaryOperatorBuilder.Create(DivAssign, AST.DivAssign.Create),
BinaryOperatorBuilder.Create(ModAssign, AST.ModAssign.Create),
BinaryOperatorBuilder.Create(AddAssign, AST.AddAssign.Create),
BinaryOperatorBuilder.Create(SubAssign, AST.SubAssign.Create),
BinaryOperatorBuilder.Create(LeftShiftAssign, LShiftAssign.Create),
BinaryOperatorBuilder.Create(RightShiftAssign, RShiftAssign.Create),
BinaryOperatorBuilder.Create(BitwiseAndAssign, AST.BitwiseAndAssign.Create),
BinaryOperatorBuilder.Create(XorAssign, AST.XorAssign.Create),
BinaryOperatorBuilder.Create(BitwiseOrAssign, AST.BitwiseOrAssign.Create)
)
).Or(
ConditionalExpression
)
);
// postfix-expression
// : primary-expression [
// '[' expression ']' # Get element from array
// | '(' [argument-expression-list]? ')' # Function call
// | '.' identifier # Get member from struct/union
// | '->' identifier # Get member from struct/union
// | '++' # Increment
// | '--' # Decrement
// ]*
PostfixExpression.Is(
PrimaryExpression
.Then(
Either(
Given <Expr>()
.Then(LeftBracket)
.Then(Expression)
.Then(RightBracket)
.Then((array, index) => Dereference.Create(AST.Add.Create(array, index)))
).Or(
Given <Expr>()
.Then(LeftParen)
.Then(ArgumentExpressionList.Optional(ImmutableList <Expr> .Empty))
.Then(RightParen)
.Then(FuncCall.Create)
).Or(
Given <Expr>()
.Then(Period)
.Then(Identifier)
.Then(Attribute.Create)
).Or(
Given <Expr>()
.Then(RightArrow)
.Then(Identifier)
.Then((expr, member) => Attribute.Create(Dereference.Create(expr), member))
).Or(
Given <Expr>()
.Then(Increment)
.Then(PostIncrement.Create)
).Or(
Given <Expr>()
.Then(Decrement)
.Then(PostDecrement.Create)
).ZeroOrMore()
)
);
// argument-expression-list
// : assignment-expression [ ',' assignment-expression ]*
ArgumentExpressionList.Is(
AssignmentExpression.OneOrMore(Comma)
);
// unary-expression
// : postfix-expression # first-set = { id, const, string }
// | '++' unary-expression # first-set = { '++' }
// | '--' unary-expression # first-set = { '--' }
// | unary-operator cast-expression # first-set = { '&', '*', '+', '-', '~', '!' }
// | 'sizeof' unary-expression # first-set = { 'sizeof' }
// | 'sizeof' '(' Type-name ')' # first-set = { 'sizeof' }
//
// Notes:
// 1. unary-operator can be '&', '*', '+', '-', '~', '!'.
// 2. The last two rules are ambiguous: you can't figure out whether the x in sizeof(x) is a typedef of a variable.
// I have a parser hack for this: add a parser environment to track all the typedefs.
// 3. first_set = first_set(postfix-expression) + { '++', '--', '&', '*', '+', '-', '~', '!', 'sizeof' }
// = first_set(primary-expression) + { '++', '--', '&', '*', '+', '-', '~', '!', 'sizeof' }
// = { id, const, string, '++', '--', '&', '*', '+', '-', '~', '!', 'sizeof' }
UnaryExpression.Is(
Either(
PostfixExpression
).Or(
(Increment).Then(UnaryExpression).Then(PreIncrement.Create)
).Or(
(Decrement).Then(UnaryExpression).Then(PreDecrement.Create)
).Or(
(BitwiseAnd).Then(CastExpression).Then(Reference.Create)
).Or(
(Mult).Then(CastExpression).Then(Dereference.Create)
).Or(
(Add).Then(CastExpression).Then(Positive.Create)
).Or(
(Sub).Then(CastExpression).Then(Negative.Create)
).Or(
(BitwiseNot).Then(CastExpression).Then(AST.BitwiseNot.Create)
).Or(
(LogicalNot).Then(CastExpression).Then(AST.LogicalNot.Create)
).Or(
(SizeOf).Then(UnaryExpression).Then(SizeofExpr.Create)
).Or(
(SizeOf).Then(LeftParen).Then(TypeName).Then(RightParen).Then(SizeofType.Create)
)
);
// cast-expression
// : unary-expression # first-set = { id, const, string, '++', '--', '&', '*', '+', '-', '~', '!', 'sizeof' }
// | '(' type_name ')' cast-expression # first-set = '('
CastExpression.Is(
Either(
UnaryExpression
).Or(
(LeftParen).Then(TypeName).Then(RightParen).Then(CastExpression)
.Then(TypeCast.Create)
)
);
// multiplicative-expression
// : cast-expression [ [ '*' | '/' | '%' ] cast-expression ]*
MultiplicativeExpression.Is(
BinaryOperator(
CastExpression,
BinaryOperatorBuilder.Create(Mult, Multiply.Create),
BinaryOperatorBuilder.Create(Div, Divide.Create),
BinaryOperatorBuilder.Create(Mod, Modulo.Create)
)
);
// additive-expression
// : multiplicative-expression [ [ '+' | '-' ] multiplicative-expression ]*
AdditiveExpression.Is(
BinaryOperator(
MultiplicativeExpression,
BinaryOperatorBuilder.Create(Add, AST.Add.Create),
BinaryOperatorBuilder.Create(Sub, AST.Sub.Create)
)
);
// shift-expression
// : additive-expression [ [ '<<' | '>>' ] additive-expression ]*
ShiftExpression.Is(
BinaryOperator(
AdditiveExpression,
BinaryOperatorBuilder.Create(LeftShift, LShift.Create),
BinaryOperatorBuilder.Create(RightShift, RShift.Create)
)
);
// relational-expression
// : shift-expression [ [ '<' | '>' | '<=' | '>=' ] shift-expression ]*
RelationalExpression.Is(
BinaryOperator(
ShiftExpression,
BinaryOperatorBuilder.Create(Less, AST.Less.Create),
BinaryOperatorBuilder.Create(Greater, AST.Greater.Create),
BinaryOperatorBuilder.Create(LessEqual, LEqual.Create),
BinaryOperatorBuilder.Create(GreaterEqual, GEqual.Create)
)
);
// equality-expression
// : relational-expression [ [ '==' | '!=' ] relational-expression ]*
EqualityExpression.Is(
BinaryOperator(
RelationalExpression,
BinaryOperatorBuilder.Create(Equal, AST.Equal.Create),
BinaryOperatorBuilder.Create(NotEqual, AST.NotEqual.Create)
)
);
// and-expression
// : equality-expression [ '&' equality-expression ]*
AndExpression.Is(
BinaryOperator(
EqualityExpression,
BinaryOperatorBuilder.Create(BitwiseAnd, AST.BitwiseAnd.Create)
)
);
// exclusive-or-expression
// : and-expression [ '^' and-expression ]*
ExclusiveOrExpression.Is(
BinaryOperator(
AndExpression,
BinaryOperatorBuilder.Create(Xor, AST.Xor.Create)
)
);
// inclusive-or-expression
// : exclusive-or-expression [ '|' exclusive-or-expression ]*
InclusiveOrExpression.Is(
BinaryOperator(
ExclusiveOrExpression,
BinaryOperatorBuilder.Create(BitwiseOr, AST.BitwiseOr.Create)
)
);
// logical-and-expression
// : inclusive-or-expression [ '&&' inclusive-or-expression ]*
LogicalAndExpression.Is(
BinaryOperator(
InclusiveOrExpression,
BinaryOperatorBuilder.Create(LogicalAnd, AST.LogicalAnd.Create)
)
);
// logical-or-expression
// :logical-and-expression [ '||' logical-and-expression ]*
LogicalOrExpression.Is(
BinaryOperator(
LogicalAndExpression,
BinaryOperatorBuilder.Create(LogicalOr, AST.LogicalOr.Create)
)
);
}
/// <summary>
/// Visit operation called for postfix expressions.
///
/// <param name="expr">a postfix expression</param>
/// </summary>
public virtual void visit_postfix_expression(PostfixExpression expr)
{
}
public virtual Expression VisitPostfixExpression(PostfixExpression pExpr1, PostfixExpression pExpr2)
{
if (pExpr1 == null) return null;
if (pExpr2 == null)
pExpr1.Expression = this.VisitExpression(pExpr1.Expression, null);
else
pExpr1.Expression = this.VisitExpression(pExpr1.Expression, pExpr2.Expression);
return pExpr1;
}
public virtual Expression VisitPostfixExpression(PostfixExpression pExpr){
if (pExpr == null) return null;
pExpr.Expression = this.VisitExpression(pExpr.Expression);
return pExpr;
}
public override Expression VisitPostfixExpression(PostfixExpression pExpr)
{
if (pExpr == null) return null;
return base.VisitPostfixExpression((PostfixExpression)pExpr.Clone());
}
public virtual Differences VisitPostfixExpression(PostfixExpression pExpr1, PostfixExpression pExpr2){
Differences differences = new Differences(pExpr1, pExpr2);
if (pExpr1 == null || pExpr2 == null){
if (pExpr1 != pExpr2) differences.NumberOfDifferences++; else differences.NumberOfSimilarities++;
return differences;
}
PostfixExpression changes = (PostfixExpression)pExpr2.Clone();
PostfixExpression deletions = (PostfixExpression)pExpr2.Clone();
PostfixExpression insertions = (PostfixExpression)pExpr2.Clone();
Differences diff = this.VisitExpression(pExpr1.Expression, pExpr2.Expression);
if (diff == null){Debug.Assert(false); return differences;}
changes.Expression = diff.Changes as Expression;
deletions.Expression = diff.Deletions as Expression;
insertions.Expression = diff.Insertions as Expression;
Debug.Assert(diff.Changes == changes.Expression && diff.Deletions == deletions.Expression && diff.Insertions == insertions.Expression);
differences.NumberOfDifferences += diff.NumberOfDifferences;
differences.NumberOfSimilarities += diff.NumberOfSimilarities;
if (pExpr1.Operator == pExpr2.Operator) differences.NumberOfSimilarities++; else differences.NumberOfDifferences++;
if (differences.NumberOfDifferences == 0){
differences.Changes = null;
differences.Deletions = null;
differences.Insertions = null;
}else{
differences.Changes = changes;
differences.Deletions = deletions;
differences.Insertions = insertions;
}
return differences;
}
public virtual void VisitPostfixExpression(PostfixExpression x)
{
if (x.PostfixForeExpression != null)
x.PostfixForeExpression.Accept(this);
}
public static void report(Node node, int shift)
{
if (node == null)
{
indent(shift);
Console.WriteLine("NULL ENTITY");
return;
}
switch (node.NodeType)
{
case NodeType.AliasDefinition:
{
AliasDefinition alias = node as AliasDefinition;
indent(shift);
Console.WriteLine("using {0} = {1};", alias.Alias.Name, alias.AliasedUri.Name);
break;
}
case NodeType.CompilationUnit:
case NodeType.CompilationUnitSnippet:
{
CompilationUnit cu = node as CompilationUnit;
for (int i = 0, n = cu.Nodes.Length; i < n; i++)
{
report(cu.Nodes[i], 0);
}
break;
}
case NodeType.Namespace:
{
Namespace ns = node as Namespace;
if (ns.UsedNamespaces != null && ns.UsedNamespaces.Length != 0)
{
indent(shift);
Console.WriteLine("using ");
for (int i = 0, n = ns.UsedNamespaces.Length; i < n; i++)
{
Console.Write("{0}", ns.UsedNamespaces[i].Namespace.Name);
if (i < n - 1)
{
Console.Write(", ");
}
}
Console.WriteLine();
}
indent(shift);
Console.WriteLine("namespace {0}", ns.FullNameId.Name);
indent(shift);
Console.WriteLine("{");
if (ns.AliasDefinitions != null && ns.AliasDefinitions.Length != 0)
{
for (int i = 0, n = ns.AliasDefinitions.Length; i < n; i++)
{
report(ns.AliasDefinitions[i], shift + ind);
}
}
if (ns.NestedNamespaces != null && ns.NestedNamespaces.Length != 0)
{
for (int i = 0, n = ns.NestedNamespaces.Length; i < n; i++)
{
report(ns.NestedNamespaces[i], shift + ind);
}
}
if (ns.Types != null && ns.Types.Length != 0)
{
for (int i = 0, n = ns.Types.Length; i < n; i++)
{
report(ns.Types[i], shift + ind);
}
}
indent(shift);
Console.WriteLine("}");
break;
}
case NodeType.Class:
{
Class cls = node as Class;
if (cls == SystemTypes.Object)
{
Console.Write(cls.Name);
break;
}
indent(shift);
if (cls.IsAbstract)
{
Console.Write("abstract ");
}
if (cls.IsPrivate)
{
Console.Write("private ");
}
else if (cls.IsPublic)
{
Console.Write("public ");
}
else
{
Console.Write("internal "); // ??????????????
}
if (cls.IsSealed)
{
Console.Write("sealed ");
}
Console.Write("class ");
if (cls.DeclaringType != null)
{
Console.Write("{0}::", cls.DeclaringType.Name.Name);
}
Console.Write("{0}", cls.Name != null?cls.Name.Name:"<NONAME>");
if (cls.BaseClass != null)
{
Console.Write(" : {0}", cls.BaseClass.Name.Name);
}
if (cls.Interfaces != null && cls.Interfaces.Length != 0)
{
if (cls.BaseClass != null)
{
Console.Write(",");
}
else
{
Console.Write(" :");
}
for (int i = 0, n = cls.Interfaces.Length; i < n; i++)
{
Interface interfac = cls.Interfaces[i];
if (interfac != null)
{
Console.Write(" {0}", interfac.Name.Name);
}
if (i < n - 1)
{
Console.Write(",");
}
}
}
Console.WriteLine();
indent(shift);
Console.WriteLine("{");
if (cls.Members != null && cls.Members.Length != 0)
{
for (int i = 0, n = cls.Members.Length; i < n; i++)
{
Member member = cls.Members[i];
if (member == null)
{
indent(shift + ind);
Console.WriteLine("<UNRESOLVED MEMBER>");
continue;
}
report(member, shift + ind);
}
}
indent(shift);
Console.WriteLine("}");
break;
}
case NodeType.Struct:
{
Struct struc = node as Struct;
indent(shift);
if (struc.IsAbstract)
{
Console.Write("abstract ");
}
if (struc.IsPrivate)
{
Console.Write("private ");
}
else if (struc.IsPublic)
{
Console.Write("public ");
}
else
{
Console.Write("internal "); // ??????????????
}
if (struc.IsSealed)
{
Console.Write("sealed ");
}
Console.Write("struct ");
if (struc.DeclaringType != null)
{
Console.Write("{0}::", struc.DeclaringType.Name.Name);
}
Console.Write("{0}", struc.Name != null?struc.Name.Name:"<NONAME>");
if (struc.Interfaces != null && struc.Interfaces.Length != 0)
{
Console.Write(" :");
for (int i = 0, n = struc.Interfaces.Length; i < n; i++)
{
Interface interfac = struc.Interfaces[i];
if (interfac != null)
{
Console.Write(" {0}", interfac.Name.Name);
}
if (i < n - 1)
{
Console.Write(",");
}
}
}
Console.WriteLine();
indent(shift);
Console.WriteLine("{");
if (struc.Members != null && struc.Members.Length != 0)
{
for (int i = 0, n = struc.Members.Length; i < n; i++)
{
Member member = struc.Members[i];
if (member == null)
{
indent(shift + ind);
Console.WriteLine("<UNRESOLVED MEMBER>");
continue;
}
report(member, shift + ind);
}
}
indent(shift);
Console.WriteLine("}");
break;
}
case NodeType.EnumNode:
{
EnumNode enume = node as EnumNode;
indent(shift);
if (enume.Name != null && enume.Name.Name != null)
{
Console.Write("enum {0} = ", enume.Name.Name);
}
else
{
Console.Write("enum <NONAME> = ");
}
Console.Write("{");
for (int i = 0, n = enume.Members.Length; i < n; i++)
{
Field enumerator = (Field)enume.Members[i];
Console.Write("{0}", enumerator.Name.Name);
if (enumerator.DefaultValue != null)
{
Console.Write(" = {0}", enumerator.DefaultValue.ToString());
}
if (i < n - 1)
{
Console.Write(", ");
}
}
Console.WriteLine("};");
break;
}
case NodeType.Interface:
{
Interface interfac = node as Interface;
indent(shift);
if (interfac.IsAbstract)
{
Console.Write("abstract ");
}
if (interfac.IsPrivate)
{
Console.Write("private ");
}
else if (interfac.IsPublic)
{
Console.Write("public ");
}
else
{
Console.Write("internal "); // ???????????
}
Console.WriteLine("interface {0}", interfac.Name.Name);
indent(shift);
Console.WriteLine("{");
if (interfac.Members != null && interfac.Members.Length != 0)
{
for (int i = 0, n = interfac.Members.Length; i < n; i++)
{
Member member = interfac.Members[i];
if (member == null)
{
indent(shift + ind);
Console.WriteLine("<UNRESOLVED MEMBER>");
continue;
}
report(member, shift + ind);
}
}
indent(shift);
Console.WriteLine("}");
break;
}
case NodeType.Method:
case NodeType.InstanceInitializer:
{
Method method = node as Method;
indent(shift);
if (method.IsAbstract)
{
Console.Write("abstract ");
}
if (method.IsPublic)
{
Console.Write("public ");
}
if (method.IsStatic)
{
Console.Write("static ");
}
if (method.IsVirtual)
{
Console.Write("virtual ");
}
if (method.IsPrivate)
{
Console.Write("private ");
}
if (method.OverriddenMethod != null)
{
Console.Write("override ");
}
if (method.ReturnType != null && method.ReturnType.Name != null)
{
Console.Write("{0} ", method.ReturnType.Name.Name);
}
if (method.Name != null)
{
if (method.ImplementedInterfaceMethods != null && method.ImplementedInterfaceMethods.Length != 0)
{
Method interf = method.ImplementedInterfaceMethods[0];
if (interf != null)
{
string name = interf.DeclaringType.Name.Name;
Console.Write("{0}.", name);
}
}
Console.Write("{0}", method.Name.Name);
}
Console.Write(" (");
if (method.Parameters != null && method.Parameters.Length != 0)
{
for (int i = 0, n = method.Parameters.Length; i < n; i++)
{
Parameter par = method.Parameters[i];
if (par == null)
{
continue;
}
if ((par.Flags & ParameterFlags.In) != 0)
{
Console.Write("in ");
}
if ((par.Flags & ParameterFlags.Out) != 0)
{
Console.Write("out ");
}
if (par.Type != null && par.Type.Name != null)
{
Console.Write("{0}", par.Type.Name.Name);
}
else
{
report(par.Type, 0);
}
Console.Write(" {0}", par.Name.Name);
if (i < n - 1)
{
Console.Write(", ");
}
}
}
Console.Write(" )");
// method body
if (method.Body != null)
{
Console.WriteLine();
report(method.Body, shift);
}
else
{
Console.WriteLine(";");
}
break;
}
case NodeType.DelegateNode:
{
DelegateNode dn = node as DelegateNode;
indent(shift);
Console.Write("delegate ");
if (dn.ReturnType != null && dn.ReturnType.Name != null)
{
Console.Write("{0} ", dn.ReturnType.Name.Name);
}
if (dn.Name != null)
{
Console.Write("{0}", dn.Name.Name);
}
Console.Write(" (");
if (dn.Parameters != null && dn.Parameters.Length != 0)
{
for (int i = 0, n = dn.Parameters.Length; i < n; i++)
{
Parameter par = dn.Parameters[i];
if (par == null)
{
continue;
}
if ((par.Flags & ParameterFlags.In) != 0)
{
Console.Write("in ");
}
if ((par.Flags & ParameterFlags.Out) != 0)
{
Console.Write("out ");
}
if (par.Type != null && par.Type.Name != null)
{
Console.Write("{0}", par.Type.Name.Name);
}
else
{
report(par.Type, 0);
}
Console.Write(" {0}", par.Name.Name);
if (i < n - 1)
{
Console.Write(", ");
}
}
}
Console.WriteLine(" );");
break;
}
case NodeType.StaticInitializer:
{
StaticInitializer si = node as StaticInitializer;
indent(shift);
Console.WriteLine("static {0} ( )", si.Name.Name);
// body
if (si.Body != null)
{
report(si.Body, shift);
}
else
{
Console.WriteLine("NO BODY");
}
break;
}
case NodeType.FieldInitializerBlock:
{
FieldInitializerBlock initializers = node as FieldInitializerBlock;
indent(shift);
if (initializers.IsStatic)
{
Console.Write("static ");
}
Console.WriteLine("init {");
for (int i = 0, n = initializers.Statements.Length; i < n; i++)
{
report(initializers.Statements[i], shift + ind);
}
indent(shift);
Console.WriteLine("}");
break;
}
case NodeType.Base:
{
Console.Write("base");
break;
}
case NodeType.Field:
{
Field field = node as Field;
indent(shift);
if (field.IsPrivate)
{
Console.Write("private ");
}
else if (field.IsPublic)
{
Console.Write("public ");
}
if (field.IsStatic)
{
Console.Write("static ");
}
if (field.IsInitOnly)
{
Console.Write("readonly ");
}
if (field.Type != null)
{
if (field.Type.Name != null)
{
Console.Write("{0}", field.Type.Name.Name);
}
else
{
report(field.Type, 0);
}
}
Console.Write(" {0}", field.Name.Name);
if (field.Initializer != null)
{
Console.Write(" = ");
report(field.Initializer, 0);
}
Console.WriteLine(";");
break;
}
case NodeType.VariableDeclaration:
{
VariableDeclaration variable = node as VariableDeclaration;
indent(shift);
if (variable.Type != null && variable.Type.Name != null)
{
Console.Write("{0}", variable.Type.Name.Name);
}
else
{
report(variable.Type, 0);
}
Console.Write(" {0}", variable.Name.Name);
if (variable.Initializer != null)
{
Console.Write(" = ");
report(variable.Initializer, 0);
}
Console.WriteLine(";");
break;
}
case NodeType.LocalDeclarationsStatement:
{
LocalDeclarationsStatement stmt = node as LocalDeclarationsStatement;
indent(shift);
TypeNode type = stmt.Type;
if (type != null && type.Name != null)
{
Console.Write("{0}", type.Name.Name);
}
else
{
report(type, 0);
}
Console.Write(" ");
LocalDeclarationList list = stmt.Declarations;
for (int i = 0, n = list.Length; i < n; i++)
{
LocalDeclaration local = list[i];
Console.Write("{0}", local.Name.Name);
if (local.InitialValue != null)
{
Console.Write(" = ");
report(local.InitialValue, 0);
}
if (i < n - 1)
{
Console.Write(", ");
}
}
Console.WriteLine(";");
break;
}
case NodeType.Property:
{
Property property = node as Property;
indent(shift);
if (property.IsPrivate)
{
Console.Write("private ");
}
else if (property.IsPublic)
{
Console.Write("public ");
}
if (property.IsStatic)
{
Console.Write("static ");
}
if (property != null)
{
if (property.Type != null && property.Type.Name != null)
{
Console.Write("{0} ", property.Type.Name.Name);
}
if (property.ImplementedTypes != null)
{
TypeNode typ = property.ImplementedTypes[0];
Console.Write("{0}.", typ.Name.Name);
}
if (property.Name != null)
{
Console.WriteLine("{0}", property.Name.Name);
}
}
indent(shift);
Console.WriteLine("{");
if (property.Getter != null)
{
report(property.Getter, shift + ind);
}
if (property.Setter != null)
{
report(property.Setter, shift + ind);
}
indent(shift);
Console.WriteLine("}");
break;
}
case NodeType.Lock:
{
Lock _lock = node as Lock;
indent(shift);
Console.Write("lock(");
report(_lock.Guard, shift);
Console.WriteLine(")");
report(_lock.Body, shift + ind);
indent(shift);
Console.WriteLine("}");
break;
}
case NodeType.Block:
{
Block block = node as Block;
if (block == null || block.Statements == null)
{
break;
}
indent(shift);
Console.WriteLine("{");
for (int i = 0, n = block.Statements.Length; i < n; i++)
{
report(block.Statements[i], shift + ind);
Console.WriteLine();
}
indent(shift);
Console.WriteLine("}");
break;
}
case NodeType.MemberBinding:
{
MemberBinding mb = node as MemberBinding;
if (mb.TargetObject != null)
{
report(mb.TargetObject, 0);
}
else if (mb.BoundMember != null && mb.BoundMember.DeclaringType != null)
{
Console.Write(mb.BoundMember.DeclaringType.Name);
}
Console.Write(".");
if (mb.BoundMember.Name != null)
{
Console.Write(mb.BoundMember.Name.Name);
}
else
{
report(mb.BoundMember, 0);
}
break;
}
case NodeType.AssignmentStatement:
{
AssignmentStatement assignment = node as AssignmentStatement;
indent(shift);
report(assignment.Target, 0);
switch (assignment.Operator)
{
case NodeType.Nop: Console.Write(" = "); break;
case NodeType.Add: Console.Write(" += "); break;
case NodeType.Add_Ovf: Console.Write(" += "); break;
case NodeType.Add_Ovf_Un: Console.Write(" += "); break;
case NodeType.Sub: Console.Write(" -= "); break;
case NodeType.Sub_Ovf: Console.Write(" -= "); break;
case NodeType.Sub_Ovf_Un: Console.Write(" -= "); break;
case NodeType.Mul: Console.Write(" *= "); break;
case NodeType.Mul_Ovf: Console.Write(" *= "); break;
case NodeType.Mul_Ovf_Un: Console.Write(" *= "); break;
}
report(assignment.Source, 0);
Console.Write(";");
break;
}
case NodeType.ExpressionStatement:
{
ExpressionStatement exprStatement = node as ExpressionStatement;
indent(shift);
report(exprStatement.Expression, 0);
Console.Write(";");
break;
}
case NodeType.Return:
{
Return return_stmt = node as Return;
indent(shift);
Console.Write("return");
if (return_stmt.Expression != null)
{
Console.Write(" ");
report(return_stmt.Expression, 0);
}
Console.Write(";");
break;
}
case NodeType.Branch:
{
Branch branch = node as Branch;
indent(shift);
Console.WriteLine("break; (???)");
break;
}
case NodeType.For:
{
For for_stmt = node as For;
indent(shift);
Console.Write("for ( ");
for (int i = 0, n = for_stmt.Initializer.Length; i < n; i++)
{
report(for_stmt.Initializer[i], 0);
}
report(for_stmt.Condition, 0);
Console.Write("; ");
for (int i = 0, n = for_stmt.Incrementer.Length; i < n; i++)
{
report(for_stmt.Incrementer[i], 0);
}
Console.WriteLine(")");
indent(shift);
Console.WriteLine("{");
report(for_stmt.Body, shift + ind);
indent(shift);
Console.WriteLine("}");
break;
}
case NodeType.While:
{
While while_loop = node as While;
indent(shift);
Console.Write("while ( ");
report(while_loop.Condition, 0);
Console.WriteLine(" )");
report(while_loop.Body, shift);
break;
}
case NodeType.DoWhile:
{
DoWhile repeat = node as DoWhile;
indent(shift);
Console.WriteLine("do");
report(repeat.Body, shift);
indent(shift);
Console.Write("while (");
report(repeat.Condition, 0);
Console.WriteLine(" );");
break;
}
case NodeType.If:
{
If if_stmt = node as If;
indent(shift);
Console.Write("if ( ");
report(if_stmt.Condition, 0);
Console.WriteLine(" )");
report(if_stmt.TrueBlock, shift);
if (if_stmt.FalseBlock == null ||
if_stmt.FalseBlock.Statements == null ||
if_stmt.FalseBlock.Statements.Length == 0)
{
break;
}
indent(shift);
Console.WriteLine("else");
report(if_stmt.FalseBlock, shift);
break;
}
case NodeType.Switch:
{
Switch swtch = node as Switch;
indent(shift);
Console.Write("switch ( ");
report(swtch.Expression, 0);
Console.WriteLine(" )");
indent(shift);
Console.WriteLine("{");
for (int i = 0, n = swtch.Cases.Length; i < n; i++)
{
indent(shift + ind);
if (swtch.Cases[i].Label != null)
{
Console.Write("case ");
report(swtch.Cases[i].Label, 0);
Console.WriteLine(":");
}
else
{
Console.WriteLine("default:");
}
report(swtch.Cases[i].Body, shift + ind);
}
indent(shift);
Console.WriteLine("}");
break;
}
case NodeType.Throw:
{
Throw thro = node as Throw;
indent(shift);
Console.Write("throw (");
report(thro.Expression, 0);
Console.Write(");");
break;
}
case NodeType.Exit:
{
indent(shift);
Console.WriteLine("exit;");
break;
}
case NodeType.Continue:
{
indent(shift);
Console.WriteLine("continue;");
break;
}
case NodeType.Try:
{
Try trys = node as Try;
indent(shift);
Console.WriteLine("try {");
report(trys.TryBlock, shift + ind);
indent(shift);
Console.WriteLine("}");
if (trys.Catchers != null)
{
for (int i = 0, n = trys.Catchers.Length; i < n; i++)
{
indent(shift);
if (trys.Catchers[i].Type != null)
{
Console.Write("catch ( {0} ", trys.Catchers[i].Type.FullName);
}
else
{
Console.Write("catch ( ");
}
if (trys.Catchers[i].Variable != null)
{
report(trys.Catchers[i].Variable, 0);
}
Console.WriteLine(" ) {");
report(trys.Catchers[i].Block, shift + ind);
indent(shift);
Console.WriteLine("}");
}
}
if (trys.Finally != null && trys.Finally.Block != null)
{
indent(shift);
Console.WriteLine("finally");
report(trys.Finally.Block, shift);
}
break;
}
case NodeType.BlockExpression:
{
BlockExpression be = node as BlockExpression;
Console.WriteLine("(");
StatementList sl = be.Block.Statements;
for (int i = 0, n = sl.Length; i < n; i++)
{
report(sl[i], shift + ind);
}
indent(shift);
Console.Write(")");
break;
}
case NodeType.ArrayTypeExpression:
{
ArrayTypeExpression array = node as ArrayTypeExpression;
indent(shift);
if (array.ElementType != null &&
array.ElementType.Name != null &&
array.ElementType.Name.Name != null)
{
Console.Write(array.ElementType.Name.Name);
}
else
{
report(array.ElementType, 0);
}
Console.Write("[");
for (int i = 0, n = array.Rank; i < n; i++)
{
if (array.Sizes != null)
{
Console.Write(array.Sizes[i]);
}
if (i < n - 1)
{
Console.Write(",");
}
}
Console.Write("]");
break;
}
case NodeType.Construct:
{
Construct construct = node as Construct;
indent(shift);
Console.Write("new ");
report(construct.Constructor, 0);
Console.Write("(");
if (construct.Operands != null)
{
for (int i = 0, n = construct.Operands.Length; i < n; i++)
{
report(construct.Operands[i], 0);
if (i < n - 1)
{
Console.Write(",");
}
}
}
Console.Write(")");
break;
}
case NodeType.ConstructArray:
{
ConstructArray initializer = node as ConstructArray;
Console.Write("new ");
if (initializer.ElementType != null &&
initializer.ElementType.Name != null &&
initializer.ElementType.Name.Name != null)
{
Console.Write(initializer.ElementType.Name.Name);
}
else
{
report(initializer.ElementType, 0);
}
Console.Write("[");
for (int i = 0, n = initializer.Operands.Length; i < n; i++)
{
report(initializer.Operands[i], 0);
if (i < n - 1)
{
Console.Write(",");
}
}
Console.Write("]");
break;
}
case NodeType.ConstructDelegate:
{
ConstructDelegate cd = node as ConstructDelegate;
// Console.Write("new {0}({1})",cd.DelegateType.Name.Name,cd.MethodName.Name);
Console.Write("new {0}(", cd.DelegateType.Name.Name);
report(cd.TargetObject, 0);
Console.Write(".{0})", cd.MethodName.Name);
// cd.Type;
break;
}
default:
{
if (node is ZonnonCompilation)
{
ZonnonCompilation zc = node as ZonnonCompilation;
report(zc.CompilationUnits[0], shift);
}
// Expression?
else if (node is MethodCall)
{
MethodCall call = node as MethodCall;
report(call.Callee, 0);
Console.Write("(");
if (call.Operands != null && call.Operands.Length != 0)
{
for (int i = 0, n = call.Operands.Length; i < n; i++)
{
report(call.Operands[i], 0);
if (i < n - 1)
{
Console.Write(",");
}
}
}
Console.Write(")");
}
else if (node is Variable)
{
Variable variable = node as Variable;
Console.Write("{0}", variable.Name.Name);
}
else if (node is Identifier)
{
Identifier identifier = node as Identifier;
Console.Write("{0}", identifier.Name);
}
else if (node is QualifiedIdentifier)
{
QualifiedIdentifier qualid = node as QualifiedIdentifier;
report(qualid.Qualifier, 0);
Console.Write(".{0}", qualid.Identifier == null?"<UNRESOLVED>":qualid.Identifier.Name);
}
else if (node is Literal)
{
Literal literal = node as Literal;
if (literal.Value == null)
{
Console.Write("null");
}
else
{
if (literal.Value is string)
{
Console.Write("\"");
}
else if (literal.Value is char)
{
Console.Write("'");
}
Console.Write("{0}", literal.Value.ToString());
if (literal.Value is string)
{
Console.Write("\"");
}
else if (literal.Value is char)
{
Console.Write("'");
}
}
}
else if (node is Indexer)
{
Indexer indexer = node as Indexer;
report(indexer.Object, 0);
Console.Write("[");
for (int i = 0, n = indexer.Operands.Length; i < n; i++)
{
report(indexer.Operands[i], 0);
if (i < n - 1)
{
Console.Write(",");
}
}
Console.Write("]");
}
else if (node is UnaryExpression)
{
UnaryExpression unexpr = node as UnaryExpression;
bool add_pars = unexpr.Operand is BinaryExpression ||
unexpr.Operand is UnaryExpression;
switch (unexpr.NodeType)
{
case NodeType.Add: Console.Write("+"); break;
case NodeType.Sub: Console.Write("-"); break;
case NodeType.Neg: Console.Write("-"); break;
case NodeType.Not: Console.Write("~"); break;
case NodeType.UnaryPlus: Console.Write("+"); break;
case NodeType.LogicalNot: Console.Write("!"); break;
case NodeType.Conv_U2: Console.Write("(UInt16)"); break;
case NodeType.RefAddress: Console.Write("ref "); break;
case NodeType.Ckfinite: Console.Write("(Ckfinite)"); break;
default: Console.Write("???"); break;
}
if (add_pars)
{
Console.Write("(");
}
report(unexpr.Operand, 0);
if (add_pars)
{
Console.Write(")");
}
}
else if (node is BinaryExpression)
{
BinaryExpression binexpr = node as BinaryExpression;
bool add_pars = binexpr.Operand1 is BinaryExpression ||
binexpr.Operand1 is UnaryExpression;
if (binexpr.NodeType == NodeType.Castclass)
{
Console.Write("(");
report(binexpr.Operand2, 0);
Console.Write(")");
if (add_pars)
{
Console.Write("(");
}
report(binexpr.Operand1, 0);
if (add_pars)
{
Console.Write(")");
}
break;
}
if (add_pars)
{
Console.Write("(");
}
report(binexpr.Operand1, 0);
if (add_pars)
{
Console.Write(")");
}
switch (binexpr.NodeType)
{
case NodeType.Add: Console.Write(" + "); break;
case NodeType.Add_Ovf: Console.Write(" + "); break;
case NodeType.Add_Ovf_Un: Console.Write(" + "); break;
case NodeType.Sub: Console.Write(" - "); break;
case NodeType.Sub_Ovf: Console.Write(" - "); break;
case NodeType.Sub_Ovf_Un: Console.Write(" - "); break;
case NodeType.Mul: Console.Write(" * "); break;
case NodeType.Mul_Ovf: Console.Write(" * "); break;
case NodeType.Mul_Ovf_Un: Console.Write(" * "); break;
case NodeType.Div: Console.Write(" / "); break;
// case NodeType.Div : Console.Write(" DIV "); break; // "DIV" ?????
case NodeType.Rem: Console.Write(" % "); break; // "MOD" ?????
case NodeType.Or: Console.Write(" | "); break;
case NodeType.And: Console.Write(" & "); break;
case NodeType.Eq: Console.Write(" == "); break;
case NodeType.Ne: Console.Write(" != "); break;
case NodeType.Lt: Console.Write(" < "); break;
case NodeType.Le: Console.Write(" <= "); break;
case NodeType.Gt: Console.Write(" > "); break;
case NodeType.Ge: Console.Write(" >= "); break;
case NodeType.LogicalOr: Console.Write(" || "); break;
case NodeType.LogicalAnd: Console.Write(" && "); break;
case NodeType.Is: Console.Write(" is "); break;
case NodeType.Comma: Console.Write(","); break;
// case OPERATORS.In : expression.NodeType = NodeType // "IN" break;
// case OPERATORS.Implements : expression.NodeType = NodeType // "IMPLEMENTS" break;
default: Console.Write(" !! "); break;
}
add_pars = binexpr.Operand2 is BinaryExpression ||
binexpr.Operand2 is UnaryExpression;
if (add_pars)
{
Console.Write("(");
}
report(binexpr.Operand2, 0);
if (add_pars)
{
Console.Write(")");
}
}
else if (node is TernaryExpression)
{
TernaryExpression ter = node as TernaryExpression;
if (ter.NodeType == NodeType.Conditional)
{
report(ter.Operand1, 0);
Console.Write(" ? ");
report(ter.Operand2, 0);
Console.Write(" : ");
report(ter.Operand3, 0);
}
}
else if (node is PostfixExpression)
{
PostfixExpression postfixExpr = node as PostfixExpression;
report(postfixExpr.Expression, 0);
switch (postfixExpr.Operator)
{
case NodeType.Increment: Console.Write("++"); break;
case NodeType.Decrement: Console.Write("--"); break;
default: Console.Write("???"); break;
}
}
else if (node is LabeledStatement)
{
LabeledStatement lbst = node as LabeledStatement;
indent(shift);
report(lbst.Label, 0);
Console.Write(" : ");
report(lbst.Statement, 0);
}
else if (node is Goto)
{
Goto gt = node as Goto;
indent(shift);
Console.Write("goto ");
report(gt.TargetLabel, 0);
}
else
{
indent(shift);
Console.WriteLine("No code for reporting {0}:{1}", node.UniqueKey, node.ToString());
}
break;
}
}
}
public virtual void VisitPostfixExpression(PostfixExpression pExpr)
{
if (pExpr == null) return;
this.VisitExpression(pExpr.Expression);
}
public virtual Expression VisitPostfixExpression(PostfixExpression pExpr, PostfixExpression changes, PostfixExpression deletions, PostfixExpression insertions){
this.UpdateSourceContext(pExpr, changes);
if (pExpr == null) return changes;
if (changes != null){
if (deletions == null || insertions == null)
Debug.Assert(false);
else{
}
}else if (deletions != null)
return null;
return pExpr;
}
// [33] PostfixExpression = PrimaryExpression |
// PostfixExpression '[' Expression ']' |
// PostfixExpression '(' [AssignmentExpression {',' AssignmentExpression}] ')' |
// PostfixExpression '.' Ident |
// PostfixExpression '->' Ident |
// PostfixExpression ('++' | '--').
// PS = '[' Expression ']' PS' |
// PS' =
private bool IsPostfixExpression(out PostfixExpression postfixExpression)
{
postfixExpression = new PostfixExpression();
if (IsPrimaryExpression(out var primaryExpression))
{
return(true);
}
else if (IsPostfixExpression(out var morePostfixExpression))
{
if (CheckToken(SyntaxKind.OpenSquareBracketToken))
{
if (!IsExpression(out var expression))
{
return(false);
}
if (!CheckToken(SyntaxKind.ClosingSquareBracketToken))
{
return(false);
}
return(true);
}
else if (CheckToken(SyntaxKind.OpenBraceToken))
{
if (IsAssignmentExpression(out var assignmentExpression))
{
while (CheckToken(SyntaxKind.CommaToken))
{
if (!IsAssignmentExpression(out var moreAssignmentExpression))
{
return(false);
}
}
}
if (!CheckToken(SyntaxKind.ClosingBraceToken))
{
return(false);
}
return(true);
}
else if (CheckToken(SyntaxKind.DotToken) || CheckToken(SyntaxKind.DashGreaterThanToken))
{
if (!CheckToken(SyntaxKind.IdentifierToken))
{
return(false);
}
return(true);
}
else if (CheckToken(SyntaxKind.PlusPlusToken) || CheckToken(SyntaxKind.MinusMinusToken))
{
return(true);
}
return(false);
}
return(false);
}
