Line data    Source code

       1             : //
       2             : // Copyright (c) 2011 The ANGLE Project Authors. All rights reserved.
       3             : // Use of this source code is governed by a BSD-style license that can be
       4             : // found in the LICENSE file.
       5             : //
       6             : 
       7             : #ifndef COMPILER_PREPROCESSOR_TOKEN_H_
       8             : #define COMPILER_PREPROCESSOR_TOKEN_H_
       9             : 
      10             : #include <ostream>
      11             : #include <string>
      12             : 
      13             : #include "compiler/preprocessor/SourceLocation.h"
      14             : 
      15             : namespace pp
      16             : {
      17             : 
      18           0 : struct Token
      19             : {
      20             :     enum Type
      21             :     {
      22             :         LAST = 0,  // EOF.
      23             : 
      24             :         IDENTIFIER = 258,
      25             : 
      26             :         CONST_INT,
      27             :         CONST_FLOAT,
      28             : 
      29             :         OP_INC,
      30             :         OP_DEC,
      31             :         OP_LEFT,
      32             :         OP_RIGHT,
      33             :         OP_LE,
      34             :         OP_GE,
      35             :         OP_EQ,
      36             :         OP_NE,
      37             :         OP_AND,
      38             :         OP_XOR,
      39             :         OP_OR,
      40             :         OP_ADD_ASSIGN,
      41             :         OP_SUB_ASSIGN,
      42             :         OP_MUL_ASSIGN,
      43             :         OP_DIV_ASSIGN,
      44             :         OP_MOD_ASSIGN,
      45             :         OP_LEFT_ASSIGN,
      46             :         OP_RIGHT_ASSIGN,
      47             :         OP_AND_ASSIGN,
      48             :         OP_XOR_ASSIGN,
      49             :         OP_OR_ASSIGN,
      50             : 
      51             :         // Preprocessing token types.
      52             :         // These types are used by the preprocessor internally.
      53             :         // Preprocessor clients must not depend or check for them.
      54             :         PP_HASH,
      55             :         PP_NUMBER,
      56             :         PP_OTHER
      57             :     };
      58             :     enum Flags
      59             :     {
      60             :         AT_START_OF_LINE   = 1 << 0,
      61             :         HAS_LEADING_SPACE  = 1 << 1,
      62             :         EXPANSION_DISABLED = 1 << 2
      63             :     };
      64             : 
      65           0 :     Token()
      66           0 :         : type(0),
      67           0 :           flags(0)
      68             :     {
      69           0 :     }
      70             : 
      71             :     void reset();
      72             :     bool equals(const Token &other) const;
      73             : 
      74             :     // Returns true if this is the first token on line.
      75             :     // It disregards any leading whitespace.
      76           0 :     bool atStartOfLine() const
      77             :     {
      78           0 :         return (flags & AT_START_OF_LINE) != 0;
      79             :     }
      80             :     void setAtStartOfLine(bool start);
      81             : 
      82           0 :     bool hasLeadingSpace() const
      83             :     {
      84           0 :         return (flags & HAS_LEADING_SPACE) != 0;
      85             :     }
      86             :     void setHasLeadingSpace(bool space);
      87             : 
      88           0 :     bool expansionDisabled() const
      89             :     {
      90           0 :         return (flags & EXPANSION_DISABLED) != 0;
      91             :     }
      92             :     void setExpansionDisabled(bool disable);
      93             : 
      94             :     // Converts text into numeric value for CONST_INT and CONST_FLOAT token.
      95             :     // Returns false if the parsed value cannot fit into an int or float.
      96             :     bool iValue(int *value) const;
      97             :     bool uValue(unsigned int *value) const;
      98             :     bool fValue(float *value) const;
      99             : 
     100             :     int type;
     101             :     unsigned int flags;
     102             :     SourceLocation location;
     103             :     std::string text;
     104             : };
     105             : 
     106           0 : inline bool operator==(const Token &lhs, const Token &rhs)
     107             : {
     108           0 :     return lhs.equals(rhs);
     109             : }
     110             : 
     111             : inline bool operator!=(const Token &lhs, const Token &rhs)
     112             : {
     113             :     return !lhs.equals(rhs);
     114             : }
     115             : 
     116             : std::ostream &operator<<(std::ostream &out, const Token &token);
     117             : 
     118             : }  // namepsace pp
     119             : 
     120             : #endif  // COMPILER_PREPROCESSOR_TOKEN_H_