private void ConfigError (IXmlLineInfo lineInfo, string message, params object [] args)
 {
     Console.Error.WriteLine ("Analyzer Configuration Error: {0} ({1}:{2},{3})",
         String.Format (message, args), configuration_path,
         lineInfo.LineNumber, lineInfo.LinePosition);
     throw new Exception ();
 }

 internal XmlException(string res, string[] args,  IXmlLineInfo lineInfo) {
     HResult = HResults.Xml;
     this.res = res;
     this.args = args;
     this.lineNumber = null == lineInfo ? 0 : lineInfo.LineNumber;
     this.linePosition = null == lineInfo ? 0 : lineInfo.LinePosition;
 }

 public XPathDocumentBuilder(XPathDocument doc, IXmlLineInfo lineInfo, string baseUri, XPathDocument.LoadFlags flags)
 {
     this.nodePageFact.Init(0x100);
     this.nmspPageFact.Init(0x10);
     this.stkNmsp = new Stack<XPathNodeRef>();
     this.Initialize(doc, lineInfo, baseUri, flags);
 }

      protected virtual Exception CreateParseException(IXmlLineInfo lineInfo, string format, params object[] args) {

         if (lineInfo != null && lineInfo.HasLineInfo())
            return new HttpParseException(String.Format(CultureInfo.InvariantCulture, format, args), null, this.VirtualPath, null, lineInfo.LineNumber);
         else
            return new HttpParseException(String.Format(CultureInfo.InvariantCulture, format, args));
      }

		// Return false if there is already the same key.
		public bool SetIdentityField (object identity, bool isXsiNil, XsdAnySimpleType type, int depth, IXmlLineInfo li)
		{
			FieldFoundDepth = depth;
			Identity = identity;
			IsXsiNil = isXsiNil;
			FieldFound |= isXsiNil;
			FieldType = type;
			Consuming = false;
			Consumed = true;
			if (li != null && li.HasLineInfo ()) {
				FieldHasLineInfo = true;
				FieldLineNumber = li.LineNumber;
				FieldLinePosition = li.LinePosition;
			}

			if (!(this.entry.OwnerSequence.SourceSchemaIdentity is XmlSchemaKeyref)) {
				for (int i = 0; i < entry.OwnerSequence.FinishedEntries.Count; i++) {
					XsdKeyEntry other = (XsdKeyEntry) entry.OwnerSequence.FinishedEntries [i];
					if (this.entry.CompareIdentity (other))
						return false;
				}
			}

			return true;
		}

		private NvdlReader (XmlReader reader)
		{
			// FIXME: use .rnc validation.
			this.reader = reader;
			this.lineInfo = reader as IXmlLineInfo;
			reader.MoveToContent ();
		}

        static Color? ParseColor(IXmlLineInfo lineInfo, string color)
        {
            if (string.IsNullOrEmpty(color))
                return null;

            return ColorConverter.ConvertFromString(color);
        }

 static Exception Error(IXmlLineInfo lineInfo, string message)
 {
     if (lineInfo != null)
         return new HighlightingDefinitionInvalidException(HighlightingLoader.FormatExceptionMessage(message, lineInfo.LineNumber, lineInfo.LinePosition));
     else
         return new HighlightingDefinitionInvalidException(message);
 }

		public NvdlFilteredXmlReader (XmlReader reader,
			NvdlValidateInterp validate)
		{
			this.reader = reader;
			reader_as_line_info = reader as IXmlLineInfo;
			this.validate = validate;
		}

 private void SetLineInfo(IXmlLineInfo lineInfo, SearchResult searchResult)
 {
     if(lineInfo.HasLineInfo())
     {
         searchResult.LineNumber = lineInfo.LineNumber;
         searchResult.LinePosition = lineInfo.LinePosition;
     }
 }

        private static string WrapMessage(IXmlLineInfo lineInfo, string message, Exception innerException)
        {
            if (innerException == null)
                return string.Format("{0} (line: {1}, col: {2})", message, lineInfo.LineNumber, lineInfo.LinePosition);

            return string.Format("{0} (line: {1}, col: {2}): [{3}] {4}", message, lineInfo.LineNumber,
                                 lineInfo.LinePosition, innerException.GetType().Name, innerException.Message);
        }

        public Attribute(string name, IXmlLineInfo lineInfo)
        {
            this.name = name;

            _hasLineInfo = lineInfo.HasLineInfo();
            _lineNumber = lineInfo.LineNumber;
            _linePosition = lineInfo.LinePosition;
        }

//Constructor
        internal XsdCachingReader(XmlReader reader, IXmlLineInfo lineInfo, CachingEventHandler handlerMethod) {
            this.coreReader = reader;
            this.lineInfo = lineInfo;
            this.cacheHandler = handlerMethod;
            attributeEvents = new ValidatingReaderNodeData[InitialAttributeCount];
            contentEvents = new ValidatingReaderNodeData[InitialContentCount];
            Init();
        }

 internal XsdCachingReader(XmlReader reader, IXmlLineInfo lineInfo, CachingEventHandler handlerMethod)
 {
     this.coreReader = reader;
     this.lineInfo = lineInfo;
     this.cacheHandler = handlerMethod;
     this.attributeEvents = new ValidatingReaderNodeData[8];
     this.contentEvents = new ValidatingReaderNodeData[4];
     this.Init();
 }

		/// <summary>
		/// Loads the XML document from the specified <see cref="XmlReader"/>.
		/// </summary>
		public override void Load(XmlReader reader)
		{
			lineInfo = reader as IXmlLineInfo;
			try {
				base.Load(reader);
			} finally {
				lineInfo = null;
			}
		}

        public XmlReaderProxy(XmlReader xmlreader, Uri baseUri, IXmlLineInfo lineNumberService)
        {
            Debug.Assert(xmlreader != null, "xmlreader != null");
            Debug.Assert(baseUri != null, "baseUri != null");

            _proxy = xmlreader;
            _baseUri = baseUri;
            _lineNumberService = lineNumberService;
        }

		static string BuildMessage (string message, IXmlLineInfo li, string sourceUri)
		{
			if (li != null && li.HasLineInfo ()) {
				message = String.Format ("{0}. Location: {1} ({2}, {3}).", message, sourceUri, li.LineNumber, li.LinePosition);
			}
			else if (sourceUri != null)
				message = String.Format ("{0}. Location: {1}", message, sourceUri);
			return message;
		}

        /// <summary>
        /// Create a new XPathDocumentBuilder which creates nodes in "doc".
        /// </summary>
        public XPathDocumentBuilder(XPathDocument doc, IXmlLineInfo lineInfo, string baseUri, XPathDocument.LoadFlags flags) {
            // Allocate the initial node (for non-namespaces) page, and the initial namespace page
            this.nodePageFact.Init(256);
            this.nmspPageFact.Init(16);

            this.stkNmsp = new Stack<XPathNodeRef>();

            Initialize(doc, lineInfo, baseUri, flags);
        }

 internal PositionXmlAttribute(string prefix, string localName, string namespaceURI, XmlDocument doc, IXmlLineInfo lineInfo)
     : base(prefix, localName, namespaceURI, doc)
 {
     if (lineInfo != null) {
         this.lineNumber = lineInfo.LineNumber;
         this.linePosition = lineInfo.LinePosition;
         this.hasLineInfo = true;
     }
 }

        public override void Load(XmlReader reader)
        {
            if (reader is IXmlLineInfo)
                lineInfo = (IXmlLineInfo)reader;

            base.Load(reader);

            lineInfo = null;
        }