public override void OnLabelStatement(LabelStatement node)
{
string name = node.Name;
if (!MatchName(name)) return;
if (neededLabels.Contains(name)) return;
unneededLabels.Add(node);
}
public static GotoStatement NewGoto(LabelStatement label)
{
GotoStatement statement;
GotoStatement statement1 = statement = new GotoStatement();
statement.set_Label(new ReferenceExpression(label.get_Name()));
return statement;
}
/// <summary>
/// Make a loop:
/// $initializers
/// goto converterGeneratedName#
/// while true:
/// $iterators
/// :converterGeneratedName#
/// break $conditionType $condition
/// $body
/// </summary>
ArrayList MakeManualLoop(INode node, List <Statement> initializers, B.StatementModifierType conditionType, Expression condition, List <Statement> iterators, Statement body)
{
// we use this "while true" form because "continue" must not skip the iterator.
ArrayList list = ConvertStatements(initializers);
B.LabelStatement labelStatement = MakeLabel(GenerateName());
B.GotoStatement gotoStatement = new B.GotoStatement();
gotoStatement.Label = new B.ReferenceExpression(labelStatement.Name);
list.Add(gotoStatement);
B.WhileStatement w = new B.WhileStatement(GetLexicalInfo(node));
w.Condition = new B.BoolLiteralExpression(true);
list.Add(w);
w.Block = ConvertBlock(iterators);
B.BreakStatement breakStatement = new B.BreakStatement();
breakStatement.Modifier = new B.StatementModifier(conditionType, ConvertExpression(condition));
w.Block.Add(labelStatement);
w.Block.Add(breakStatement);
foreach (B.Statement st in ConvertBlock(body).Statements)
{
w.Block.Add(st);
}
return(list);
}
override public void LeaveLabelStatement(LabelStatement node)
{
if (null != node.Modifier)
{
Warnings.Add(
CompilerWarningFactory.ModifiersInLabelsHaveNoEffect(node.Modifier));
}
}
public void CloningShouldPreserveIsSynthetic()
{
foreach (var flag in new[] { true, false })
{
var node = new LabelStatement {IsSynthetic = flag};
Assert.AreEqual(flag, node.CloneNode().IsSynthetic);
}
}
public InternalLabel(LabelStatement labelStatement)
{
if (null == labelStatement)
{
throw new ArgumentNullException("labelStatement");
}
_labelStatement = labelStatement;
_labelStatement.Entity = this;
}
void BranchError(GotoStatement node, LabelStatement target)
{
Node parent = AstUtil.GetParentTryExceptEnsure(target);
switch (parent.NodeType)
{
case NodeType.TryStatement:
{
Error(CompilerErrorFactory.CannotBranchIntoTry(node.Label));
break;
}
case NodeType.ExceptionHandler:
{
Error(CompilerErrorFactory.CannotBranchIntoExcept(node.Label));
break;
}
case NodeType.Block:
{
Error(CompilerErrorFactory.CannotBranchIntoEnsure(node.Label));
break;
}
}
}
public override void OnLabelStatement(LabelStatement node)
{
EmitDebugInfo(node);
_il.MarkLabel(((InternalLabel)node.Entity).Label);
}
public override void OnLabelStatement(LabelStatement node)
{
AstAnnotations.SetTryBlockDepth(node, _state.TryBlockDepth);
if (null == _state.ResolveLabel(node.Name))
{
_state.AddLabel(new InternalLabel(node));
}
else
{
Error(
CompilerErrorFactory.LabelAlreadyDefined(node,
_currentMethod.FullName,
node.Name));
}
}
public GotoOnTopLevelBreak(LabelStatement label)
{
this._label = label;
}
public GotoOnTopLevelContinue(LabelStatement label)
{
_label = label;
}
override public void OnLabelStatement(LabelStatement node)
{
AstAnnotations.SetTryBlockDepth(node, _state.TryBlockDepth);
if (_state.ResolveLabel(node.Name) != null)
{
Error(CompilerErrorFactory.LabelAlreadyDefined(node, _currentMethod, node.Name));
return;
}
_state.AddLabel(new InternalLabel(node));
}
override public object Clone()
{
LabelStatement clone = new LabelStatement();
clone._lexicalInfo = _lexicalInfo;
clone._endSourceLocation = _endSourceLocation;
clone._documentation = _documentation;
clone._isSynthetic = _isSynthetic;
clone._entity = _entity;
if (_annotations != null) clone._annotations = (Hashtable)_annotations.Clone();
if (null != _modifier)
{
clone._modifier = _modifier.Clone() as StatementModifier;
clone._modifier.InitializeParent(clone);
}
clone._name = _name;
return clone;
}
public override void LeaveLabelStatement(LabelStatement node)
{
CheckName(node,node.Name);
}
IMethod CreateDisposeMethod()
{
BooMethodBuilder mn = _enumerator.AddVirtualMethod("Dispose", TypeSystemServices.VoidType);
mn.Method.LexicalInfo = this.LexicalInfo;
LabelStatement noEnsure = CodeBuilder.CreateLabel(_generator.Method, "noEnsure").LabelStatement;
mn.Body.Add(noEnsure);
mn.Body.Add(SetStateTo(_finishedStateNumber));
mn.Body.Add(new ReturnStatement());
// Create a section calling all ensure methods for each converted try block
LabelStatement[] disposeLabels = new LabelStatement[_labels.Count];
for (int i = 0; i < _convertedTryStatements.Count; i++) {
TryStatementInfo info = _convertedTryStatements[i];
disposeLabels[info._stateNumber] = CodeBuilder.CreateLabel(_generator.Method, "$ensure_" + info._stateNumber).LabelStatement;
mn.Body.Add(disposeLabels[info._stateNumber]);
mn.Body.Add(SetStateTo(_finishedStateNumber));
Block block = mn.Body;
while (info._parent != null) {
TryStatement ts = new TryStatement();
block.Add(ts);
ts.ProtectedBlock.Add(CallMethodOnSelf(info._ensureMethod));
block = ts.EnsureBlock = new Block();
info = info._parent;
}
block.Add(CallMethodOnSelf(info._ensureMethod));
mn.Body.Add(new ReturnStatement());
}
// now map the labels of the suspended states to the labels we just created
for (int i = 0; i < _labels.Count; i++) {
if (_tryStatementInfoForLabels[i] == null)
disposeLabels[i] = noEnsure;
else
disposeLabels[i] = disposeLabels[_tryStatementInfoForLabels[i]._stateNumber];
}
mn.Body.Insert(0, CodeBuilder.CreateSwitch(
this.LexicalInfo,
CodeBuilder.CreateMemberReference(_state),
disposeLabels));
return mn.Entity;
}
public override void OnLabelStatement(LabelStatement node)
{
WriteIndented(":");
WriteLine(node.Name);
}
public Statement for_c(Block container)
{
Statement statement = null;
try
{
Expression expression;
Expression expression2;
WhileStatement statement3;
Block block;
string str;
switch (this.LA(1))
{
case 0x2d:
this.declaration_statement(container);
if (base.inputState.guessing == 0)
{
statement = container.get_Statements().get_Item(-1) as DeclarationStatement;
if (statement != null)
{
statement.Annotate("PrivateScope");
}
}
break;
case 12:
case 15:
case 0x13:
case 0x1b:
case 0x1d:
case 0x27:
case 40:
case 0x2a:
case 0x2c:
case 0x3b:
case 60:
case 0x3d:
case 0x3f:
case 0x44:
case 0x4f:
case 80:
case 0x52:
case 0x58:
case 0x67:
case 0x69:
case 0x6a:
case 0x6b:
case 0x6c:
case 0x6d:
this.expression_statement(container);
break;
case 0x4d:
break;
default:
throw new NoViableAltException(this.LT(1), this.getFilename());
}
this.match(0x4d);
switch (this.LA(1))
{
case 12:
case 15:
case 0x13:
case 0x1b:
case 0x1d:
case 0x27:
case 40:
case 0x2a:
case 0x2c:
case 0x3b:
case 60:
case 0x3d:
case 0x3f:
case 0x44:
case 0x4f:
case 80:
case 0x52:
case 0x58:
case 0x67:
case 0x69:
case 0x6a:
case 0x6b:
case 0x6c:
case 0x6d:
expression = this.expression();
break;
case 0x4d:
break;
default:
throw new NoViableAltException(this.LT(1), this.getFilename());
}
this.match(0x4d);
switch (this.LA(1))
{
case 12:
case 15:
case 0x13:
case 0x1b:
case 0x1d:
case 0x27:
case 40:
case 0x2a:
case 0x2c:
case 0x3b:
case 60:
case 0x3d:
case 0x3f:
case 0x44:
case 0x4f:
case 80:
case 0x52:
case 0x58:
case 0x67:
case 0x69:
case 0x6a:
case 0x6b:
case 0x6c:
case 0x6d:
expression2 = this.assignment_expression();
break;
case 0x40:
break;
default:
throw new NoViableAltException(this.LT(1), this.getFilename());
}
if (base.inputState.guessing == 0)
{
WhileStatement statement2;
WhileStatement statement1 = statement2 = new WhileStatement();
statement2.set_Condition(expression);
statement3 = statement2;
if (expression == null)
{
BoolLiteralExpression expression3;
BoolLiteralExpression expression1 = expression3 = new BoolLiteralExpression();
expression3.set_Value(true);
statement3.set_Condition(expression3);
}
block = statement3.get_Block();
statement = statement3;
str = this.SetUpLoopLabel(statement3);
container.Add(statement);
this.EnterLoop(statement3);
}
this.match(0x40);
this.compound_or_single_stmt(block);
if (base.inputState.guessing != 0)
{
return statement;
}
this.LeaveLoop(statement3);
if (this.IsLabelInUse(statement3))
{
LabelStatement statement4;
LabelStatement statement5 = statement4 = new LabelStatement();
statement4.set_Name(str);
block.Add(statement4);
}
if (expression2 != null)
{
block.Add(expression2);
}
}
catch (RecognitionException exception)
{
if (base.inputState.guessing != 0)
{
throw;
}
this.reportError(exception);
this.recover(exception, tokenSet_15_);
return statement;
}
return statement;
}
protected LabelStatement label_stmt() //throws RecognitionException, TokenStreamException
{
LabelStatement stmt;
IToken token = null;
IToken label = null;
stmt = null;
try { // for error handling
token = LT(1);
match(COLON);
label = LT(1);
match(ID);
if (0==inputState.guessing)
{
stmt = new LabelStatement(ToLexicalInfo(token), label.getText());
}
}
catch (RecognitionException ex)
{
if (0 == inputState.guessing)
{
reportError(ex, "label_stmt");
recover(ex,tokenSet_21_);
}
else
{
throw ex;
}
}
return stmt;
}
public override void OnLabelStatement(LabelStatement node)
{
if (null == _labels) _labels = new List();
_labels.Add(node.Entity);
}
public ReferenceExpression CreateLabelReference(LabelStatement label)
{
var reference = new ReferenceExpression(label.LexicalInfo, label.Name);
reference.Entity = label.Entity;
return reference;
}
override public void OnLabelStatement(LabelStatement node)
{
base.OnLabelStatement(node);
CheckName(node, node.Name);
}
