diff options
Diffstat (limited to 'gfx/skia/skia/src/sksl/ir/SkSLBlock.h')
-rw-r--r-- | gfx/skia/skia/src/sksl/ir/SkSLBlock.h | 110 |
1 files changed, 110 insertions, 0 deletions
diff --git a/gfx/skia/skia/src/sksl/ir/SkSLBlock.h b/gfx/skia/skia/src/sksl/ir/SkSLBlock.h new file mode 100644 index 0000000000..7bdfdf8bf7 --- /dev/null +++ b/gfx/skia/skia/src/sksl/ir/SkSLBlock.h @@ -0,0 +1,110 @@ +/* + * Copyright 2016 Google Inc. + * + * Use of this source code is governed by a BSD-style license that can be + * found in the LICENSE file. + */ + +#ifndef SKSL_BLOCK +#define SKSL_BLOCK + +#include "include/private/SkSLDefines.h" +#include "include/private/SkSLIRNode.h" +#include "include/private/SkSLStatement.h" +#include "include/sksl/SkSLPosition.h" + +#include <memory> +#include <string> +#include <utility> + +namespace SkSL { + +class SymbolTable; + +/** + * A block of multiple statements functioning as a single statement. + */ +class Block final : public Statement { +public: + inline static constexpr Kind kIRNodeKind = Kind::kBlock; + + // "kBracedScope" represents an actual language-level block. Other kinds of block are used to + // pass around multiple statements as if they were a single unit, with no semantic impact. + enum class Kind { + kUnbracedBlock, // Represents a group of statements without curly braces. + kBracedScope, // Represents a language-level Block, with curly braces. + kCompoundStatement, // A block which conceptually represents a single statement, such as + // `int a, b;`. (SkSL represents this internally as two statements: + // `int a; int b;`) Allowed to optimize away to its interior Statement. + // Treated as a single statement by the debugger. + }; + + Block(Position pos, StatementArray statements, + Kind kind = Kind::kBracedScope, const std::shared_ptr<SymbolTable> symbols = nullptr) + : INHERITED(pos, kIRNodeKind) + , fChildren(std::move(statements)) + , fBlockKind(kind) + , fSymbolTable(std::move(symbols)) {} + + // Make is allowed to simplify compound statements. For a single-statement unscoped Block, + // Make can return the Statement as-is. For an empty unscoped Block, Make can return Nop. + static std::unique_ptr<Statement> Make(Position pos, + StatementArray statements, + Kind kind = Kind::kBracedScope, + std::shared_ptr<SymbolTable> symbols = nullptr); + + // MakeBlock always makes a real Block object. This is important because many callers rely on + // Blocks specifically; e.g. a function body must be a scoped Block, nothing else will do. + static std::unique_ptr<Block> MakeBlock(Position pos, + StatementArray statements, + Kind kind = Kind::kBracedScope, + std::shared_ptr<SymbolTable> symbols = nullptr); + + const StatementArray& children() const { + return fChildren; + } + + StatementArray& children() { + return fChildren; + } + + bool isScope() const { + return fBlockKind == Kind::kBracedScope; + } + + Kind blockKind() const { + return fBlockKind; + } + + void setBlockKind(Kind kind) { + fBlockKind = kind; + } + + std::shared_ptr<SymbolTable> symbolTable() const { + return fSymbolTable; + } + + bool isEmpty() const override { + for (const std::unique_ptr<Statement>& stmt : this->children()) { + if (!stmt->isEmpty()) { + return false; + } + } + return true; + } + + std::unique_ptr<Statement> clone() const override; + + std::string description() const override; + +private: + StatementArray fChildren; + Kind fBlockKind; + std::shared_ptr<SymbolTable> fSymbolTable; + + using INHERITED = Statement; +}; + +} // namespace SkSL + +#endif |