public static PersistentParameter Read(BinaryReader reader, INameDecoder nameTable)
 {
     PersistentParameter par = new PersistentParameter ();
     par.name = PersistentHelper.ReadString (reader, nameTable);
     par.documentation = PersistentHelper.ReadString (reader, nameTable);
     par.modifier = (ParameterModifier)reader.ReadByte();
     par.returnType = PersistentReturnType.Read (reader, nameTable);
     return par;
 }

 public static PersistentEvent Read(BinaryReader reader, INameDecoder nameTable)
 {
     PersistentEvent ev = new PersistentEvent();
     ev.FullyQualifiedName = PersistentHelper.ReadString (reader, nameTable);
     ev.Documentation = PersistentHelper.ReadString (reader, nameTable);
     ev.modifiers = (ModifierEnum)reader.ReadUInt32();
     ev.returnType = PersistentReturnType.Read (reader, nameTable);
     ev.region = PersistentRegion.Read (reader, nameTable);
     return ev;
 }

 public static PersistentField Read(BinaryReader reader, INameDecoder nameTable)
 {
     PersistentField field = new PersistentField ();
     field.FullyQualifiedName = PersistentHelper.ReadString (reader, nameTable);
     field.Documentation = PersistentHelper.ReadString (reader, nameTable);
     field.modifiers = (ModifierEnum)reader.ReadUInt32();
     field.returnType = PersistentReturnType.Read (reader, nameTable);
     field.region = PersistentRegion.Read (reader, nameTable);
     return field;
 }

		public static DomLocation ReadLocation (BinaryReader reader, INameDecoder nameTable)
		{
			if (ReadNull (reader)) 
				return DomLocation.Empty;
			
			int line   = reader.ReadInt32 ();
			int column = reader.ReadInt32 ();
			
			return new DomLocation (line, column);
		}

		public static DomRegion ReadRegion (BinaryReader reader, INameDecoder nameTable)
		{
			if (ReadNull (reader)) 
				return DomRegion.Empty;
			
			int startLine   = reader.ReadInt32 ();
			int startColumn = reader.ReadInt32 ();
			int endLine     = reader.ReadInt32 ();
			int endColumn   = reader.ReadInt32 ();
			
			return new DomRegion (startLine, startColumn, endLine, endColumn);
		}

 public static PersistentProperty Read(BinaryReader reader, INameDecoder nameTable)
 {
     PersistentProperty pro = new PersistentProperty ();
     pro.FullyQualifiedName = PersistentHelper.ReadString (reader, nameTable);
     pro.Documentation = PersistentHelper.ReadString (reader, nameTable);
     uint m = reader.ReadUInt32();
     pro.modifiers = (ModifierEnum)(m & (canGetFlag - 1));
     pro.canGet = (m & canGetFlag) == canGetFlag;
     pro.canSet = (m & canSetFlag) == canSetFlag;
     pro.returnType = PersistentReturnType.Read (reader, nameTable);
     pro.region = PersistentRegion.Read (reader, nameTable);
     return pro;
 }

        public static PersistentClass Read(BinaryReader reader, INameDecoder nameTable)
        {
            PersistentClass cls = new PersistentClass ();

            cls.FullyQualifiedName = PersistentHelper.ReadString (reader, nameTable);
            cls.Documentation = PersistentHelper.ReadString (reader, nameTable);

            cls.modifiers          = (ModifierEnum)reader.ReadUInt32();
            cls.classType          = (ClassType)reader.ReadInt16();

            uint count = reader.ReadUInt32();
            for (uint i = 0; i < count; ++i) {
                cls.baseTypes.Add (PersistentHelper.ReadString (reader, nameTable));
            }

            count = reader.ReadUInt32();
            for (uint i = 0; i < count; ++i) {
                cls.innerClasses.Add(PersistentClass.Read (reader, nameTable));
            }

            count = reader.ReadUInt32();
            for (uint i = 0; i < count; ++i) {
                cls.fields.Add(PersistentField.Read (reader, nameTable));
            }

            count = reader.ReadUInt32();
            for (uint i = 0; i < count; ++i) {
                cls.properties.Add(PersistentProperty.Read (reader, nameTable));
            }

            count = reader.ReadUInt32();
            for (uint i = 0; i < count; ++i) {
                IMethod m = PersistentMethod.Read (reader, nameTable);
                cls.methods.Add(m);
            }

            count = reader.ReadUInt32();
            for (uint i = 0; i < count; ++i) {
                cls.events.Add(PersistentEvent.Read (reader, nameTable));
            }

            count = reader.ReadUInt32();
            for (uint i = 0; i < count; ++i) {
                cls.indexer.Add(PersistentIndexer.Read (reader, nameTable));
            }

            cls.region = PersistentRegion.Read (reader, nameTable);
            return cls;
        }

        public static PersistentIndexer Read(BinaryReader reader, INameDecoder nameTable)
        {
            PersistentIndexer ind = new PersistentIndexer();
            ind.FullyQualifiedName = PersistentHelper.ReadString (reader, nameTable);
            ind.Documentation = PersistentHelper.ReadString (reader, nameTable);
            ind.modifiers = (ModifierEnum)reader.ReadUInt32();
            ind.returnType = PersistentReturnType.Read (reader, nameTable);

            uint count = reader.ReadUInt32();
            for (uint i = 0; i < count; ++i) {
                ind.parameters.Add (PersistentParameter.Read (reader, nameTable));
            }
            ind.region = PersistentRegion.Read (reader, nameTable);
            return ind;
        }

        public static PersistentMethod Read(BinaryReader reader, INameDecoder nameTable)
        {
            PersistentMethod met = new PersistentMethod ();
            met.FullyQualifiedName = PersistentHelper.ReadString (reader, nameTable);
            met.Documentation = PersistentHelper.ReadString (reader, nameTable);

            met.modifiers = (ModifierEnum)reader.ReadUInt32();
            met.returnType = PersistentReturnType.Read (reader, nameTable);

            uint count = reader.ReadUInt32();
            for (uint i = 0; i < count; ++i) {
                met.parameters.Add (PersistentParameter.Read (reader, nameTable));
            }
            met.region = PersistentRegion.Read (reader, nameTable);
            return met;
        }

        public static PersistentReturnType Read(BinaryReader reader, INameDecoder nameTable)
        {
            if (PersistentHelper.ReadNull (reader)) return null;

            PersistentReturnType rt = new PersistentReturnType ();
            rt.FullyQualifiedName = PersistentHelper.ReadString (reader, nameTable);

            rt.pointerNestingLevel = reader.ReadInt32();

            uint count = reader.ReadUInt32();
            rt.arrayDimensions = new int[count];
            for (uint i = 0; i < rt.arrayDimensions.Length; ++i) {
                rt.arrayDimensions[i] = reader.ReadInt32();
            }
            return rt;
        }

		public static TypeParameter ReadTypeParameter (BinaryReader reader, INameDecoder nameTable)
		{
			string name = ReadString (reader, nameTable);
			TypeParameter tp = new TypeParameter (name);
			
			// Flags
			
			byte f = reader.ReadByte ();
			if ((f & 1) != 0)
				tp.ClassRequired = true;
			if ((f & 2) != 0)
				tp.ValueTypeRequired = true;
			if ((f & 4) != 0)
				tp.ConstructorRequired = true;

			// Variance 

			tp.Variance = (TypeParameterVariance)reader.ReadByte ();

			// Constraints
			
			uint count = ReadUInt (reader, 1000);
			while (count-- > 0)
				tp.AddConstraint (ReadReturnType (reader, nameTable));

			// Attributes
			
			count = ReadUInt (reader, 1000);
			while (count-- > 0)
				tp.AddAttribute (ReadAttribute (reader, nameTable));

			return tp;
		}

		static DomType ReadTypeInternal (BinaryReader reader, INameDecoder nameTable, IDomObjectTable objectTable)
		{
			uint typeCount = ReadUInt (reader, 1000);
			if (typeCount > 1) {
				CompoundType compoundResult = new CompoundType ();
				while (typeCount-- > 0) {
					compoundResult.AddPart (ReadTypeInternal (reader, nameTable, objectTable));
				}
				
				return compoundResult;
			}
			
			DomType result = new DomType ();
			ReadMemberInformation (reader, nameTable, objectTable, result);
			//			bool verbose = result.Name == "CopyDelegate";
			//			if (verbose) System.Console.WriteLine("read type:" + result.Name);
			result.TypeModifier = (TypeModifier)reader.ReadUInt32 ();
			result.BodyRegion = ReadRegion (reader, nameTable);
			string compilationUnitFileName = ReadString (reader, nameTable);
			result.CompilationUnit = new CompilationUnit (compilationUnitFileName);
			
			result.Namespace = ReadString (reader, nameTable);
			result.ClassType = (ClassType)reader.ReadUInt32 ();
			result.BaseType = ReadReturnType (reader, nameTable, objectTable);
			
			// implemented interfaces
			long count = ReadUInt (reader, 5000);
			//			if (verbose) System.Console.WriteLine("impl. interfaces:" + count);
			while (count-- > 0) {
				result.AddInterfaceImplementation (ReadReturnType (reader, nameTable, objectTable));
			}
			
			// innerTypes
			//			if (verbose) System.Console.WriteLine("pos:" + reader.BaseStream.Position);
			count = ReadUInt (reader, 10000);
			//			if (verbose) System.Console.WriteLine("inner types:" + count);
			while (count-- > 0) {
				DomType innerType = ReadTypeInternal (reader, nameTable, objectTable);
				innerType.DeclaringType = result;
				result.Add (innerType);
			}
			
			// fields
			//			if (verbose) System.Console.WriteLine("pos:" + reader.BaseStream.Position);
			count = ReadUInt (reader, 10000);
			//			if (verbose) System.Console.WriteLine("fields:" + count);
			while (count-- > 0) {
				DomField field = ReadField (reader, nameTable, objectTable);
				field.DeclaringType = result;
				result.Add (field);
			}
			
			// methods
			//			if (verbose) System.Console.WriteLine("pos:" + reader.BaseStream.Position);
			count = ReadUInt (reader, 10000);
			//			if (verbose) System.Console.WriteLine("methods:" + count);
			while (count-- > 0) {
				DomMethod method = ReadMethod (reader, nameTable, objectTable);
				method.DeclaringType = result;
				result.Add (method);
			}
			
			// properties
			//			if (verbose) System.Console.WriteLine("pos:" + reader.BaseStream.Position);
			count = ReadUInt (reader, 10000);
			//			if (verbose) System.Console.WriteLine("properties:" + count);
			while (count-- > 0) {
				DomProperty property = ReadProperty (reader, nameTable, objectTable);
				property.DeclaringType = result;
				result.Add (property);
			}
			
			// events
			//			if (verbose) System.Console.WriteLine("pos:" + reader.BaseStream.Position);
			count = ReadUInt (reader, 10000);
			//			if (verbose) System.Console.WriteLine("events:" + count);
			while (count-- > 0) {
				DomEvent evt = ReadEvent (reader, nameTable, objectTable);
				evt.DeclaringType = result;
				result.Add (evt);
			}
			
			// type parameters
			count = ReadUInt (reader, 500);
			while (count-- > 0) {
				TypeParameter tp = ReadTypeParameter (reader, nameTable, objectTable);
				result.AddTypeParameter (tp);
			}
			return result;
		}

        /// <summary>
        /// Reads the name of an element from the reader.
        /// </summary>
        /// <param name="nameDecoder">The name decoder.</param>
        /// <returns>
        /// The name of the element.
        /// </returns>
        public override string ReadName(INameDecoder nameDecoder)
        {
            if (nameDecoder == null)
            {
                throw new ArgumentNullException("nameDecoder");
            }

            if (Disposed) { ThrowObjectDisposedException(); }
            if (State == BsonReaderState.Type)
            {
                ReadBsonType();
            }
            if (State != BsonReaderState.Name)
            {
                ThrowInvalidState("ReadName", BsonReaderState.Name);
            }

            nameDecoder.Inform(CurrentName);
            State = BsonReaderState.Value;
            return CurrentName;
        }

		public static DomField ReadField (BinaryReader reader, INameDecoder nameTable, IDomObjectTable objectTable)
		{
			DomField result = new DomField ();
			ReadMemberInformation (reader, nameTable, objectTable, result);
			result.ReturnType = ReadReturnType (reader, nameTable, objectTable);
			return result;
		}

		static void ReadMemberInformation (BinaryReader reader, INameDecoder nameTable, IDomObjectTable objectTable, AbstractMember member)
		{
			member.Name          = ReadString (reader, nameTable);
			member.Documentation = ReadString (reader, nameTable);
			member.Modifiers     = (Modifiers)reader.ReadUInt32();
			member.Location      = ReadLocation (reader, nameTable);
			
			uint count = ReadUInt (reader, 1000);
			while (count-- > 0)
				member.Add (ReadAttribute (reader, nameTable, objectTable));
		}

		internal static List<AttributeEntry> ReadAttributeEntryList (BinaryReader reader, INameDecoder nameTable, IDomObjectTable objectTable)
		{
			List<AttributeEntry> list = new List<AttributeEntry> ();
			// Number of attributes
			int num = reader.ReadInt32 ();
			while (num-- > 0) {
				AttributeEntry e = new AttributeEntry ();
				e.File = ReadString (reader, nameTable);
				e.Attribute = ReadAttribute (reader, nameTable, objectTable);
				list.Add (e);
			}
			return list;
		}

		public static CodeExpression ReadExpression (BinaryReader reader, INameDecoder nameTable)
		{
			TypeCode code = (TypeCode)reader.ReadInt32 ();
			switch (code) {
			case TypeCode.DBNull:
				return new CodePrimitiveExpression (null);
			case TypeCode.Object:
				return (CodeExpression)serializer.Deserialize (reader, typeof(CodeExpression));
			default:
				return new CodePrimitiveExpression (Convert.ChangeType (ReadString (reader, nameTable), code, CultureInfo.InvariantCulture));
			}
		}

		public static TypeParameter ReadTypeParameter (BinaryReader reader, INameDecoder nameTable, IDomObjectTable objectTable)
		{
			string name = ReadString (reader, nameTable);
			TypeParameter tp = new TypeParameter (name);
			
			// Flags
			tp.TypeParameterModifier = (TypeParameterModifier)reader.ReadByte ();
			
			// Variance 

			tp.Variance = (TypeParameterVariance)reader.ReadByte ();
			
			// Constraints
			
			uint count = ReadUInt (reader, 1000);
			while (count-- > 0)
				tp.AddConstraint (ReadReturnType (reader, nameTable, objectTable));

			// Attributes
			
			count = ReadUInt (reader, 1000);
			while (count-- > 0)
				tp.AddAttribute (ReadAttribute (reader, nameTable, objectTable));

			return tp;
		}

		public static DomAttribute ReadAttribute (BinaryReader reader, INameDecoder nameTable, IDomObjectTable objectTable)
		{
			DomAttribute attr = new DomAttribute ();
			attr.Name = ReadString (reader, nameTable);
			attr.Region = ReadRegion (reader, nameTable);
			attr.AttributeTarget = (AttributeTarget)reader.ReadInt32 ();
			attr.AttributeType = ReadReturnType (reader, nameTable, objectTable);
			
			// Named argument count
			uint num = ReadUInt (reader, 500);
			string[] names = new string[num];
			for (int n=0; n<num; n++)
				names [n] = ReadString (reader, nameTable);
			
			CodeExpression[] exps = ReadExpressionArray (reader, nameTable);
			
			int i;
			for (i=0; i<num; i++)
				attr.AddNamedArgument (names [i], exps [i]);
			
			for (; i<exps.Length; i++)
				attr.AddPositionalArgument (exps [i]);

			return attr;
		}

		public static IReturnType ReadReturnType (BinaryReader reader, INameDecoder nameTable, IDomObjectTable objectTable)
		{
			if (ReadNull (reader))
				return null;
			byte index = reader.ReadByte ();
			if (index < 0xFF) 
				return DomReturnType.GetSharedReturnType (index);
			
			string ns = ReadString (reader, nameTable);
			List<ReturnTypePart> parts = new List<ReturnTypePart> ();
			
			uint partCount = ReadUInt (reader, 500);
			while (partCount-- > 0) {
				ReturnTypePart part = new ReturnTypePart ();
				parts.Add (part);
				part.Name = ReadString (reader, nameTable);
				part.IsGenerated = reader.ReadBoolean ();
				uint arguments  = ReadUInt (reader, 1000);
				while (arguments-- > 0)
					part.AddTypeParameter (ReadReturnType (reader, nameTable, objectTable));
			}
			
			DomReturnType result = new DomReturnType (ns, parts);
			result.PointerNestingLevel = reader.ReadInt32 ();
			result.IsNullable = reader.ReadBoolean ();
			result.IsByRef = reader.ReadBoolean ();
			
			int  arrayDimensions = reader.ReadInt32 ();
			int[] dims = new int [arrayDimensions];
			for (int n=0; n<arrayDimensions; n++)
				dims [n] = reader.ReadInt32 ();
			
			result.SetDimensions (dims);
			return objectTable != null ? (IReturnType) objectTable.GetSharedObject (result) : result;
		}