public void CloseMethod()
{
if (current_method._comp_unit != null)
{
methods.Add(current_method);
}
current_method = (SourceMethodBuilder)current_method_stack.Pop();
}
public SourceMethodBuilder OpenMethod(ICompileUnit file, int ns_id, IMethodDef method)
{
SourceMethodBuilder builder = new SourceMethodBuilder(file, ns_id, method);
current_method_stack.Push(current_method);
current_method = builder;
return(builder);
}
void ConvertSequencePoints (PdbFunction function, SourceFile file, SourceMethodBuilder builder)
{
foreach (var line in function.lines.SelectMany (lines => lines.lines))
builder.MarkSequencePoint (
(int) line.offset,
file.CompilationUnit.SourceFile,
(int) line.lineBegin,
(int) line.colBegin, line.lineBegin == 0xfeefee);
}
void ConvertSequencePoints (PdbFunction function, SourceFile file, SourceMethodBuilder builder)
{
int last_line = 0;
foreach (var line in function.lines.SelectMany (lines => lines.lines)) {
// 0xfeefee is an MS convention, we can't pass it into mdb files, so we use the last non-hidden line
bool is_hidden = line.lineBegin == 0xfeefee;
builder.MarkSequencePoint (
(int) line.offset,
file.CompilationUnit.SourceFile,
is_hidden ? last_line : (int) line.lineBegin,
(int) line.colBegin, is_hidden);
if (!is_hidden)
last_line = (int) line.lineBegin;
}
}
public override EmitContext CreateEmitContext (ILGenerator ig, SourceMethodBuilder sourceMethod)
{
EmitContext ec = new EmitContext (this, ig, ReturnType, sourceMethod);
ec.CurrentAnonymousMethod = AnonymousMethod;
return ec;
}
public virtual EmitContext CreateEmitContext (ILGenerator ig, SourceMethodBuilder sourceMethod)
{
return new EmitContext (this, ig, MemberType, sourceMethod);
}
public EmitContext CreateEmitContext (ILGenerator ig, SourceMethodBuilder sourceMethod)
{
return new EmitContext (this, ig, ReturnType, sourceMethod);
}
//
// Emits the code
//
public void Emit (TypeDefinition parent)
{
DefineOverride (parent);
var mc = (IMemberContext) method;
method.ParameterInfo.ApplyAttributes (mc, MethodBuilder);
ToplevelBlock block = method.Block;
if (block != null) {
BlockContext bc = new BlockContext (mc, block, method.ReturnType);
if (block.Resolve (null, bc, method)) {
debug_builder = member.Parent.CreateMethodSymbolEntry ();
EmitContext ec = method.CreateEmitContext (MethodBuilder.GetILGenerator (), debug_builder);
block.Emit (ec);
}
}
}
EmitContext IMethodData.CreateEmitContext (ILGenerator ig, SourceMethodBuilder sourceMethod)
{
throw new NotImplementedException ();
}
//
// Emits the code
//
public override void Emit ()
{
if (Parent.PartialContainer.IsComImport) {
if (!IsDefault ()) {
Report.Error (669, Location, "`{0}': A class with the ComImport attribute cannot have a user-defined constructor",
Parent.GetSignatureForError ());
}
// Set as internal implementation and reset block data
// to ensure no IL is generated
ConstructorBuilder.SetImplementationFlags (MethodImplAttributes.InternalCall);
block = null;
}
if ((ModFlags & Modifiers.DEBUGGER_HIDDEN) != 0)
Module.PredefinedAttributes.DebuggerHidden.EmitAttribute (ConstructorBuilder);
if (OptAttributes != null)
OptAttributes.Emit ();
base.Emit ();
parameters.ApplyAttributes (this, ConstructorBuilder);
BlockContext bc = new BlockContext (this, block, Compiler.BuiltinTypes.Void);
bc.Set (ResolveContext.Options.ConstructorScope);
if (block != null) {
//
// If we use a "this (...)" constructor initializer, then
// do not emit field initializers, they are initialized in the other constructor
//
if (!(Initializer is ConstructorThisInitializer))
Parent.PartialContainer.ResolveFieldInitializers (bc);
if (!IsStatic) {
if (Initializer == null) {
if (Parent.PartialContainer.Kind == MemberKind.Struct) {
//
// If this is a non-static `struct' constructor and doesn't have any
// initializer, it must initialize all of the struct's fields.
//
block.AddThisVariable (bc);
} else if (Parent.PartialContainer.Kind == MemberKind.Class) {
Initializer = new GeneratedBaseInitializer (Location);
}
}
if (Initializer != null &&
!(bc.FileType == SourceFileType.PlayScript && Initializer.IsAsExplicitSuperCall)) {
//
// mdb format does not support reqions. Try to workaround this by emitting the
// sequence point at initializer. Any breakpoint at constructor header should
// be adjusted to this sequence point as it's the next one which follows.
//
block.AddScopeStatement (new StatementExpression (Initializer));
}
}
if (block.Resolve (null, bc, this)) {
debug_builder = Parent.CreateMethodSymbolEntry ();
EmitContext ec = new EmitContext (this, ConstructorBuilder.GetILGenerator (), bc.ReturnType, debug_builder);
ec.With (EmitContext.Options.ConstructorScope, true);
block.Emit (ec);
}
}
if (declarative_security != null) {
foreach (var de in declarative_security) {
#if STATIC
ConstructorBuilder.__AddDeclarativeSecurity (de);
#else
ConstructorBuilder.AddDeclarativeSecurity (de.Key, de.Value);
#endif
}
}
block = null;
}
public EmitContext (IMemberContext rc, ILGenerator ig, TypeSpec return_type, SourceMethodBuilder methodSymbols)
{
this.member_context = rc;
this.ig = ig;
this.return_type = return_type;
if (rc.Module.Compiler.Settings.Checked)
flags |= Options.CheckedScope;
if (methodSymbols != null) {
this.methodSymbols = methodSymbols;
if (!rc.Module.Compiler.Settings.Optimize)
flags |= Options.AccurateDebugInfo;
} else {
flags |= Options.OmitDebugInfo;
}
#if STATIC
ig.__CleverExceptionBlockAssistance ();
#endif
}
protected SourceMethod (DeclSpace parent, MethodBase method, ICompileUnit file)
{
this.method = method;
builder = SymbolWriter.OpenMethod (file, parent.NamespaceEntry.SymbolFileID, this);
}
public void CloseMethod()
{
current_method = (SourceMethodBuilder)current_method_stack.Pop();
}
public void CloseMethod ()
{
current_method = (SourceMethodBuilder) current_method_stack.Pop ();
}
public SourceMethodBuilder OpenMethod (ICompileUnit file, int ns_id, IMethodDef method)
{
SourceMethodBuilder builder = new SourceMethodBuilder (file, ns_id, method);
current_method_stack.Push (current_method);
current_method = builder;
methods.Add (current_method);
return builder;
}
public void CloseMethod ()
{
if (current_method._comp_unit != null)
methods.Add (current_method);
current_method = (SourceMethodBuilder) current_method_stack.Pop ();
}
