C# TokenType类代码示例

 /// <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;
 }