/// <summary>
		/// Writes this object's state to a YAML emitter.
		/// </summary>
		/// <param name="emitter"></param>
		void IYamlSerializable.WriteYaml(IEmitter emitter)
		{
			foreach (var item in events)
			{
				emitter.Emit(item);
			}
		}

 /// <summary>
 /// Writes this object's state to a YAML emitter.
 /// </summary>
 void IYamlConvertible.Write(IEmitter emitter, ObjectSerializer nestedObjectSerializer)
 {
     foreach (var item in events)
     {
         emitter.Emit(item);
     }
 }

 public void AfterTypesEmit(IEmitter emitter, IList<ITypeInfo> types)
 {
     foreach (var plugin in this.Parts)
     {
         plugin.AfterTypesEmit(emitter, types);
     }
 }

        public override bool Enter(IObjectDescriptor value, IEmitter context)
        {
            var typeConverter = typeConverters.FirstOrDefault(t => t.Accepts(value.Type));
            if (typeConverter != null)
            {
                typeConverter.WriteYaml(context, value.Value, value.Type);
                return false;
            }

            var convertible = value.Value as IYamlConvertible;
            if (convertible != null)
            {
                convertible.Write(context, nestedObjectSerializer);
                return false;
            }

            #pragma warning disable 0618 // IYamlSerializable is obsolete
            var serializable = value.Value as IYamlSerializable;
            if (serializable != null)
            {
                serializable.WriteYaml(context);
                return false;
            }
            #pragma warning restore

            return base.Enter(value, context);
        }

 public void AfterEmit(IEmitter emitter, ITranslator translator)
 {
     foreach (var plugin in this.Parts)
     {
         plugin.AfterEmit(emitter, translator);
     }
 }

 public ExpressionListBlock(IEmitter emitter, IEnumerable<Expression> expressions, Expression paramArg)
     : base(emitter, null)
 {
     this.Emitter = emitter;
     this.Expressions = expressions;
     this.ParamExpression = paramArg;
 }

 public void AfterTypeEmit(IEmitter emitter, ITypeInfo type)
 {
     foreach (var plugin in this.Parts)
     {
         plugin.AfterTypeEmit(emitter, type);
     }
 }

 public ConstructorBlock(IEmitter emitter, ITypeInfo typeInfo, bool staticBlock)
     : base(emitter, typeInfo.TypeDeclaration)
 {
     this.Emitter = emitter;
     this.TypeInfo = typeInfo;
     this.StaticBlock = staticBlock;
 }

        Token id, iprop;  // id is the current ID for the current line

        /// <summary>
        /// Create a new iCalendar parser.
        /// </summary>
        /// <param name="reader">The reader that contains the stream of text iCalendar</param>
        /// <param name="_emitter">The emitter that will transform the iCalendar elements</param>
        public Parser(StreamReader reader, IEmitter _emitter)
        {
            scanner = new Scanner(reader);
            emitter = _emitter;
            emitter.VParser = this;
            errors = new ArrayList();
        }

 public ExpressionListBlock(IEmitter emitter, IEnumerable<Expression> expressions, Expression paramArg, InvocationExpression invocation = null)
     : base(emitter, null)
 {
     this.Emitter = emitter;
     this.Expressions = expressions;
     this.ParamExpression = paramArg;
     this.InvocationExpression = invocation;
 }

 public override void Emit(MappingStartEventInfo eventInfo, IEmitter emitter)
 {
     if(tagMappings.ContainsKey(eventInfo.Source.Type))
     {
         eventInfo.Tag = tagMappings[eventInfo.Source.Type];
     }
     base.Emit(eventInfo, emitter);
 }

 public EmitComposite Add(IEmitter node)
 {
     if (node.IsNotNull())
     {
         _nodes.Add(node);
     }
     return this;
 }

		public CustomSerializationObjectGraphVisitor(IEmitter emitter, IObjectGraphVisitor nextVisitor, IEnumerable<IYamlTypeConverter> typeConverters)
			: base(nextVisitor)
		{
			this.emitter = emitter;
			this.typeConverters = typeConverters != null
				? typeConverters.ToList()
				: Enumerable.Empty<IYamlTypeConverter>();
		}

 public Pdp11Assembler(Pdp11Architecture arch, Address addrBase, IEmitter emitter)
 {
     this.arch = arch;
     this.BaseAddress = addrBase;
     this.emitter = emitter;
     this.Equates = new Dictionary<string, object>();
     this.symtab = new SymbolTable();
 }

 public SwitchBlock(IEmitter emitter, CaseLabel caseLabel, string varName, bool isFirst)
     : base(emitter, caseLabel)
 {
     this.Emitter = emitter;
     this.CaseLabel = caseLabel;
     varName_ = varName;
     isFirst_ = isFirst;
 }

 public FieldBlock(IEmitter emitter, ITypeInfo typeInfo, bool staticBlock, bool fieldsOnly)
     : base(emitter, typeInfo.TypeDeclaration)
 {
     this.Emitter = emitter;
     this.TypeInfo = typeInfo;
     this.StaticBlock = staticBlock;
     this.FieldsOnly = fieldsOnly;
     this.Injectors = new List<string>();
 }

        public void Serialize(IEmitter emitter, object graph)
        {
            if (emitter == null)
            {
                throw new ArgumentNullException("emitter");
            }

            EmitDocument(emitter, new ObjectDescriptor(graph, graph != null ? graph.GetType() : typeof(object), typeof(object)));
        }

        public InlineArgumentsBlock(IEmitter emitter, ArgumentsInfo argsInfo, string inline)
            : base(emitter, argsInfo.Expression)
        {
            this.Emitter = emitter;
            this.ArgumentsInfo = argsInfo;
            this.InlineCode = inline;

            argsInfo.AddExtensionParam();
        }

        public static TypeDefinition GetBaseType(TypeDefinition type, IEmitter emitter)
        {
            if (type == null || type.BaseType == null)
            {
                return null;
            }

            return Helpers.ToTypeDefinition(type.BaseType, emitter);
        }

 public LambdaBlock(IEmitter emitter, IEnumerable<ParameterDeclaration> parameters, AstNode body, AstNode context, bool isAsync)
     : base(emitter, context)
 {
     this.Emitter = emitter;
     this.Parameters = parameters;
     this.Body = body;
     this.Context = context;
     this.IsAsync = isAsync;
 }