public static AbstractStatement ReadStatement(CodeModelBuilder model, StatementSyntax statement)
{
if (ReaderBySyntaxType.TryGetValue(statement.GetType(), out var reader))
{
return(reader(model, statement));
}
else
{
throw new NotSupportedException(
$"Statement of type '{statement.GetType().Name}' is not supported by {nameof(StatementReader)}.");
}
}
public static Span IsUsingCustomData(this StatementSyntax node)
{
if (node == null)
{
return(null);
}
List <Type> typesToCheck = new List <Type>
{
typeof(BreakStatementSyntax),
typeof(CheckedStatementSyntax),
typeof(CommonForEachStatementSyntax),
typeof(ContinueStatementSyntax),
typeof(DoStatementSyntax),
typeof(EmptyStatementSyntax),
typeof(FixedStatementSyntax),
typeof(ForEachStatementSyntax),
typeof(ForStatementSyntax),
typeof(GotoStatementSyntax),
typeof(IfStatementSyntax),
typeof(LabeledStatementSyntax),
typeof(LocalDeclarationStatementSyntax),
typeof(LockStatementSyntax),
typeof(ReturnStatementSyntax),
typeof(SwitchStatementSyntax),
typeof(ThrowStatementSyntax),
typeof(TryStatementSyntax),
typeof(WhileStatementSyntax),
typeof(YieldStatementSyntax),
};
if (!typesToCheck.Contains(node.GetType()))
{
return(null);
}
if (node.ToString().Contains("CustomData"))
{
return(node.Span.ToSpan());
}
return(null);
}
public static IInternalStatement ToInternalStatement(this StatementSyntax syntax)
{
return(factory.Create(syntax.GetType()));
}
private void WriteStatement(StatementSyntax statement)
{
if (statement is BlockSyntax)
{
writer.WriteLinePrefix('{');
writer.AddTab();
using (var stream = new MemoryStream())
using (var subInstructionalBody = new InstructionalBody(stream, writer))
{
subInstructionalBody.locals.AddRange(instructionalBody.locals); // copy parent block locals
var origWriter = writer;
var origInstructionalBody = instructionalBody;
writer = subInstructionalBody;
instructionalBody = subInstructionalBody;
// write body
WriteBody((BlockSyntax)statement);
// write define locals
writer = origWriter;
instructionalBody = origInstructionalBody;
foreach (var local in subInstructionalBody.locals)
{
if (local.block == (BlockSyntax)statement) // only write locals part of this block
{
writer.WriteLinePrefix($"{GetTypeFullNameRef(local.type)} {local.name};");
}
}
foreach (var local in subInstructionalBody.specialLocals)
{
if (local.block == (BlockSyntax)statement) // only write locals part of this block
{
writer.WriteLinePrefix($"{local.type} {local.name};");
}
}
}
writer.RemoveTab();
writer.WriteLinePrefix('}');
}
else
{
if (statement is ExpressionStatementSyntax)
{
ExpressionStatement((ExpressionStatementSyntax)statement);
}
else if (statement is LocalDeclarationStatementSyntax)
{
LocalDeclarationStatement((LocalDeclarationStatementSyntax)statement);
}
else if (statement is IfStatementSyntax)
{
IfStatement((IfStatementSyntax)statement);
}
else if (statement is WhileStatementSyntax)
{
WhileStatement((WhileStatementSyntax)statement);
}
else if (statement is DoStatementSyntax)
{
DoStatement((DoStatementSyntax)statement);
}
else if (statement is ForStatementSyntax)
{
ForStatement((ForStatementSyntax)statement);
}
else if (statement is ForEachStatementSyntax)
{
ForEachStatement((ForEachStatementSyntax)statement);
}
else if (statement is SwitchStatementSyntax)
{
SwitchStatement((SwitchStatementSyntax)statement);
}
else if (statement is BreakStatementSyntax)
{
BreakStatement((BreakStatementSyntax)statement);
}
else if (statement is ContinueStatementSyntax)
{
ContinueStatement((ContinueStatementSyntax)statement);
}
else if (statement is FixedStatementSyntax)
{
FixedStatement((FixedStatementSyntax)statement);
}
else if (statement is ReturnStatementSyntax)
{
WriteReturnStatement((ReturnStatementSyntax)statement);
}
else if (statement is TryStatementSyntax)
{
TryStatement((TryStatementSyntax)statement);
}
else if (statement is ThrowStatementSyntax)
{
ThrowStatement((ThrowStatementSyntax)statement);
}
else if (statement is UsingStatementSyntax)
{
UsingStatement((UsingStatementSyntax)statement);
}
else if (statement is EmptyStatementSyntax)
{
EmptyStatement((EmptyStatementSyntax)statement);
}
else
{
throw new NotSupportedException("Unsupported statement: " + statement.GetType());
}
}
BlockStartCallback = null;
}
public void FlattenStatement(StatementSyntax ss, List<FlatStatement> instructions)
{
switch (ss.Kind)
{
case SyntaxKind.Block:
Flatten((BlockSyntax)ss,instructions);
return;
case SyntaxKind.ExpressionStatement:
Flatten((ExpressionStatementSyntax)ss,instructions);
return;
case SyntaxKind.ReturnStatement:
Flatten((ReturnStatementSyntax)ss,instructions);
return;
case SyntaxKind.LocalDeclarationStatement:
Flatten((LocalDeclarationStatementSyntax)ss,instructions);
return;
case SyntaxKind.ForStatement:
Flatten((ForStatementSyntax)ss,instructions);
return;
case SyntaxKind.IfStatement:
Flatten((IfStatementSyntax)ss,instructions);
return;
case SyntaxKind.BreakStatement:
Flatten((BreakStatementSyntax)ss,instructions);
return;
case SyntaxKind.ContinueStatement:
Flatten((ContinueStatementSyntax)ss, instructions);
return;
case SyntaxKind.TryStatement:
Flatten((TryStatementSyntax)ss,instructions);
return;
case SyntaxKind.DoStatement:
Flatten((DoStatementSyntax)ss,instructions);
return;
case SyntaxKind.WhileStatement:
Flatten((WhileStatementSyntax)ss,instructions);
return;
case SyntaxKind.EmptyStatement:
// do nothing. :)
return;
case SyntaxKind.SwitchStatement:
Flatten((SwitchStatementSyntax)ss,instructions);
return;
case SyntaxKind.ThrowStatement:
Flatten((ThrowStatementSyntax)ss,instructions);
return;
case SyntaxKind.ForEachStatement:
Flatten((ForEachStatementSyntax)ss,instructions);
return;
case SyntaxKind.LockStatement:
Flatten((LockStatementSyntax)ss, instructions);
return;
case SyntaxKind.UsingStatement:
Flatten((UsingStatementSyntax)ss, instructions);
return;
case SyntaxKind.GotoStatement:
case SyntaxKind.GotoCaseStatement:
case SyntaxKind.GotoDefaultStatement:
Flatten((GotoStatementSyntax)ss, instructions);
return;
case SyntaxKind.CheckedStatement:
case SyntaxKind.FixedStatement:
case SyntaxKind.GlobalStatement:
case SyntaxKind.LabeledStatement:
case SyntaxKind.UncheckedStatement:
case SyntaxKind.UnsafeStatement:
case SyntaxKind.YieldBreakStatement:
case SyntaxKind.YieldReturnStatement:
throw new NotImplementedException("statement type " + ss.GetType().ToString() + ": " + ss.Kind.ToString());
break;
default:
throw new NotImplementedException("statement type " + ss.GetType().ToString() + ": " + ss.Kind.ToString());
break;
}
}
public Statement ParseStatement(StatementSyntax syntax, SemanticModel semanticModel)
{
var bs = syntax as BlockSyntax;
var ifs = syntax as IfStatementSyntax;
var fors = syntax as ForStatementSyntax;
var foreachs = syntax as ForEachStatementSyntax;
var whiles = syntax as WhileStatementSyntax;
var continues = syntax as ContinueStatementSyntax;
var breaks = syntax as BreakStatementSyntax;
var returns = syntax as ReturnStatementSyntax;
var locals = syntax as LocalDeclarationStatementSyntax;
var exs = syntax as ExpressionStatementSyntax;
var fxs = syntax as FixedStatementSyntax;
var locks = syntax as LockStatementSyntax;
var switchs = syntax as SwitchStatementSyntax;
var trys = syntax as TryStatementSyntax;
var throws = syntax as ThrowStatementSyntax;
if (bs != null)
{
return(ParseBlockStatement(bs, semanticModel));
}
else if (ifs != null)
{
var st = new IfStatement();
st.Condition = ParseExpression(ifs.Condition, semanticModel);
st.TrueStatement = ParseStatement(ifs.Statement, semanticModel);
if (ifs.Else != null)
{
st.FalseStatement = ParseStatement(ifs.Else.Statement, semanticModel);
}
return(st);
}
else if (fors != null)
{
var st = new ForStatement();
st.Condition = ParseExpression(fors.Condition, semanticModel);
if (fors.Declaration.Variables.Count != 1)
{
var span = syntax.SyntaxTree.GetLineSpan(fors.Declaration.Variables.Span);
throw new ParseException(string.Format("{0} : for内の変数の複数同時宣言は禁止です。", span));
}
if (fors.Incrementors.Count >= 2)
{
throw new ParseException("for文内の,は使用禁止です。");
}
st.Declaration = ParseVariableDeclarationSyntax(fors.Declaration, semanticModel);
if (fors.Incrementors.Count == 1)
{
st.Incrementor = ParseExpression(fors.Incrementors[0], semanticModel);
}
st.Statement = ParseStatement(fors.Statement, semanticModel);
return(st);
}
else if (foreachs != null)
{
var st = new ForeachStatement();
var type = foreachs.Type;
st.Type = ParseType(type, semanticModel);
st.Name = foreachs.Identifier.ValueText;
st.Value = ParseExpression(foreachs.Expression, semanticModel);
st.Statement = ParseStatement(foreachs.Statement, semanticModel);
return(st);
}
else if (whiles != null)
{
var st = new WhileStatement();
st.Condition = ParseExpression(whiles.Condition, semanticModel);
st.Statement = ParseStatement(whiles.Statement, semanticModel);
return(st);
}
else if (continues != null)
{
var st = new ContinueStatement();
return(st);
}
else if (breaks != null)
{
var st = new BreakStatement();
return(st);
}
else if (returns != null)
{
var st = new ReturnStatement();
st.Return = ParseExpression(returns.Expression, semanticModel);
return(st);
}
else if (locals != null)
{
return(ParseLocalDeclaration(locals, semanticModel));
}
else if (exs != null)
{
var st = new ExpressionStatement();
st.Expression = ParseExpression(exs.Expression, semanticModel);
return(st);
}
else if (fxs != null)
{
// fixed構文は配列宣言+ブロックに分解
var blocks = ParseStatement(fxs.Statement, semanticModel);
if (!(blocks is BlockStatement))
{
return(null);
}
var vs = ParseVariableDeclarationSyntax(fxs.Declaration, semanticModel);
if (vs == null)
{
return(null);
}
(blocks as BlockStatement).Statements = (new[] { vs }).Concat((blocks as BlockStatement).Statements).ToArray();
return(blocks);
}
else if (locks != null)
{
var st = new LockStatement();
st.Expression = ParseExpression(locks.Expression, semanticModel);
st.Statement = ParseStatement(locks.Statement, semanticModel);
return(st);
}
else if (syntax == null)
{
return(null);
}
{
var span = syntax.SyntaxTree.GetLineSpan(syntax.Span);
Console.WriteLine(string.Format("{0} : {1} には未対応です。", span, syntax.GetType()));
}
return(null);
}
protected virtual void CompileStatement(StatementSyntax statement)
{
if (statement is IfStatementSyntax) CompileIfStatement( (IfStatementSyntax) statement);
else if (statement is LocalDeclarationStatementSyntax) CompileLocalDeclarationStatement((LocalDeclarationStatementSyntax)statement);
else if (statement is BlockSyntax) CompileBlock( (BlockSyntax) statement);
else if (statement is ExpressionStatementSyntax) CompileExpressionStatement( (ExpressionStatementSyntax) statement);
else if (statement is ReturnStatementSyntax) CompileReturnStatement( (ReturnStatementSyntax) statement);
else if (statement is ThrowStatementSyntax) CompileThrowStatement( (ThrowStatementSyntax) statement);
else if (statement is StatementSyntax) WriteLine("statement {0}", statement.GetType());
}
