ELK/FrameworkLocal/UICore/DxfScript/Script/StringReader.cs

/**
 *
 * @author    seagle
 * @date      2024-7-10
 * @Description 从字符串中读取关键字
 */
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace MECF.Framework.UI.Core.DxfScript
{
    public class StringReader
    {
		private static readonly char CH_ROUND_LEFT = '(';
		private static readonly char CH_ROUND_RIGHT = ')';
        private static readonly char CH_BRACE_LEFT = '{';
        private static readonly char CH_BRACE_RIGHT = '}';
        private static readonly char CH_PLUS = '+';
        private static readonly char CH_MINUS = '-';
        private static readonly char CH_MULTIPLE = '*';
        private static readonly char CH_DEVIDE = '/';
        private static readonly char CH_CHANGE = '\\';
        private static readonly char CH_EQUAL = '=';
        private static readonly char CH_EXCLAM = '!';
        private static readonly char CH_WAVE = '~';
        private static readonly char CH_GT = '>';
        private static readonly char CH_LT = '<';
        private static readonly char CH_DOT = '.';
        private static readonly char CH_AND = '&';
        private static readonly char CH_OR = '|';
        private static readonly char CH_COMMA = ',';
        private static readonly char CH_SEP = ';';
        private static readonly char CH_QUOT = '"';

        private string scriptData;
        private KeywordType lastKwType;
        public int __line__;
		private int scriptLength = 0;
		private int scriptOffset = 0;
		private string buffer;
        public StringReader(string scriptData)
        {
            this.scriptData = scriptData;
			if( scriptData == null)
            {
				this.scriptData = "";
            }
            __line__ = 1;
			scriptLength = scriptData.Length;
			scriptOffset = 0;
			buffer = "";
			lastKwType = KeywordType.KW_INVALID;

		}
		private static char EOF = (char)0xffff;
		private char Getc()
        {
            if (scriptData == null)
            {
				return EOF;
            }
			if(scriptOffset >= scriptLength)
            {
				return EOF;
            }
			char ch = scriptData[scriptOffset++];
			return ch;
        }
		private void UnGetc()
		{
			if (scriptData == null)
			{
				return ;
			}
			if (scriptOffset > scriptLength)
			{
				return ;
			}
            if (scriptOffset <=0)
            {
				return;
            }
			scriptOffset--;
		
		}
		private bool Eof()
        {
			if (scriptData == null) return true;
			return scriptOffset >= scriptLength;
        }
        private bool isAlpha(char ch)
        {
            if (ch >= 'a' && ch <= 'z')
            {
                return true;
            }
            else if (ch >= 'A' && ch <= 'Z')
            {
                return true;
            }
            else if (ch >= '0' && ch <= '9')
            {
                return true;
            }
            else if (ch == '_')
            {
                return true;
            }
            return false;
        }
        public void rollback(KeywordType kwType)
        {
            lastKwType = kwType;
        }

        public KeywordType Next()
        {
			if (lastKwType != KeywordType.KW_INVALID)
			{
				KeywordType retKwType = lastKwType;
				lastKwType = KeywordType.KW_INVALID;
				return retKwType;
			}
			if (Eof())
			{
				return KeywordType.KW_EOF;
			}
			
			char ch;
			while ((ch = Getc()) != EOF)
			{
				if (ch == ' ' || ch == '\t' || ch == 0x0d)
				{
					continue;
				}
				if (ch == 0x0a)
				{
					__line__++;
					continue;
				}
				if (ch == EOF)
				{
					return KeywordType.KW_EOF;
				}
				else if (ch == CH_DEVIDE)
				{
					char ch2 = Getc();
					if (ch2 == CH_DEVIDE)
					{
						char ch3;
						while ((ch3 = Getc()) != EOF)
						{
							if (ch3 == 0x0a)
							{
								__line__++;
								break;
							}
						}
						if (ch3 == EOF)
						{
							return KeywordType.KW_EOF;
						}
						else
						{
							continue;
						}
					}
					else if (ch2 == CH_MULTIPLE)
					{
						char ch3;
						while ((ch3 = Getc()) != EOF)
						{
							if (ch3 == 0x0a)
							{
								__line__++;
							}
							else if (ch3 == CH_MULTIPLE)
							{
								char ch4 = Getc();
								if (ch4 == CH_DEVIDE)
								{
									break;
								}
								else if (ch4 == 0x0a)
								{
									__line__++;
								}

							}
						}
						if (ch3 == EOF)
						{
							return KeywordType.KW_EOF;
						}
						else
						{
							continue;
						}

					}
					else
					{
						//real devide
						UnGetc();
						buffer = CH_DEVIDE.ToString();
						return KeywordType.KW_OPERATOR_DEVIDE;
					}
				}
				else if (ch == CH_SEP)
				{
					buffer = CH_SEP.ToString();
					return KeywordType.KW_SEP;
				}
				else if (ch == CH_QUOT)
				{
					buffer = "";
					char ch2;
					while ((ch2 = Getc())!= EOF)
					{
						if (ch2 == CH_QUOT)
						{
							return KeywordType.KW_CONST_STRING;
						}
						else if (ch2 == CH_CHANGE)
						{
							char ch3 = Getc();
							if (ch3 == EOF)
							{
								return KeywordType.KW_INVALID;
							}
							else if (ch3 == CH_QUOT)
							{
								buffer+= ch3.ToString();
							}
							else if (ch3 == 'n')
							{

								buffer += "\n";
							}
							else if (ch3 == 't')
							{
								
								buffer+= '\t';
							}
							else if (ch3 == '\\')
							{
								
								buffer+= ch3.ToString();
							}
							else
							{
								return KeywordType.KW_INVALID;
							}
						}
						else if (ch2 == 0x0a)
						{
							return KeywordType.KW_INVALID;
						}
						else
						{
							
							buffer+= ch2.ToString();
						}
					}
					return KeywordType.KW_INVALID;
				}
				else if (ch == CH_PLUS)
				{
					buffer = ch.ToString();
					return KeywordType.KW_OPERATOR_PLUS;
				}
				else if (ch == CH_MULTIPLE)
				{
					buffer = ch.ToString();
					return KeywordType.KW_OPERATOR_MULTIPLE;
				}
				else if (ch == CH_MINUS)
				{
					char ch_last = buffer[0];
					if (ch_last == CH_ROUND_RIGHT || isAlpha(ch_last))
					{
						buffer= ch.ToString();
						return KeywordType.KW_OPERATOR_MINUS;
					}
					else
					{
						buffer = ch.ToString();
						return KeywordType.KW_OPERATOR_NEGATIVE;
					}
				}
				else if (ch == CH_COMMA)
				{
					buffer = ch.ToString();
					return KeywordType.KW_OPERATOR_COMMA;
				}
				else if (ch >= '0' && ch <= '9')
				{
					char ch2;
					bool hexFlag = false;
					bool dotFlag = false;
					buffer = ch.ToString();
					
					while ((ch2 = Getc()) != EOF)
					{
						if (ch2 == 'x' || ch2 == 'X')
						{
							if (buffer.Equals("0") && !hexFlag)
							{
								hexFlag = true;
								
								buffer="";
							}
							else
							{
								return KeywordType.KW_INVALID;
							}
						}
						else if (ch2 == CH_DOT)
						{
							if (!dotFlag)
							{
								dotFlag = true;
								buffer += ch2.ToString();
								
							}
							else
							{
								return KeywordType.KW_INVALID;
							}
						}
						else if (ch2 >= '0' && ch2 <= '9')
						{
							buffer += ch2.ToString();
						}
						else if (ch2 >= 'a' && ch2 <= 'f')
						{
							
							
							if (hexFlag)
							{
								buffer+= ch2.ToString();
							}
							else
							{
								return KeywordType.KW_INVALID;
							}
							
						}
						else if (ch2 >= 'A' && ch2 <= 'F')
						{
							if (hexFlag)
							{
								buffer += ch2.ToString();
							}
							else
							{
								return KeywordType.KW_INVALID;
							}
						}
						else
						{
							UnGetc();
							if (hexFlag && dotFlag)
							{
								return KeywordType.KW_INVALID;
							}
							else if (dotFlag)
							{
								return KeywordType.KW_CONST_DECIMAL;
							}
							else
							{
								if (hexFlag && buffer.Length<3)
								{
									return KeywordType.KW_INVALID;
								}
                                if (hexFlag)
                                {
									buffer = ""+int.Parse(buffer, System.Globalization.NumberStyles.HexNumber);
                                }
								return KeywordType.KW_CONST_INTEGER;
							}
						}
					}
					return KeywordType.KW_INVALID;
				}
				else if (isAlpha(ch))
				{
					char ch2;
					buffer = ch.ToString();
					bool dotFlag = false;
					while ((ch2 = Getc()) != EOF)
					{
						if (isAlpha(ch2))
						{
							buffer+= ch2.ToString();
						}
						else if (ch2 == CH_DOT)
						{
							buffer += ch2.ToString();
							dotFlag = true;
						}
						else
						{
							UnGetc();
							if (buffer.ToLower().Equals("on") ||
								buffer.ToLower().Equals("true"))
							{
								return KeywordType.KW_CONST_TRUE;
							}
							else if (buffer.ToLower().Equals("off") ||
								buffer.ToLower().Equals("false"))
							{
								return KeywordType.KW_CONST_FALSE;
							}
							else if (buffer.ToLower().Equals("if"))
							{
								return KeywordType.KW_IF;
							}
							else if (buffer.ToLower().Equals("else"))
							{
								return KeywordType.KW_ELSE;
							}else if(buffer.ToLower().Equals("return"))
							{
								return KeywordType.KW_RETURN;
							}
							else if (buffer.ToLower().Equals( "when"))
							{
								return KeywordType.KW_WHEN;
							}
							else if (buffer.ToLower().Equals( "for"))
							{
								return KeywordType.KW_FOR;
							}
							else if (ch2 == CH_ROUND_LEFT)
							{
								return KeywordType.KW_FUNCTION;
							}
							else
							{
								return KeywordType.KW_VARIABLE;
							}
						}
					}
					return KeywordType.KW_INVALID;
				}
				else if (ch == CH_GT)
				{
					char ch2 = Getc();
					if (ch2 == EOF)
					{
						return KeywordType.KW_INVALID;
					}
					else if (ch2 == CH_GT)
					{
						buffer = ">>";
						return KeywordType.KW_OPERATOR_MOVE_RIGHT;
					}
					else if (ch2 == CH_EQUAL)
					{
						buffer = ">=";
						return KeywordType.KW_OPERATOR_GE;
					}
					else
					{
						buffer = ">";
						UnGetc();
						return KeywordType.KW_OPERATOR_GT;
					}
				}
				else if (ch == CH_LT)
				{
					char ch2 = Getc();
					if (ch2 == EOF)
					{
						return KeywordType.KW_INVALID;
					}
					else if (ch2 == CH_LT)
					{
						buffer = "<<";
						return KeywordType.KW_OPERATOR_MOVE_LEFT;
					}
					else if (ch2 == CH_EQUAL)
					{
						buffer = "<=";
						return KeywordType.KW_OPERATOR_LE;
					}
					else
					{
						buffer = "<";
						UnGetc();
						return KeywordType.KW_OPERATOR_LT;
					}
				}
				else if (ch == CH_EXCLAM)
				{
					char ch2 = Getc();
					if (ch2 == EOF)
					{
						return KeywordType.KW_INVALID;
					}
					else if (ch2 == CH_EQUAL)
					{
						buffer = "!=";
						return KeywordType.KW_OPERATOR_NOT_EQUAL;
					}
					else
					{
						buffer = "!";
						return KeywordType.KW_OPERATOR_NOT;
					}
				}
				else if (ch == CH_EQUAL)
				{
					char ch2 = Getc();
					if (ch2 == EOF)
					{
						return KeywordType.KW_INVALID;
					}
					else if (ch2 == CH_EQUAL)
					{
						buffer = "==";
						return KeywordType.KW_OPERATOR_EQUAL;
					}
					else
					{
						buffer = "=";
						UnGetc();
						return KeywordType.KW_SET;
					}

				}
				else if (ch == CH_AND)
				{
					char ch2 = Getc();
					if (ch2 == EOF)
					{
						return KeywordType.KW_INVALID;
					}
					else if (ch2 == CH_AND)
					{
						buffer = "&&";
						return KeywordType.KW_OPERATOR_AND;
					}
					else
					{
						buffer = "&";
						return KeywordType.KW_OPERATOR_BIT_AND;
					}
				}
				else if (ch == CH_OR)
				{
					char ch2 = Getc();
					if (ch2 == EOF)
					{
						return KeywordType.KW_INVALID;
					}
					else if (ch2 == CH_OR)
					{
						buffer = "||";
						return KeywordType.KW_OPERATOR_OR;
					}
					else
					{
						buffer = "|";
						UnGetc();
						return KeywordType.KW_OPERATOR_BIT_OR;
					}
				}
				else if (ch == CH_WAVE)
				{
					buffer = CH_WAVE.ToString();
					return KeywordType.KW_OPERATOR_BIT_NOT;
				}
				else if (ch == CH_ROUND_LEFT)
				{
					buffer = CH_ROUND_LEFT.ToString ();
					
					return KeywordType.KW_ROUND_LEFT;
				}
				else if (ch == CH_ROUND_RIGHT)
				{
					buffer= CH_ROUND_RIGHT.ToString();
					
					return KeywordType.KW_ROUND_RIGHT;
				}
				else if (ch == CH_BRACE_LEFT)
				{
					buffer= CH_BRACE_LEFT.ToString();
					
					return KeywordType.KW_BRACE_LEFT;
				}
				else if (ch == CH_BRACE_RIGHT)
				{
					buffer= CH_BRACE_RIGHT.ToString();
					
					return KeywordType.KW_BRACE_RIGHT;
				}
				else
				{
					return KeywordType.KW_INVALID;
				}
				break;
			}
			return KeywordType.KW_EOF;
		}
        public string Data()
        {
			return buffer;   
        }
    }
}