framework/randomshaders/rsgStatement.hpp

   1 #ifndef _RSGSTATEMENT_HPP
   2 #define _RSGSTATEMENT_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 Statements.
  24  *//*--------------------------------------------------------------------*/
  25
  26 #include "rsgDefs.hpp"
  27 #include "rsgGeneratorState.hpp"
  28 #include "rsgVariableManager.hpp"
  29 #include "rsgExpression.hpp"
  30 #include "rsgToken.hpp"
  31
  32 #include <vector>
  33
  34 namespace rsg
  35 {
  36
  37 class Statement
  38 {
  39 public:
  40                                                                 Statement                       (void);
  41         virtual                                         ~Statement                      (void);
  42
  43         virtual Statement*                      createNextChild         (GeneratorState& state)                                                 = DE_NULL;
  44         virtual void                            tokenize                        (GeneratorState& state, TokenStream& str) const = DE_NULL;
  45         virtual void                            execute                         (ExecutionContext& execCtx) const                               = DE_NULL;
  46
  47 protected:
  48 };
  49
  50 // IfStatement
  51 // ForLoopStatement
  52 // WhileStatement
  53 // DoWhileStatement
  54
  55 class ExpressionStatement : public Statement
  56 {
  57 public:
  58                                                         ExpressionStatement             (GeneratorState& state);
  59         virtual                                 ~ExpressionStatement    (void);
  60
  61         Statement*                              createNextChild                 (GeneratorState& state) { DE_UNREF(state); return DE_NULL; }
  62         void                                    tokenize                                (GeneratorState& state, TokenStream& str) const;
  63         void                                    execute                                 (ExecutionContext& execCtx) const;
  64
  65         static float                    getWeight                               (const GeneratorState& state);
  66
  67 protected:
  68         Expression*                             m_expression;
  69 };
  70
  71 class DeclarationStatement : public Statement
  72 {
  73 public:
  74                                                         DeclarationStatement    (GeneratorState& state, Variable* variable = DE_NULL);
  75         virtual                                 ~DeclarationStatement   (void);
  76
  77         Statement*                              createNextChild                 (GeneratorState& state) { DE_UNREF(state); return DE_NULL; }
  78         void                                    tokenize                                (GeneratorState& state, TokenStream& str) const;
  79         void                                    execute                                 (ExecutionContext& execCtx) const;
  80
  81         static float                    getWeight                               (const GeneratorState& state);
  82
  83 protected:
  84         const Variable*                 m_variable;
  85         Expression*                             m_expression;
  86 };
  87
  88 class BlockStatement : public Statement
  89 {
  90 public:
  91                                                         BlockStatement                  (GeneratorState& state);
  92         virtual                                 ~BlockStatement                 (void);
  93
  94                                                         BlockStatement                  (void) : m_numChildrenToCreate(0) {}
  95         void                                    init                                    (GeneratorState& state);
  96
  97         Statement*                              createNextChild                 (GeneratorState& state);
  98         void                                    tokenize                                (GeneratorState& state, TokenStream& str) const;
  99         void                                    execute                                 (ExecutionContext& execCtx) const;
 100
 101         static float                    getWeight                               (const GeneratorState& state);
 102
 103         void                                    addChild                                (Statement* statement);
 104
 105 private:
 106         VariableScope                   m_scope;
 107
 108         int                                             m_numChildrenToCreate;
 109         std::vector<Statement*> m_children;
 110 };
 111
 112 class ConditionalStatement : public Statement
 113 {
 114 public:
 115                                                         ConditionalStatement    (GeneratorState& state);
 116         virtual                                 ~ConditionalStatement   (void);
 117
 118         Statement*                              createNextChild                 (GeneratorState& state);
 119         void                                    tokenize                                (GeneratorState& state, TokenStream& str) const;
 120         void                                    execute                                 (ExecutionContext& execCtx) const;
 121
 122         static float                    getWeight                               (const GeneratorState& state);
 123
 124 private:
 125         bool                                    isElseBlockRequired             (const GeneratorState& state) const;
 126
 127         Expression*                             m_condition;
 128         Statement*                              m_trueStatement;
 129         Statement*                              m_falseStatement;
 130
 131         ValueScope                              m_conditionalScope;
 132 };
 133
 134 // \note Used for generating mandatory assignments (shader outputs, function outputs).
 135 //       Normally assignment is handled inside ExpressionStatement where generator may
 136 //       choose to generate AssignOp expression.
 137 class AssignStatement : public Statement
 138 {
 139 public:
 140                                                         AssignStatement                 (const Variable* variable, Expression* value);
 141                                                         AssignStatement                 (GeneratorState& state, const Variable* variable, ConstValueRangeAccess valueRange);
 142         virtual                                 ~AssignStatement                (void);
 143
 144         Statement*                              createNextChild                 (GeneratorState& state) { DE_UNREF(state); return DE_NULL; }
 145         void                                    tokenize                                (GeneratorState& state, TokenStream& str) const;
 146         void                                    execute                                 (ExecutionContext& execCtx) const;
 147
 148 private:
 149         const Variable*                 m_variable;
 150         Expression*                             m_valueExpr;
 151 };
 152
 153 } // rsg
 154
 155 #endif // _RSGSTATEMENT_HPP