public FlowBranchingException StartFlowBranching(ExceptionStatement stmt)
{
FlowBranchingException branching = new FlowBranchingException(CurrentBranching, stmt);
current_flow_branching = branching;
return(branching);
}
private CachedDecompiledMember DecompileMethod(ILanguage language, MethodDefinition method, TypeSpecificContext typeContext)
{
CachedDecompiledMember decompiledMember;
Statement statement;
try
{
DecompilationContext innerContext = null;
statement = method.Body.Decompile(language, out innerContext, typeContext);
decompiledMember = new CachedDecompiledMember(new DecompiledMember(Utilities.GetMemberUniqueName(method), statement, innerContext.MethodContext), innerContext.TypeContext);
}
catch (Exception ex)
{
this.ExceptionsWhileDecompiling.Add(method);
BlockStatement blockStatement = new BlockStatement();
statement = new ExceptionStatement(ex, method);
blockStatement.AddStatement(statement);
decompiledMember = new CachedDecompiledMember(new DecompiledMember(Utilities.GetMemberUniqueName(method), blockStatement, new MethodSpecificContext(method.Body)));
OnExceptionThrown(ex);
}
return(decompiledMember);
}
public override bool Resolve(BlockContext bc)
{
expr = expr.Resolve(bc);
if (expr == null)
{
return(false);
}
machine_initializer = bc.CurrentAnonymousMethod as T;
inside_try_block = bc.CurrentTryBlock;
return(true);
}
public void RegisterResumePoint()
{
if (inside_try_block == null)
{
resume_pc = machine_initializer.AddResumePoint(this);
}
else
{
resume_pc = inside_try_block.AddResumePoint(this, resume_pc, machine_initializer);
unwind_protect = true;
inside_try_block = null;
}
}
public Method CreateFinallyHost(ExceptionStatement block)
{
var method = new Method(IteratorHost, null, TypeManager.system_void_expr, Modifiers.COMPILER_GENERATED,
new MemberName(CompilerGeneratedClass.MakeName("", "", "Finally", finally_hosts_counter++), loc),
ParametersCompiled.EmptyReadOnlyParameters, null);
method.Block = new ToplevelBlock(method.Compiler, method.ParameterInfo, loc);
method.Block.AddStatement(new TryFinallyBlockProxyStatement(this, block));
// Cannot it add to IteratorHost because it'd be emitted before nested
// anonoymous methods which could capture shared variable
return(method);
}
public virtual void VisitExceptionStatement(ExceptionStatement node)
{
}
public virtual ICodeNode VisitExceptionStatement(ExceptionStatement node)
{
return(node);
}
public override void VisitExceptionStatement(ExceptionStatement node)
{
WriteException(new Exception("Exception in: " + node.Member.GetFullMemberName(Language), node.ExceptionObject), node.Member);
}
protected virtual void WriteInternal(IMemberDefinition member)
{
uint memberToken = member.MetadataToken.ToUInt32();
if (isStopped)
{
return;
}
membersStack.Push(member);
bool isNestedType = member is TypeDefinition && member != this.CurrentType;
if (!isNestedType)
{
formatter.PreserveIndent(member);
}
try
{
if (this.Settings.WriteDocumentation && !isNestedType)
{
int documentationStartIndex = this.formatter.CurrentPosition;
WriteDocumentation(member);
AddMemberDocumentationOffsetSpan(memberToken, documentationStartIndex, this.formatter.CurrentPosition);
}
if (member is TypeDefinition)
{
formatter.WriteMemberDeclaration(member);
WriteTypeInANewWriterIfNeeded((TypeDefinition)member);
}
else
{
int attributesStartIndex = this.formatter.CurrentPosition;
WriteAttributes(member);
AddMemberAttributesOffsetSpan(memberToken, attributesStartIndex, this.formatter.CurrentPosition);
int decompiledCodeStartIndex = this.formatter.CurrentPosition;
if (member is MethodDefinition)
{
formatter.WriteMemberDeclaration(member);
Write((MethodDefinition)member);
}
else if (member is PropertyDefinition)
{
formatter.WriteMemberDeclaration(member);
Write((PropertyDefinition)member);
}
else if (member is EventDefinition)
{
formatter.WriteMemberDeclaration(member);
Write((EventDefinition)member);
}
else if (member is FieldDefinition)
{
formatter.WriteMemberDeclaration(member);
Write((FieldDefinition)member);
}
this.currentWritingInfo.MemberTokenToDecompiledCodeMap.Add(memberToken, new OffsetSpan(decompiledCodeStartIndex, this.formatter.CurrentPosition - 1));
}
}
catch (Exception ex)
{
ExceptionStatement exceptionStatement = new ExceptionStatement(ex, member);
Visit(exceptionStatement);
formatter.RestoreIndent(member);
this.currentWritingInfo.ExceptionsWhileWriting.Add(member);
this.currentWritingInfo.MembersWithExceptions.Add(memberToken);
if (member is PropertyDefinition)
{
PropertyDefinition property = member as PropertyDefinition;
if (property.GetMethod != null)
{
this.currentWritingInfo.ExceptionsWhileWriting.Add(property.GetMethod);
}
if (property.SetMethod != null)
{
this.currentWritingInfo.ExceptionsWhileWriting.Add(property.SetMethod);
}
}
if (member is EventDefinition)
{
EventDefinition @event = member as EventDefinition;
if (@event.AddMethod != null)
{
this.currentWritingInfo.ExceptionsWhileWriting.Add(@event.AddMethod);
}
if (@event.RemoveMethod != null)
{
this.currentWritingInfo.ExceptionsWhileWriting.Add(@event.RemoveMethod);
}
if (@event.InvokeMethod != null)
{
this.currentWritingInfo.ExceptionsWhileWriting.Add(@event.InvokeMethod);
}
}
OnExceptionThrown(ex);
}
if (!(member is TypeDefinition) || (member == CurrentType))
{
formatter.RemovePreservedIndent(member);
}
membersStack.Pop();
}
public FlowBranchingTryFinally (FlowBranching parent,
ExceptionStatement stmt)
: base (parent, BranchingType.Exception, SiblingType.Try,
null, stmt.loc)
{
this.stmt = stmt;
}
public TryFinallyBlockProxyStatement(Iterator iterator, ExceptionStatement block)
{
this.iterator = iterator;
this.block = block;
}
public string GenerateRoutineScripts(RoutineScript script)
{
StringBuilder sb = new StringBuilder();
sb.AppendLine($"CREATE {script.Type.ToString()} {script.FullName}");
if (script.Parameters.Count > 0)
{
sb.AppendLine("(");
int i = 0;
foreach (Parameter parameter in script.Parameters)
{
ParameterType parameterType = parameter.ParameterType;
string strParameterType = "";
if (parameterType == ParameterType.IN)
{
strParameterType = "";
}
else if (parameterType.HasFlag(ParameterType.IN) && parameterType.HasFlag(ParameterType.OUT))
{
strParameterType = "OUT";
}
else if (parameterType != ParameterType.NONE)
{
strParameterType = parameterType.ToString();
}
string defaultValue = parameter.DefaultValue == null ? "" : "=" + parameter.DefaultValue;
sb.AppendLine($"{parameter.Name} {parameter.DataType} {defaultValue} {strParameterType}{(i == script.Parameters.Count - 1 ? "" : ",")}");
i++;
}
sb.AppendLine(")");
}
else if (script.Type == RoutineType.FUNCTION)
{
sb.AppendLine("(");
sb.AppendLine(")");
}
if (script.Type == RoutineType.FUNCTION)
{
if (script.ReturnTable == null)
{
sb.AppendLine($"RETURNS {script.ReturnDataType}");
}
else
{
sb.AppendLine($"RETURNS {script.ReturnTable.Name}({string.Join(",", script.ReturnTable.Columns.Select(t => $"{t.Name} {t.DataType}")) })");
}
}
sb.AppendLine("AS");
sb.AppendLine("BEGIN");
Action <IEnumerable <Statement> > appendStatements = (statements) =>
{
foreach (Statement statement in statements)
{
if (statement is WhileStatement @while)
{
FetchCursorStatement fetchCursorStatement = @while.Statements.FirstOrDefault(item => item is FetchCursorStatement) as FetchCursorStatement;
if (fetchCursorStatement != null && !statements.Any(item => item is FetchCursorStatement))
{
@while.Condition.Symbol = "@@FETCH_STATUS = 0";
sb.AppendLine(this.BuildStatement(fetchCursorStatement));
}
}
sb.AppendLine(this.BuildStatement(statement));
}
};
ExceptionStatement exceptionStatement = (ExceptionStatement)script.Statements.FirstOrDefault(item => item is ExceptionStatement);
if (exceptionStatement != null)
{
sb.AppendLine("BEGIN TRY");
appendStatements(script.Statements.Where(item => !(item is ExceptionStatement)));
sb.AppendLine("END TRY");
sb.AppendLine("BEGIN CATCH");
foreach (ExceptionItem exceptionItem in exceptionStatement.Items)
{
sb.AppendLine($"IF {exceptionItem.Name} = ERROR_PROCEDURE() OR {exceptionItem.Name} = ERROR_NUMBER()");
sb.AppendLine("BEGIN");
appendStatements(exceptionItem.Statements);
sb.AppendLine("END");
}
sb.AppendLine("END CATCH");
}
else
{
appendStatements(script.Statements);
}
sb.AppendLine("END");
return(this.FormatScripts(sb.ToString()));
}