aspclassic-core/AspClassic.Parser/TokenXmlSerializer.cs

using System.Collections.Generic;
using System.Runtime.CompilerServices;
using System.Xml;
using Microsoft.VisualBasic.CompilerServices;

namespace AspClassic.Parser;

public class TokenXmlSerializer
{
	private readonly XmlWriter Writer;

	[SpecialName]
	private Dictionary<TypeCharacter, string> _0024STATIC_0024Serialize_002420111182E4_0024TypeCharacterTable;

	public TokenXmlSerializer(XmlWriter Writer)
	{
		this.Writer = Writer;
	}

	private void Serialize(Span Span)
	{
		Writer.WriteAttributeString("startLine", Conversions.ToString(Span.Start.Line));
		Writer.WriteAttributeString("startCol", Conversions.ToString(Span.Start.Column));
		Writer.WriteAttributeString("endLine", Conversions.ToString(Span.Finish.Line));
		Writer.WriteAttributeString("endCol", Conversions.ToString(Span.Finish.Column));
	}

	private void Serialize(TypeCharacter TypeCharacter)
	{
		if (TypeCharacter == TypeCharacter.None)
		{
			return;
		}
		if (_0024STATIC_0024Serialize_002420111182E4_0024TypeCharacterTable == null)
		{
			Dictionary<TypeCharacter, string> Table = new Dictionary<TypeCharacter, string>();
			string[] TypeCharacters = new string[15]
			{
				"$", "%", "&", "S", "I", "L", "!", "#", "@", "F",
				"R", "D", "US", "UI", "UL"
			};
			TypeCharacter TableTypeCharacter = TypeCharacter.StringSymbol;
			int num = checked(TypeCharacters.Length - 1);
			for (int Index = 0; Index <= num; Index = checked(Index + 1))
			{
				Table.Add(TableTypeCharacter, TypeCharacters[Index]);
				TableTypeCharacter = (TypeCharacter)((int)TableTypeCharacter << 1);
			}
			_0024STATIC_0024Serialize_002420111182E4_0024TypeCharacterTable = Table;
		}
		Writer.WriteAttributeString("typeChar", _0024STATIC_0024Serialize_002420111182E4_0024TypeCharacterTable[TypeCharacter]);
	}

	public void Serialize(Token Token)
	{
		Writer.WriteStartElement(Token.Type.ToString());
		Serialize(Token.Span);
		switch (Token.Type)
		{
		case TokenType.LexicalError:
		{
			ErrorToken errorToken = (ErrorToken)Token;
			Writer.WriteAttributeString("errorNumber", Conversions.ToString((int)errorToken.SyntaxError.Type));
			Writer.WriteString(errorToken.SyntaxError.ToString());
			errorToken = null;
			break;
		}
		case TokenType.Comment:
		{
			CommentToken commentToken = (CommentToken)Token;
			Writer.WriteAttributeString("isRem", Conversions.ToString(commentToken.IsREM));
			Writer.WriteString(commentToken.Comment);
			commentToken = null;
			break;
		}
		case TokenType.Identifier:
		{
			IdentifierToken identifierToken = (IdentifierToken)Token;
			Writer.WriteAttributeString("escaped", Conversions.ToString(identifierToken.Escaped));
			Serialize(identifierToken.TypeCharacter);
			Writer.WriteString(identifierToken.Identifier);
			identifierToken = null;
			break;
		}
		case TokenType.StringLiteral:
		{
			StringLiteralToken stringLiteralToken = (StringLiteralToken)Token;
			Writer.WriteString(stringLiteralToken.Literal);
			stringLiteralToken = null;
			break;
		}
		case TokenType.CharacterLiteral:
		{
			CharacterLiteralToken characterLiteralToken = (CharacterLiteralToken)Token;
			Writer.WriteString(Conversions.ToString(characterLiteralToken.Literal));
			characterLiteralToken = null;
			break;
		}
		case TokenType.DateLiteral:
		{
			DateLiteralToken dateLiteralToken = (DateLiteralToken)Token;
			Writer.WriteString(Conversions.ToString(dateLiteralToken.Literal));
			dateLiteralToken = null;
			break;
		}
		case TokenType.IntegerLiteral:
		{
			IntegerLiteralToken integerLiteralToken = (IntegerLiteralToken)Token;
			Writer.WriteAttributeString("base", integerLiteralToken.IntegerBase.ToString());
			Serialize(integerLiteralToken.TypeCharacter);
			Writer.WriteString(Conversions.ToString(integerLiteralToken.Literal));
			integerLiteralToken = null;
			break;
		}
		case TokenType.FloatingPointLiteral:
		{
			FloatingPointLiteralToken floatingPointLiteralToken = (FloatingPointLiteralToken)Token;
			Serialize(floatingPointLiteralToken.TypeCharacter);
			Writer.WriteString(Conversions.ToString(floatingPointLiteralToken.Literal));
			floatingPointLiteralToken = null;
			break;
		}
		case TokenType.DecimalLiteral:
		{
			DecimalLiteralToken decimalLiteralToken = (DecimalLiteralToken)Token;
			Serialize(decimalLiteralToken.TypeCharacter);
			Writer.WriteString(Conversions.ToString(decimalLiteralToken.Literal));
			decimalLiteralToken = null;
			break;
		}
		case TokenType.UnsignedIntegerLiteral:
		{
			UnsignedIntegerLiteralToken unsignedIntegerLiteralToken = (UnsignedIntegerLiteralToken)Token;
			Serialize(unsignedIntegerLiteralToken.TypeCharacter);
			Writer.WriteString(Conversions.ToString(unsignedIntegerLiteralToken.Literal));
			unsignedIntegerLiteralToken = null;
			break;
		}
		}
		Writer.WriteEndElement();
	}

	public void Serialize(Token[] Tokens)
	{
		foreach (Token Token in Tokens)
		{
			Serialize(Token);
		}
	}
}