context: //
  // System.Web.Compilation.AspParser
  //
  // Authors:
  //	Gonzalo Paniagua Javier (gonzalo@ximian.com)
  //      Marek Habersack <mhabersack@novell.com>
  //
  // (C) 2002,2003 Ximian, Inc (http://www.ximian.com)
  // (C) 2004-2009 Novell, Inc (http://novell.com)
  //
  
  //
  // Permission is hereby granted, free of charge, to any person obtaining
  // a copy of this software and associated documentation files (the
  // "Software"), to deal in the Software without restriction, including
  // without limitation the rights to use, copy, modify, merge, publish,
  // distribute, sublicense, and/or sell copies of the Software, and to
  // permit persons to whom the Software is furnished to do so, subject to
  // the following conditions:
  // 
  // The above copyright notice and this permission notice shall be
  // included in all copies or substantial portions of the Software.
  // 
  // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  //
  using System;
  using System.ComponentModel;
  using System.Collections;
  using System.Globalization;
  using System.IO;
  using System.Text;
  using System.Web.Util;
  using System.Security.Cryptography;
  
  namespace System.Web.Compilation
  {
  	delegate void ParseErrorHandler (ILocation location, string message);
  	delegate void TextParsedHandler (ILocation location, string text);
  	delegate void TagParsedHandler (ILocation location, TagType tagtype, string id, TagAttributes attributes);
  	delegate void ParsingCompleteHandler ();
  	
  	class AspParser : ILocation
  	{
  		static readonly object errorEvent = new object ();
  		static readonly object tagParsedEvent = new object ();
  		static readonly object textParsedEvent = new object ();
  		static readonly object parsingCompleteEvent = new object();
  
  		MD5 checksum;
  		AspTokenizer tokenizer;
  		int beginLine, endLine;
  		int beginColumn, endColumn;
  		int beginPosition, endPosition;
  		string filename;
  		string verbatimID;
  		string fileText;
  		StringReader fileReader;
  		bool _internal;
  		int _internalLineOffset;
  		int _internalPositionOffset;
  		AspParser outer;
  		
  		EventHandlerList events = new EventHandlerList ();
  		
  		public event ParseErrorHandler Error {
  			add { events.AddHandler (errorEvent, value); }
  			remove { events.RemoveHandler (errorEvent, value); }
  		}
  		
  		public event TagParsedHandler TagParsed {
  			add { events.AddHandler (tagParsedEvent, value); }
  			remove { events.RemoveHandler (tagParsedEvent, value); }
  		}
  		
  		public event TextParsedHandler TextParsed {
  			add { events.AddHandler (textParsedEvent, value); }
  			remove { events.RemoveHandler (textParsedEvent, value); }
  		}
  
  		public event ParsingCompleteHandler ParsingComplete {
  			add { events.AddHandler (parsingCompleteEvent, value); }
  			remove { events.RemoveHandler (parsingCompleteEvent, value); }
  		}
  		
  		public AspParser (string filename, TextReader input)
  		{
  			this.filename = filename;
  			this.fileText = input.ReadToEnd ();
  			this.fileReader = new StringReader (this.fileText);
  			this._internalLineOffset = 0;
  			tokenizer = new AspTokenizer (this.fileReader);
  		}
  
  		public AspParser (string filename, TextReader input, int startLineOffset, int positionOffset, AspParser outer)
  			: this (filename, input)
  		{
  			this._internal = true;
  			this._internalLineOffset = startLineOffset;
  			this._internalPositionOffset = positionOffset;
  			this.outer = outer;
  		}
  		
  		public byte[] MD5Checksum {
  			get {
  				if (checksum == null)
  					return new byte[0];
  				
  				return checksum.Hash;
  			}
  		}
  
  		public int BeginPosition {
  			get { return beginPosition; }
  		}
  
  		public int EndPosition {
  			get { return endPosition; }
  		}
  		
  		public int BeginLine {
  			get {
  				if (_internal)
  					return beginLine + _internalLineOffset;
  
  				return beginLine;
  			}
  		}
  
  		public int BeginColumn {
  			get { return beginColumn; }
  		}
  
  		public int EndLine {
  			get {
  				if (_internal)
  					return endLine + _internalLineOffset;
  				return endLine;
  			}
  		}
  
  		public int EndColumn {
  			get { return endColumn; }
  		}
  
  		public string FileText {
  			get {
  				string ret = null;
  				
  				if (_internal && outer != null)
  				 	ret = outer.FileText;
  				
  				if (ret == null && fileText != null)
  					ret = fileText;
  				
  				return ret;
  			}
  		}
  		
  		public string PlainText {
  			get {
  				if (beginPosition >= endPosition || fileText == null)
  					return null;
  
  				string text = FileText;
  				int start, len;
  				
  				if (_internal && outer != null) {
  					start = beginPosition + _internalPositionOffset;
  					len = (endPosition + _internalPositionOffset) - start;
  				} else {
  					start = beginPosition;
  					len = endPosition - beginPosition;
  				}
  				
  				if (text != null)
  					return text.Substring (start, len);
  
  				return null;
  			}
  		}
  
  		public string Filename {
  			get {
  				if (_internal && outer != null)
  					return outer.Filename;
  				
  				return filename;
  			}
  		}
  
  		public string VerbatimID {
  			set {
  				tokenizer.Verbatim = true;
  				verbatimID = value;
  			}
  		}
  
  		bool Eat (int expected_token)
  		{
  			int token = tokenizer.get_token ();
  			if (token != expected_token) {
  				tokenizer.put_back ();
  				return false;
  			}
  
  			endLine = tokenizer.EndLine;
  			endColumn = tokenizer.EndColumn;
  			return true;
  		}
  
  		void BeginElement ()
  		{
  			beginLine = tokenizer.BeginLine;
  			beginColumn = tokenizer.BeginColumn;
  			beginPosition = tokenizer.Position - 1;
  		}
  
  		void EndElement ()
  		{
  			endLine = tokenizer.EndLine;
  			endColumn = tokenizer.EndColumn;
  			endPosition = tokenizer.Position;
  		}
  
  		public void Parse ()
  		{
  			if (tokenizer == null) {
  				OnError ("AspParser not initialized properly.");
  				return;
  			}
  			
  			int token;
  			string id;
  			TagAttributes attributes;
  			TagType tagtype = TagType.Text;
  			StringBuilder text =  new StringBuilder ();
  
  			try {
  				while ((token = tokenizer.get_token ()) != Token.EOF) {
  					BeginElement ();
  
  					if (tokenizer.Verbatim){
  						string end_verbatim = "</" + verbatimID + ">";
  						string verbatim_text = GetVerbatim (token, end_verbatim);
  
  						if (verbatim_text == null)
  							OnError ("Unexpected EOF processing " + verbatimID);
  
  						tokenizer.Verbatim = false;
  
  						EndElement ();
  						endPosition -= end_verbatim.Length;
  						OnTextParsed (verbatim_text);
  						beginPosition = endPosition;
  						endPosition += end_verbatim.Length;
  						OnTagParsed (TagType.Close, verbatimID, null);
  						continue;
  					}
  				
  					if (token == '<') {
  						GetTag (out tagtype, out id, out attributes);
  						EndElement ();
  						if (tagtype == TagType.ServerComment)
  							continue;
  
  						if (tagtype == TagType.Text)
  							OnTextParsed (id);
  						else
  							OnTagParsed (tagtype, id, attributes);
  
  						continue;
  					}
  
  					if (tokenizer.Value.Trim ().Length == 0 && tagtype == TagType.Directive) {
  						continue;
  					}
  
  					text.Length = 0;
  					do {
  						text.Append (tokenizer.Value);
  						token = tokenizer.get_token ();
  					} while (token != '<' && token != Token.EOF);
  
  					tokenizer.put_back ();
  					EndElement ();
  					OnTextParsed (text.ToString ());
  				}
  			} finally {
  				if (fileReader != null) {
  					fileReader.Close ();
  					fileReader = null;
  				}
  				checksum = tokenizer.Checksum;
  				tokenizer = null;
  			}
  
  			OnParsingComplete ();
  		}
  
  		bool GetInclude (string str, out string pathType, out string filename)
  		{
  			pathType = null;
  			filename = null;
  			str = str.Substring (2).Trim ();
  			int len = str.Length;
  			int lastQuote = str.LastIndexOf ('"');
  			if (len < 10 || lastQuote != len - 1)
  				return false;
  
  			if (!StrUtils.StartsWith (str, "#include ", true))
  				return false;
  
  			str = str.Substring (9).Trim ();
  			bool isfile = (StrUtils.StartsWith (str ,"file", true));
  			if (!isfile && !StrUtils.StartsWith (str, "virtual", true))
  				return false;
  
  			pathType = (isfile) ? "file" : "virtual";
  			if (str.Length < pathType.Length + 3)
  				return false;
  
  			str = str.Substring (pathType.Length).Trim ();
  			if (str.Length < 3 || str [0] != '=')
  				return false;
  
  			int index = 1;
  			for (; index < str.Length; index++) {
  				if (Char.IsWhiteSpace (str [index]))
  					continue;
  				else if (str [index] == '"')
  					break;
  			}
  
  			if (index == str.Length || index == lastQuote)
  				return false;
  
  			str = str.Substring (index);
  			if (str.Length == 2) { // only quotes
  				OnError ("Empty file name.");
  				return false;
  			}
  
  			filename = str.Trim ().Substring (index, str.Length - 2);
  			if (filename.LastIndexOf  ('"') != -1)
  				return false; // file=""" -> no error
  
  			return true;
  		}
  
  		void GetTag (out TagType tagtype, out string id, out TagAttributes attributes)
  		{
  			int token = tokenizer.get_token ();
  
  			tagtype = TagType.ServerComment;
  			id = null;
  			attributes = null;
  			switch (token){
  			case '%':
  				GetServerTag (out tagtype, out id, out attributes);
  				break;
  			case '/':
  				if (!Eat (Token.IDENTIFIER))
  					OnError ("expecting TAGNAME");
  
  				id = tokenizer.Value;
  				if (!Eat ('>'))
  					OnError ("expecting '>'. Got '" + id + "'");
  
  				tagtype = TagType.Close;
  				break;
  			case '!':
  				bool double_dash = Eat (Token.DOUBLEDASH);
  				if (double_dash)
  					tokenizer.put_back ();
  
  				tokenizer.Verbatim = true;
  				string end = double_dash ? "-->" : ">";
  				string comment = GetVerbatim (tokenizer.get_token (), end);
  				tokenizer.Verbatim = false;
  				if (comment == null)
  					OnError ("Unfinished HTML comment/DTD");
  
  				string pathType, filename;
  				if (double_dash && GetInclude (comment, out pathType, out filename)) {
  					tagtype = TagType.Include;
  					attributes = new TagAttributes ();
  					attributes.Add (pathType, filename);
  				} else {
  					tagtype = TagType.Text;
  					id = "<!" + comment + end;
  				}
  				break;
  			case Token.IDENTIFIER:
  				if (this.filename == "@@inner_string@@") {
  					// Actually not tag but "xxx < yyy" stuff in inner_string!
  					tagtype = TagType.Text;
  					tokenizer.InTag = false;
  					id = "<" + tokenizer.Odds + tokenizer.Value;
  				} else {
  					id = tokenizer.Value;
  					try {
  						attributes = GetAttributes ();
  					} catch (Exception e) {
  						OnError (e.Message);
  						break;
  					}
  					
  					tagtype = TagType.Tag;
  					if (Eat ('/') && Eat ('>')) {
  						tagtype = TagType.SelfClosing;
  					} else if (!Eat ('>')) {
  						if (attributes.IsRunAtServer ()) {
  							OnError ("The server tag is not well formed.");
  							break;
  						}
  						tokenizer.Verbatim = true;
  						attributes.Add (String.Empty, GetVerbatim (tokenizer.get_token (), ">") + ">");
  						tokenizer.Verbatim = false;
  					}
  				}
  
  				break;
  			default:
  				string idvalue = null;
  				// This is to handle code like:
  				//
  				//  <asp:ListItem runat="server"> < </asp:ListItem>
  				//
  				if ((char)token == '<') {
  					string odds = tokenizer.Odds;
  					if (odds != null && odds.Length > 0 && Char.IsWhiteSpace (odds [0])) {
  						tokenizer.put_back ();
  						idvalue = odds;
  					} else
  						idvalue = tokenizer.Value;
  				} else
  					idvalue = tokenizer.Value;
  				
  				tagtype = TagType.Text;
  				tokenizer.InTag = false;
  				id = "<" + idvalue;
  				break;
  			}
  		}
  
  		TagAttributes GetAttributes ()
  		{
  			int token;
  			TagAttributes attributes;
  			string id;
  			bool wellFormedForServer = true;
  
  			attributes = new TagAttributes ();
  			while ((token = tokenizer.get_token ()) != Token.EOF){
  				if (token == '<' && Eat ('%')) {
  					tokenizer.Verbatim = true;
  					attributes.Add (String.Empty, "<%" + 
  							GetVerbatim (tokenizer.get_token (), "%>") + "%>");
  					tokenizer.Verbatim = false;
  					tokenizer.InTag = true;
  					continue;
  				}
  					
  				if (token != Token.IDENTIFIER)
  					break;
  
  				id = tokenizer.Value;
  				if (Eat ('=')){
  					if (Eat (Token.ATTVALUE)){
  						attributes.Add (id, tokenizer.Value);
  						wellFormedForServer &= tokenizer.AlternatingQuotes;
  					} else if (Eat ('<') && Eat ('%')) {
  						tokenizer.Verbatim = true;
  						attributes.Add (id, "<%" + 
  								GetVerbatim (tokenizer.get_token (), "%>") + "%>");
  						tokenizer.Verbatim = false;
  						tokenizer.InTag = true;
  					} else {
  						OnError ("expected ATTVALUE");
  						return null;
  					}
  				} else {
  					attributes.Add (id, null);
  				}
  			}
  
  			tokenizer.put_back ();
  
  			if (attributes.IsRunAtServer () && !wellFormedForServer) {
  				OnError ("The server tag is not well formed.");
  				return null;
  			}
  			
  			return attributes;
  		}
  
  		string GetVerbatim (int token, string end)
  		{
  			StringBuilder vb_text = new StringBuilder ();
  			StringBuilder tmp = new StringBuilder ();
  			int i = 0;
  
  			if (tokenizer.Value.Length > 1){
  				// May be we have a put_back token that is not a single character
  				vb_text.Append (tokenizer.Value);
  				token = tokenizer.get_token ();
  			}
  
  			end = end.ToLower (Helpers.InvariantCulture);
  			int repeated = 0;
  			for (int k = 0; k < end.Length; k++)
  				if (end [0] == end [k])
  					repeated++;
  			
  			while (token != Token.EOF){
  				if (Char.ToLower ((char) token, Helpers.InvariantCulture) == end [i]){
  					if (++i >= end.Length)
  						break;
  					tmp.Append ((char) token);
  					token = tokenizer.get_token ();
  					continue;
  				} else if (i > 0) {
  					if (repeated > 1 && i == repeated && (char) token == end [0]) {
  						vb_text.Append ((char) token);
  						token = tokenizer.get_token ();
  						continue;
  					}
  					vb_text.Append (tmp.ToString ());
  					tmp.Remove (0, tmp.Length);
  					i = 0;
  				}
  
  				vb_text.Append ((char) token);
  				token = tokenizer.get_token ();
  			} 
  
  			if (token == Token.EOF)
  				OnError ("Expecting " + end + " and got EOF.");
  
  			return RemoveComments (vb_text.ToString ());
  		}
  
  		string RemoveComments (string text)
  		{
  			int end;
  			int start = text.IndexOf ("<%--");
  
  			while (start != -1) {
  				end = text.IndexOf ("--%>");
  				if (end == -1 || end <= start + 1)
  					break;
  
  				text = text.Remove (start, end - start + 4);
  				start = text.IndexOf ("<%--");
  			}
  
  			return text;
  		}
  
  		void GetServerTag (out TagType tagtype, out string id, out TagAttributes attributes)
  		{
  			string inside_tags;
  			bool old = tokenizer.ExpectAttrValue;
  
  			tokenizer.ExpectAttrValue = false;
  			if (Eat ('@')){
  				tokenizer.ExpectAttrValue = old;
  				tagtype = TagType.Directive;
  				id = "";
  				if (Eat (Token.DIRECTIVE))
  					id = tokenizer.Value;
  
  
gt: 				attributes = GetAttributes ();