diff options
Diffstat (limited to 'src/sksl/SkSLIRGenerator.h')
-rw-r--r-- | src/sksl/SkSLIRGenerator.h | 122 |
1 files changed, 122 insertions, 0 deletions
diff --git a/src/sksl/SkSLIRGenerator.h b/src/sksl/SkSLIRGenerator.h new file mode 100644 index 0000000000..d23e5a1bdb --- /dev/null +++ b/src/sksl/SkSLIRGenerator.h @@ -0,0 +1,122 @@ +/* + * 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_IRGENERATOR +#define SKSL_IRGENERATOR + +#include "SkSLErrorReporter.h" +#include "ast/SkSLASTBinaryExpression.h" +#include "ast/SkSLASTBlock.h" +#include "ast/SkSLASTBreakStatement.h" +#include "ast/SkSLASTCallSuffix.h" +#include "ast/SkSLASTContinueStatement.h" +#include "ast/SkSLASTDiscardStatement.h" +#include "ast/SkSLASTDoStatement.h" +#include "ast/SkSLASTExpression.h" +#include "ast/SkSLASTExpressionStatement.h" +#include "ast/SkSLASTExtension.h" +#include "ast/SkSLASTForStatement.h" +#include "ast/SkSLASTFunction.h" +#include "ast/SkSLASTIdentifier.h" +#include "ast/SkSLASTIfStatement.h" +#include "ast/SkSLASTInterfaceBlock.h" +#include "ast/SkSLASTModifiers.h" +#include "ast/SkSLASTPrefixExpression.h" +#include "ast/SkSLASTReturnStatement.h" +#include "ast/SkSLASTStatement.h" +#include "ast/SkSLASTSuffixExpression.h" +#include "ast/SkSLASTTernaryExpression.h" +#include "ast/SkSLASTVarDeclaration.h" +#include "ast/SkSLASTVarDeclarationStatement.h" +#include "ast/SkSLASTWhileStatement.h" +#include "ir/SkSLBlock.h" +#include "ir/SkSLExpression.h" +#include "ir/SkSLExtension.h" +#include "ir/SkSLFunctionDefinition.h" +#include "ir/SkSLInterfaceBlock.h" +#include "ir/SkSLModifiers.h" +#include "ir/SkSLSymbolTable.h" +#include "ir/SkSLStatement.h" +#include "ir/SkSLType.h" +#include "ir/SkSLTypeReference.h" +#include "ir/SkSLVarDeclaration.h" + +namespace SkSL { + +/** + * Performs semantic analysis on an abstract syntax tree (AST) and produces the corresponding + * (unoptimized) intermediate representation (IR). + */ +class IRGenerator { +public: + IRGenerator(std::shared_ptr<SymbolTable> root, ErrorReporter& errorReporter); + + std::unique_ptr<VarDeclaration> convertVarDeclaration(const ASTVarDeclaration& decl, + Variable::Storage storage); + std::unique_ptr<FunctionDefinition> convertFunction(const ASTFunction& f); + std::unique_ptr<Statement> convertStatement(const ASTStatement& statement); + std::unique_ptr<Expression> convertExpression(const ASTExpression& expression); + +private: + void pushSymbolTable(); + void popSymbolTable(); + + std::shared_ptr<Type> convertType(const ASTType& type); + std::unique_ptr<Expression> call(Position position, + std::shared_ptr<FunctionDeclaration> function, + std::vector<std::unique_ptr<Expression>> arguments); + bool determineCallCost(std::shared_ptr<FunctionDeclaration> function, + const std::vector<std::unique_ptr<Expression>>& arguments, + int* outCost); + std::unique_ptr<Expression> call(Position position, std::unique_ptr<Expression> function, + std::vector<std::unique_ptr<Expression>> arguments); + std::unique_ptr<Expression> coerce(std::unique_ptr<Expression> expr, + std::shared_ptr<Type> type); + std::unique_ptr<Block> convertBlock(const ASTBlock& block); + std::unique_ptr<Statement> convertBreak(const ASTBreakStatement& b); + std::unique_ptr<Expression> convertConstructor(Position position, + std::shared_ptr<Type> type, + std::vector<std::unique_ptr<Expression>> params); + std::unique_ptr<Statement> convertContinue(const ASTContinueStatement& c); + std::unique_ptr<Statement> convertDiscard(const ASTDiscardStatement& d); + std::unique_ptr<Statement> convertDo(const ASTDoStatement& d); + std::unique_ptr<Expression> convertBinaryExpression(const ASTBinaryExpression& expression); + std::unique_ptr<Extension> convertExtension(const ASTExtension& e); + std::unique_ptr<Statement> convertExpressionStatement(const ASTExpressionStatement& s); + std::unique_ptr<Statement> convertFor(const ASTForStatement& f); + std::unique_ptr<Expression> convertIdentifier(const ASTIdentifier& identifier); + std::unique_ptr<Statement> convertIf(const ASTIfStatement& s); + std::unique_ptr<Expression> convertIndex(std::unique_ptr<Expression> base, + const ASTExpression& index); + std::unique_ptr<InterfaceBlock> convertInterfaceBlock(const ASTInterfaceBlock& s); + Modifiers convertModifiers(const ASTModifiers& m); + std::unique_ptr<Expression> convertPrefixExpression(const ASTPrefixExpression& expression); + std::unique_ptr<Statement> convertReturn(const ASTReturnStatement& r); + std::unique_ptr<Expression> convertSuffixExpression(const ASTSuffixExpression& expression); + std::unique_ptr<Expression> convertField(std::unique_ptr<Expression> base, + const std::string& field); + std::unique_ptr<Expression> convertSwizzle(std::unique_ptr<Expression> base, + const std::string& fields); + std::unique_ptr<Expression> convertTernaryExpression(const ASTTernaryExpression& expression); + std::unique_ptr<Statement> convertVarDeclarationStatement(const ASTVarDeclarationStatement& s); + std::unique_ptr<Statement> convertWhile(const ASTWhileStatement& w); + + void checkValid(const Expression& expr); + void markReadFrom(std::shared_ptr<Variable> var); + void markWrittenTo(const Expression& expr); + + std::shared_ptr<FunctionDeclaration> fCurrentFunction; + std::shared_ptr<SymbolTable> fSymbolTable; + ErrorReporter& fErrors; + + friend class AutoSymbolTable; + friend class Compiler; +}; + +} + +#endif |