void case_703()
#line 4950 "cs-parser.jay"
{
yyVal = new SimpleAssign ((Expression) yyVals[-2+yyTop], (Expression) yyVals[0+yyTop]);
lbag.AddLocation (yyVal, GetLocation (yyVals[-1+yyTop]));
}
protected override Arguments CreateSetterArguments (ResolveContext rc, Expression rhs)
{
//
// Indexer has arguments which complicates things as the setter and getter
// are called in two steps when unary mutator is used. We have to make a
// copy of all variable arguments to not duplicate any side effect.
//
// ++d[++arg, Foo ()]
//
if (!can_be_mutator)
return base.CreateSetterArguments (rc, rhs);
var setter_args = new Arguments (Arguments.Count + 1);
for (int i = 0; i < Arguments.Count; ++i) {
var expr = Arguments[i].Expr;
if (expr is Constant || expr is VariableReference || expr is This) {
setter_args.Add (Arguments [i]);
continue;
}
LocalVariable temp = LocalVariable.CreateCompilerGenerated (expr.Type, rc.CurrentBlock, loc);
expr = new SimpleAssign (temp.CreateReferenceExpression (rc, expr.Location), expr).Resolve (rc);
Arguments[i].Expr = temp.CreateReferenceExpression (rc, expr.Location).Resolve (rc);
setter_args.Add (Arguments [i].Clone (expr));
}
setter_args.Add (new Argument (rhs));
return setter_args;
}
public virtual object Visit(SimpleAssign simpleAssign)
{
return(null);
}
public override object Visit(SimpleAssign simpleAssign)
{
var result = new AssignmentExpression();
result.Operator = AssignmentOperatorType.Assign;
if (simpleAssign.Target != null)
result.AddChild((Expression)simpleAssign.Target.Accept(this), AssignmentExpression.LeftRole);
var location = LocationsBag.GetLocations(simpleAssign);
if (location != null)
result.AddChild(new CSharpTokenNode(Convert(location [0]), AssignmentExpression.AssignRole), AssignmentExpression.AssignRole);
if (simpleAssign.Source != null) {
result.AddChild((Expression)simpleAssign.Source.Accept(this), AssignmentExpression.RightRole);
}
return result;
}
public virtual object Visit (SimpleAssign simpleAssign)
{
return null;
}
void EmitHoistedFieldsInitialization (ResolveContext rc, EmitContext ec)
{
//
// Initialize all storey reference fields by using local or hoisted variables
//
if (used_parent_storeys != null) {
foreach (StoreyFieldPair sf in used_parent_storeys) {
//
// Get instance expression of storey field
//
Expression instace_expr = GetStoreyInstanceExpression (ec);
var fs = sf.Field.Spec;
if (TypeManager.IsGenericType (instace_expr.Type))
fs = MemberCache.GetMember (instace_expr.Type, fs);
FieldExpr f_set_expr = new FieldExpr (fs, Location);
f_set_expr.InstanceExpression = instace_expr;
// TODO: CompilerAssign expression
SimpleAssign a = new SimpleAssign (f_set_expr, sf.Storey.GetStoreyInstanceExpression (ec));
if (a.Resolve (rc) != null)
a.EmitStatement (ec);
}
}
//
// Initialize hoisted `this' only once, everywhere else will be
// referenced indirectly
//
if (initialize_hoisted_this) {
rc.CurrentBlock.AddScopeStatement (new ThisInitializer (hoisted_this, hoisted_this_parent));
}
//
// Setting currect anonymous method to null blocks any further variable hoisting
//
AnonymousExpression ae = ec.CurrentAnonymousMethod;
ec.CurrentAnonymousMethod = null;
if (hoisted_params != null) {
EmitHoistedParameters (ec, hoisted_params);
}
ec.CurrentAnonymousMethod = ae;
}
void CreateAutomaticProperty ()
{
// Create backing field
BackingField = new BackingFieldDeclaration (this, Initializer == null && Set == null);
if (!BackingField.Define ())
return;
if (Initializer != null) {
BackingField.Initializer = Initializer;
Parent.RegisterFieldForInitialization (BackingField, new FieldInitializer (BackingField, Initializer, Location));
BackingField.ModFlags |= Modifiers.READONLY;
}
Parent.PartialContainer.Members.Add (BackingField);
FieldExpr fe = new FieldExpr (BackingField, Location);
if ((BackingField.ModFlags & Modifiers.STATIC) == 0)
fe.InstanceExpression = new CompilerGeneratedThis (Parent.CurrentType, Location);
//
// Create get block but we careful with location to
// emit only single sequence point per accessor. This allow
// to set a breakpoint on it even with no user code
//
Get.Block = new ToplevelBlock (Compiler, ParametersCompiled.EmptyReadOnlyParameters, Location.Null);
Return r = new Return (fe, Get.Location);
Get.Block.AddStatement (r);
Get.ModFlags |= Modifiers.COMPILER_GENERATED;
// Create set block
if (Set != null) {
Set.Block = new ToplevelBlock (Compiler, Set.ParameterInfo, Location.Null);
Assign a = new SimpleAssign (fe, new SimpleName ("value", Location.Null), Location.Null);
Set.Block.AddStatement (new StatementExpression (a, Set.Location));
Set.ModFlags |= Modifiers.COMPILER_GENERATED;
}
}
