/// <summary>
 /// Initializes a new isntance of the <see cref="RegexLexerContext"/> class
 /// </summary>
 /// <param name="position">the position into the source file</param>
 /// <param name="match">the regular expression match data</param>
 /// <param name="stateStack">The stack of states</param>
 /// <param name="ruleTokenType">The token type the rule specified to emit</param>
 public RegexLexerContext(int position, Match match, Stack<string> stateStack, TokenType ruleTokenType)
 {
     Position = position;
     Match = match;
     StateStack = stateStack;
     RuleTokenType = ruleTokenType;
 }

    public VxSqlToken(TokenType t, string n, string l)
    {
	type = t;
	name = n;
	leading_space = l;
	trailing_space = "";
    }

 public Token(TokenType type, string text, int offset, int length)
 {
     m_Type = type;
     m_Text = text;
     m_Offset = offset;
     m_Length = length;
 }

        public bool Equals(TokenType tokenType, string value)
        {
            Debug.Assert(Enum.IsDefined(typeof(TokenType), tokenType));
            Debug.Assert(value != null);

            return (this.type == tokenType) && string.Equals(this.value, value, StringComparison.Ordinal);
        }

 public Token(TokenType type, string text, int start, int length)
 {
     this.type = type;
     this.text = text;
     this.start = start;
     this.length = length;
 }

 internal static OperatorType GetOperatorType(TokenType type)
 {
     if (type == TokenType.OP_UMINUS) return OperatorType.UNARY;
     if (type == TokenType.OP_UPLUS) return OperatorType.UNARY;
     if (type == TokenType.OP_UNOT) return OperatorType.UNARY;
     return OperatorType.BINARY;
 }

        public UnaryExpression(TokenType op, Expression operand)
        {
            if (operand != null)
                AddChild (operand, OperandRole);

            Operator = op;
        }

 public BinaryExpression(int line, int column, Expression lhs, TokenType op, Expression rhs)
     : base(line, column)
 {
     this.lhs = lhs;
     this.op = op;
     this.rhs = rhs;
 }

        private void DiscardToken(TokenType tokenType)
        {
            if (_lookaheadFirst.TokenType != tokenType)
                throw new LqlParserException(string.Format("Expected {0} but found: {1}", tokenType.ToString().ToUpper(), _lookaheadFirst.Value));

            DiscardToken();
        }

 protected MonadicExpression(TextPosition tp, TokenType op, Element exp)
     : base(tp)
 {
     Operator = op;
     Exp = exp;
     AppendChild(Exp);
 }

 public Token(string name, TokenType t, int line, int column)
 {
     this.Text = name;
     this.Type = t;
     this.Line = line;
     this.Column = column;
 }

 /// <summary>
 /// Gets the value of the next token of a certain type
 /// </summary>
 /// <param name="type">The type of token to retrieve</param>
 /// <returns>The token's value</returns>
 private string _get(TokenType type)
 {
     var token = _read();
     if (token.Type != type)
         throw new InvalidDataException(token.Type.ToString());
     return token.Value;
 }

 public Token(DateTimeOffset created, Guid tokenGuid, string tokenName, TokenType tokenType)
 {
     this.Created = created;
     this.TokenGuid = tokenGuid;
     this.TokenName = tokenName;
     this.TokenType = tokenType;
 }

 public static extern bool DuplicateTokenEx(
     SafeFileHandle hExistingToken,
     uint dwDesiredAccess,
     SecurityAttributes lpTokenAttributes,
     SecurityImpersonationLevel impersonationLevel,
     TokenType tokenType,
     out IntPtr hNewToken);

 public Token(TokenType type, string term, int start, int length)
 {
     Start = start;
     Length = length;
     Type = type;
     Term = term;
 }

 public Token(Regex match, TokenType tokenType, OperationType operationType = OperationType.Operator, TokenDiscardPolicy discardPolicy = TokenDiscardPolicy.Keep)
 {
     m_TokenType = tokenType;
     m_DiscardPolicy = discardPolicy;
     m_OperationType = operationType;
     m_Regex = match;
 }

 static XmlTokens()
 {
     StartComment = new TokenType("StartComment", "<!--");
     EndComment = new TokenType("EndComment", "-->");
     CloseElement = new TokenType("CloseElement", "/>");
     ComplexCloseElement = new TokenType("ComplexCloseElement", "</");
 }

 public override ScriptObject Compute(TokenType type, ScriptObject value) {
     if (type != TokenType.Plus) { return base.Compute(type, value); }
     ScriptTable table = value as ScriptTable;
     if (table == null) throw new ExecutionException(m_Script, this, "table [+] 操作只限两个[table]之间,传入数据类型:" + value.Type);
     ScriptTable ret = m_Script.CreateTable();
     ScriptObject obj = null;
     ScriptScriptFunction func = null;
     foreach (KeyValuePair<object, ScriptObject> pair in m_listObject) {
         obj = pair.Value.Clone();
         if (obj is ScriptScriptFunction) {
             func = (ScriptScriptFunction)obj;
             if (!func.IsStaticFunction) func.SetTable(ret);
         }
         ret.m_listObject[pair.Key] = obj;
     }
     foreach (KeyValuePair<object, ScriptObject> pair in table.m_listObject) {
         obj = pair.Value.Clone();
         if (obj is ScriptScriptFunction) {
             func = (ScriptScriptFunction)obj;
             if (!func.IsStaticFunction) func.SetTable(ret);
         }
         ret.m_listObject[pair.Key] = obj;
     }
     return ret;
 }

 public CLexer()
 {
     m_strExpr = "";
     m_nNextPos = 0;
     m_PreviousTokenType = TokenType.T_EOL;
     m_currToken = new Token();
 }

 // Constructor
 public Token(TokenType type, int startOffset, int length, object data = null)
 {
     this.type = type;
     this.startOffset = startOffset;
     this.length = length;
     this.data = data;
 }