shader_preprocessor.cpp | Explore in Territory

/**************************************************************************/
/*  shader_preprocessor.cpp                                               */
/**************************************************************************/
/*                         This file is part of:                          */
/*                             GODOT ENGINE                               */
/*                        https://godotengine.org                         */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
/*                                                                        */
/* Permission is hereby granted, free of charge, to any person obtaining  */
/* a copy of this software and associated documentation files (the        */
/* "Software"), to deal in the Software without restriction, including    */
/* without limitation the rights to use, copy, modify, merge, publish,    */
/* distribute, sublicense, and/or sell copies of the Software, and to     */
/* permit persons to whom the Software is furnished to do so, subject to  */
/* the following conditions:                                              */
/*                                                                        */
/* The above copyright notice and this permission notice shall be         */
/* included in all copies or substantial portions of the Software.        */
/*                                                                        */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
/**************************************************************************/

#include "shader_preprocessor.h"
#include "core/math/expression.h"

const char32_t CURSOR = …;

// Tokenizer

void ShaderPreprocessor::Tokenizer::add_generated(const ShaderPreprocessor::Token &p_t) { … }

char32_t ShaderPreprocessor::Tokenizer::next() { … }

int ShaderPreprocessor::Tokenizer::get_line() const { … }

int ShaderPreprocessor::Tokenizer::get_index() const { … }

void ShaderPreprocessor::Tokenizer::get_and_clear_generated(LocalVector<char32_t> *r_out) { … }

void ShaderPreprocessor::Tokenizer::backtrack(char32_t p_what) { … }

char32_t ShaderPreprocessor::Tokenizer::peek() { … }

int ShaderPreprocessor::Tokenizer::consume_line_continuations(int p_offset) { … }

LocalVector<ShaderPreprocessor::Token> ShaderPreprocessor::Tokenizer::advance(char32_t p_what) { … }

void ShaderPreprocessor::Tokenizer::skip_whitespace() { … }

bool ShaderPreprocessor::Tokenizer::consume_empty_line() { … }

String ShaderPreprocessor::Tokenizer::get_identifier(bool *r_is_cursor, bool p_started) { … }

String ShaderPreprocessor::Tokenizer::peek_identifier() { … }

ShaderPreprocessor::Token ShaderPreprocessor::Tokenizer::get_token() { … }

ShaderPreprocessor::Tokenizer::Tokenizer(const String &p_code) { … }

// ShaderPreprocessor::CommentRemover

String ShaderPreprocessor::CommentRemover::get_error() const { … }

int ShaderPreprocessor::CommentRemover::get_error_line() const { … }

char32_t ShaderPreprocessor::CommentRemover::peek() const { … }

bool ShaderPreprocessor::CommentRemover::advance(char32_t p_what) { … }

String ShaderPreprocessor::CommentRemover::strip() { … }

ShaderPreprocessor::CommentRemover::CommentRemover(const String &p_code) { … }

// ShaderPreprocessor::Token

ShaderPreprocessor::Token::Token() { … }

ShaderPreprocessor::Token::Token(char32_t p_text, int p_line) { … }

// ShaderPreprocessor

bool ShaderPreprocessor::is_char_word(char32_t p_char) { … }

bool ShaderPreprocessor::is_char_space(char32_t p_char) { … }

bool ShaderPreprocessor::is_char_end(char32_t p_char) { … }

String ShaderPreprocessor::vector_to_string(const LocalVector<char32_t> &p_v, int p_start, int p_end) { … }

String ShaderPreprocessor::tokens_to_string(const LocalVector<Token> &p_tokens) { … }

void ShaderPreprocessor::process_directive(Tokenizer *p_tokenizer) { … }

void ShaderPreprocessor::process_define(Tokenizer *p_tokenizer) { … }

void ShaderPreprocessor::process_elif(Tokenizer *p_tokenizer) { … }

void ShaderPreprocessor::process_else(Tokenizer *p_tokenizer) { … }

void ShaderPreprocessor::process_endif(Tokenizer *p_tokenizer) { … }

void ShaderPreprocessor::process_error(Tokenizer *p_tokenizer) { … }

void ShaderPreprocessor::process_if(Tokenizer *p_tokenizer) { … }

void ShaderPreprocessor::process_ifdef(Tokenizer *p_tokenizer) { … }

void ShaderPreprocessor::process_ifndef(Tokenizer *p_tokenizer) { … }

void ShaderPreprocessor::process_include(Tokenizer *p_tokenizer) { … }

void ShaderPreprocessor::process_pragma(Tokenizer *p_tokenizer) { … }

void ShaderPreprocessor::process_undef(Tokenizer *p_tokenizer) { … }

void ShaderPreprocessor::add_region(int p_line, bool p_enabled, Region *p_parent_region) { … }

void ShaderPreprocessor::start_branch_condition(Tokenizer *p_tokenizer, bool p_success, bool p_continue) { … }

void ShaderPreprocessor::expand_output_macros(int p_start, int p_line_number) { … }

Error ShaderPreprocessor::expand_condition(const String &p_string, int p_line, String &r_expanded) { … }

Error ShaderPreprocessor::expand_macros(const String &p_string, int p_line, String &r_expanded) { … }

bool ShaderPreprocessor::expand_macros_once(const String &p_line, int p_line_number, const RBMap<String, Define *>::Element *p_define_pair, String &r_expanded) { … }

bool ShaderPreprocessor::find_match(const String &p_string, const String &p_value, int &r_index, int &r_index_start) { … }

void ShaderPreprocessor::concatenate_macro_body(String &r_body) { … }

String ShaderPreprocessor::next_directive(Tokenizer *p_tokenizer, const Vector<String> &p_directives) { … }

void ShaderPreprocessor::add_to_output(const String &p_str) { … }

void ShaderPreprocessor::set_error(const String &p_error, int p_line) { … }

ShaderPreprocessor::Define *ShaderPreprocessor::create_define(const String &p_body) { … }

void ShaderPreprocessor::clear_state() { … }

Error ShaderPreprocessor::preprocess(State *p_state, const String &p_code, String &r_result) { … }

Error ShaderPreprocessor::preprocess(const String &p_code, const String &p_filename, String &r_result, String *r_error_text, List<FilePosition> *r_error_position, List<Region> *r_regions, HashSet<Ref<ShaderInclude>> *r_includes, List<ScriptLanguage::CodeCompletionOption> *r_completion_options, List<ScriptLanguage::CodeCompletionOption> *r_completion_defines, IncludeCompletionFunction p_include_completion_func) { … }

void ShaderPreprocessor::get_keyword_list(List<String> *r_keywords, bool p_include_shader_keywords, bool p_ignore_context_keywords) { … }

void ShaderPreprocessor::get_pragma_list(List<String> *r_pragmas) { … }

ShaderPreprocessor::ShaderPreprocessor() { … }

ShaderPreprocessor::~ShaderPreprocessor() { … }
godot/servers/rendering/shader_preprocessor.cpp
