framework/randomshaders/rsgToken.hpp

   1 #ifndef _RSGTOKEN_HPP
   2 #define _RSGTOKEN_HPP
   3 /*-------------------------------------------------------------------------
   4  * drawElements Quality Program Random Shader Generator
   5  * ----------------------------------------------------
   6  *
   7  * Copyright 2014 The Android Open Source Project
   8  *
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  *      http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  *
  21  *//*!
  22  * \file
  23  * \brief Token class.
  24  *//*--------------------------------------------------------------------*/
  25
  26 #include "rsgDefs.hpp"
  27
  28 #include <vector>
  29
  30 namespace rsg
  31 {
  32
  33 class Token
  34 {
  35 public:
  36         enum Type
  37         {
  38                 IDENTIFIER,
  39                 STRUCT,
  40                 INVARIANT,
  41                 PRECISION,
  42                 VOID,
  43                 BREAK,
  44                 CONTINUE,
  45                 DO,
  46                 WHILE,
  47                 ELSE,
  48                 FOR,
  49                 IF,
  50                 DISCARD,
  51                 RETURN,
  52                 INC_OP,
  53                 DEC_OP,
  54                 LEFT_PAREN,
  55                 RIGHT_PAREN,
  56                 LEFT_BRACKET,   // [
  57                 RIGHT_BRACKET,  // ]
  58                 LEFT_BRACE,             // {
  59                 RIGHT_BRACE,    // }
  60                 DOT,
  61                 COMMA,
  62                 COLON,
  63                 SEMICOLON,
  64                 MINUS,
  65                 PLUS,
  66                 MUL,
  67                 DIV,
  68                 MOD,
  69                 QUESTION,
  70                 BOOL,
  71                 BVEC2,
  72                 BVEC3,
  73                 BVEC4,
  74                 INT,
  75                 IVEC2,
  76                 IVEC3,
  77                 IVEC4,
  78                 FLOAT,
  79                 VEC2,
  80                 VEC3,
  81                 VEC4,
  82                 MAT2,
  83                 MAT3,
  84                 MAT4,
  85                 SAMPLER2D,
  86                 SAMPLERCUBE,
  87                 FLOAT_LITERAL,
  88                 INT_LITERAL,
  89                 BOOL_LITERAL,
  90                 EQUAL,
  91                 MUL_ASSIGN,
  92                 DIV_ASSIGN,
  93                 ADD_ASSIGN,
  94                 SUB_ASSIGN,
  95                 CMP_LT,
  96                 CMP_GT,
  97                 CMP_LE,
  98                 CMP_GE,
  99                 CMP_EQ,
 100                 CMP_NE,
 101                 LOGICAL_AND,
 102                 LOGICAL_OR,
 103                 LOGICAL_NOT,
 104                 LOGICAL_XOR,
 105                 ATTRIBUTE,
 106                 UNIFORM,
 107                 VARYING,
 108                 CONST,
 109                 FLAT,
 110                 HIGH_PRECISION,
 111                 MEDIUM_PRECISION,
 112                 LOW_PRECISION,
 113                 IN,
 114                 OUT,
 115                 INOUT,
 116                 LAYOUT,
 117                 LOCATION,
 118
 119                 // Formatting only
 120                 INDENT_INC,
 121                 INDENT_DEC,
 122                 NEWLINE,
 123
 124                 TYPE_LAST
 125         };
 126
 127                                         Token                   (void);
 128                                         Token                   (Type type);
 129                                         Token                   (const char* identifier);
 130                                         Token                   (float value);
 131                                         Token                   (int value);
 132                                         Token                   (bool value);
 133                                         Token                   (const Token& other);
 134
 135                                         ~Token                  (void);
 136
 137         inline bool             operator==              (Type type) const       { return m_type == type;        }
 138         inline bool             operator!=              (Type type) const       { return m_type != type;        }
 139
 140         bool                    operator==              (const Token& other) const;
 141         bool                    operator!=              (const Token& other) const;
 142
 143         Token&                  operator=               (const Token& other);
 144
 145         inline Type             getType                 (void) const            { return m_type;                        }
 146
 147         const char*             getIdentifier   (void) const;
 148         float                   getFloat                (void) const;
 149         int                             getInt                  (void) const;
 150         bool                    getBool                 (void) const;
 151
 152 private:
 153         Type                    m_type;
 154         union
 155         {
 156                 char*                   identifier;
 157                 float                   floatValue;
 158                 int                             intValue;
 159                 bool                    boolValue;
 160         } m_arg;
 161 };
 162
 163
 164 inline Token::Token (void)
 165         : m_type(TYPE_LAST)
 166 {
 167         m_arg.identifier = DE_NULL;
 168 }
 169
 170 inline Token::Token (Type type)
 171         : m_type(type)
 172 {
 173         DE_ASSERT(type != IDENTIFIER);
 174 }
 175
 176 inline Token::Token (float value)
 177         : m_type(FLOAT_LITERAL)
 178 {
 179         m_arg.floatValue = value;
 180 }
 181
 182 inline Token::Token (int value)
 183         : m_type(INT_LITERAL)
 184 {
 185         m_arg.intValue = value;
 186 }
 187
 188 inline Token::Token (bool value)
 189         : m_type(BOOL_LITERAL)
 190 {
 191         m_arg.boolValue = value;
 192 }
 193
 194 inline bool Token::operator== (const Token& other) const
 195 {
 196         return !(*this != other);
 197 }
 198
 199 inline const char* Token::getIdentifier (void) const
 200 {
 201         DE_ASSERT(m_type == IDENTIFIER);
 202         return m_arg.identifier;
 203 }
 204
 205 inline float Token::getFloat (void) const
 206 {
 207         DE_ASSERT(m_type == FLOAT_LITERAL);
 208         return m_arg.floatValue;
 209 }
 210
 211 inline int Token::getInt (void) const
 212 {
 213         DE_ASSERT(m_type == INT_LITERAL);
 214         return m_arg.intValue;
 215 }
 216
 217 inline bool Token::getBool (void) const
 218 {
 219         DE_ASSERT(m_type == BOOL_LITERAL);
 220         return m_arg.boolValue;
 221 }
 222
 223 class TokenStream
 224 {
 225 public:
 226                                                         TokenStream             (void);
 227                                                         ~TokenStream    (void);
 228
 229         int                                             getSize                 (void) const    { return (int)m_numTokens;      }
 230         const Token&                    operator[]              (int ndx) const { return m_tokens[ndx];         }
 231
 232         TokenStream&                    operator<<              (const Token& token);
 233
 234 private:
 235         enum
 236         {
 237                 ALLOC_SIZE = 64
 238         };
 239
 240         std::vector<Token>              m_tokens;
 241         size_t                                  m_numTokens;
 242 };
 243
 244 inline TokenStream& TokenStream::operator<< (const Token& token)
 245 {
 246         if (m_tokens.size() == m_numTokens)
 247                 m_tokens.resize(m_numTokens+ALLOC_SIZE);
 248
 249         m_tokens[m_numTokens]    = token;
 250         m_numTokens                             += 1;
 251
 252         return *this;
 253 }
 254
 255 } // rsg
 256
 257 #endif // _RSGTOKEN_HPP