| 0,0 → 1,395 |
|---|
| /* |
| * Copyright © 2010 Intel Corporation |
| * |
| * 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 (including the next |
| * paragraph) 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. |
| */ |
| |
| #pragma once |
| #ifndef GLSL_PARSER_EXTRAS_H |
| #define GLSL_PARSER_EXTRAS_H |
| |
| /* |
| * Most of the definitions here only apply to C++ |
| */ |
| #ifdef __cplusplus |
| |
| |
| #include <stdlib.h> |
| #include "glsl_symbol_table.h" |
| |
| enum _mesa_glsl_parser_targets { |
| vertex_shader, |
| geometry_shader, |
| fragment_shader |
| }; |
| |
| struct gl_context; |
| |
| struct glsl_switch_state { |
| /** Temporary variables needed for switch statement. */ |
| ir_variable *test_var; |
| ir_variable *is_fallthru_var; |
| ir_variable *is_break_var; |
| class ast_switch_statement *switch_nesting_ast; |
| |
| /** Table of constant values already used in case labels */ |
| struct hash_table *labels_ht; |
| class ast_case_label *previous_default; |
| |
| bool is_switch_innermost; // if switch stmt is closest to break, ... |
| }; |
| |
| const char * |
| glsl_compute_version_string(void *mem_ctx, bool is_es, unsigned version); |
| |
| typedef struct YYLTYPE { |
| int first_line; |
| int first_column; |
| int last_line; |
| int last_column; |
| unsigned source; |
| } YYLTYPE; |
| # define YYLTYPE_IS_DECLARED 1 |
| # define YYLTYPE_IS_TRIVIAL 1 |
| |
| struct _mesa_glsl_parse_state { |
| _mesa_glsl_parse_state(struct gl_context *_ctx, GLenum target, |
| void *mem_ctx); |
| |
| /* Callers of this ralloc-based new need not call delete. It's |
| * easier to just ralloc_free 'ctx' (or any of its ancestors). */ |
| static void* operator new(size_t size, void *ctx) |
| { |
| void *mem = rzalloc_size(ctx, size); |
| assert(mem != NULL); |
| |
| return mem; |
| } |
| |
| /* If the user *does* call delete, that's OK, we will just |
| * ralloc_free in that case. */ |
| static void operator delete(void *mem) |
| { |
| ralloc_free(mem); |
| } |
| |
| /** |
| * Generate a string representing the GLSL version currently being compiled |
| * (useful for error messages). |
| */ |
| const char *get_version_string() |
| { |
| return glsl_compute_version_string(this, this->es_shader, |
| this->language_version); |
| } |
| |
| /** |
| * Determine whether the current GLSL version is sufficiently high to |
| * support a certain feature. |
| * |
| * \param required_glsl_version is the desktop GLSL version that is |
| * required to support the feature, or 0 if no version of desktop GLSL |
| * supports the feature. |
| * |
| * \param required_glsl_es_version is the GLSL ES version that is required |
| * to support the feature, or 0 if no version of GLSL ES suports the |
| * feature. |
| */ |
| bool is_version(unsigned required_glsl_version, |
| unsigned required_glsl_es_version) |
| { |
| unsigned required_version = this->es_shader ? |
| required_glsl_es_version : required_glsl_version; |
| return required_version != 0 |
| && this->language_version >= required_version; |
| } |
| |
| bool check_version(unsigned required_glsl_version, |
| unsigned required_glsl_es_version, |
| YYLTYPE *locp, const char *fmt, ...) PRINTFLIKE(5, 6); |
| |
| bool check_precision_qualifiers_allowed(YYLTYPE *locp) |
| { |
| return check_version(130, 100, locp, |
| "precision qualifiers are forbidden"); |
| } |
| |
| bool check_bitwise_operations_allowed(YYLTYPE *locp) |
| { |
| return check_version(130, 300, locp, "bit-wise operations are forbidden"); |
| } |
| |
| void process_version_directive(YYLTYPE *locp, int version, |
| const char *ident); |
| |
| struct gl_context *const ctx; |
| void *scanner; |
| exec_list translation_unit; |
| glsl_symbol_table *symbols; |
| |
| unsigned num_uniform_blocks; |
| unsigned uniform_block_array_size; |
| struct gl_uniform_block *uniform_blocks; |
| |
| unsigned num_supported_versions; |
| struct { |
| unsigned ver; |
| bool es; |
| } supported_versions[12]; |
| |
| bool es_shader; |
| unsigned language_version; |
| enum _mesa_glsl_parser_targets target; |
| |
| /** |
| * Number of nested struct_specifier levels |
| * |
| * Outside a struct_specifer, this is zero. |
| */ |
| unsigned struct_specifier_depth; |
| |
| /** |
| * Default uniform layout qualifiers tracked during parsing. |
| * Currently affects uniform blocks and uniform buffer variables in |
| * those blocks. |
| */ |
| struct ast_type_qualifier *default_uniform_qualifier; |
| |
| /** |
| * Printable list of GLSL versions supported by the current context |
| * |
| * \note |
| * This string should probably be generated per-context instead of per |
| * invokation of the compiler. This should be changed when the method of |
| * tracking supported GLSL versions changes. |
| */ |
| const char *supported_version_string; |
| |
| /** |
| * Implementation defined limits that affect built-in variables, etc. |
| * |
| * \sa struct gl_constants (in mtypes.h) |
| */ |
| struct { |
| /* 1.10 */ |
| unsigned MaxLights; |
| unsigned MaxClipPlanes; |
| unsigned MaxTextureUnits; |
| unsigned MaxTextureCoords; |
| unsigned MaxVertexAttribs; |
| unsigned MaxVertexUniformComponents; |
| unsigned MaxVaryingFloats; |
| unsigned MaxVertexTextureImageUnits; |
| unsigned MaxCombinedTextureImageUnits; |
| unsigned MaxTextureImageUnits; |
| unsigned MaxFragmentUniformComponents; |
| |
| /* ARB_draw_buffers */ |
| unsigned MaxDrawBuffers; |
| |
| /* 3.00 ES */ |
| int MinProgramTexelOffset; |
| int MaxProgramTexelOffset; |
| } Const; |
| |
| /** |
| * During AST to IR conversion, pointer to current IR function |
| * |
| * Will be \c NULL whenever the AST to IR conversion is not inside a |
| * function definition. |
| */ |
| class ir_function_signature *current_function; |
| |
| /** |
| * During AST to IR conversion, pointer to the toplevel IR |
| * instruction list being generated. |
| */ |
| exec_list *toplevel_ir; |
| |
| /** Have we found a return statement in this function? */ |
| bool found_return; |
| |
| /** Was there an error during compilation? */ |
| bool error; |
| |
| /** |
| * Are all shader inputs / outputs invariant? |
| * |
| * This is set when the 'STDGL invariant(all)' pragma is used. |
| */ |
| bool all_invariant; |
| |
| /** Loop or switch statement containing the current instructions. */ |
| class ast_iteration_statement *loop_nesting_ast; |
| |
| struct glsl_switch_state switch_state; |
| |
| /** List of structures defined in user code. */ |
| const glsl_type **user_structures; |
| unsigned num_user_structures; |
| |
| char *info_log; |
| |
| /** |
| * \name Enable bits for GLSL extensions |
| */ |
| /*@{*/ |
| bool ARB_draw_buffers_enable; |
| bool ARB_draw_buffers_warn; |
| bool ARB_draw_instanced_enable; |
| bool ARB_draw_instanced_warn; |
| bool ARB_explicit_attrib_location_enable; |
| bool ARB_explicit_attrib_location_warn; |
| bool ARB_fragment_coord_conventions_enable; |
| bool ARB_fragment_coord_conventions_warn; |
| bool ARB_texture_rectangle_enable; |
| bool ARB_texture_rectangle_warn; |
| bool EXT_texture_array_enable; |
| bool EXT_texture_array_warn; |
| bool ARB_shader_texture_lod_enable; |
| bool ARB_shader_texture_lod_warn; |
| bool ARB_shader_stencil_export_enable; |
| bool ARB_shader_stencil_export_warn; |
| bool AMD_conservative_depth_enable; |
| bool AMD_conservative_depth_warn; |
| bool ARB_conservative_depth_enable; |
| bool ARB_conservative_depth_warn; |
| bool AMD_shader_stencil_export_enable; |
| bool AMD_shader_stencil_export_warn; |
| bool OES_texture_3D_enable; |
| bool OES_texture_3D_warn; |
| bool OES_EGL_image_external_enable; |
| bool OES_EGL_image_external_warn; |
| bool ARB_shader_bit_encoding_enable; |
| bool ARB_shader_bit_encoding_warn; |
| bool ARB_uniform_buffer_object_enable; |
| bool ARB_uniform_buffer_object_warn; |
| bool OES_standard_derivatives_enable; |
| bool OES_standard_derivatives_warn; |
| bool ARB_texture_cube_map_array_enable; |
| bool ARB_texture_cube_map_array_warn; |
| bool ARB_shading_language_packing_enable; |
| bool ARB_shading_language_packing_warn; |
| bool ARB_texture_multisample_enable; |
| bool ARB_texture_multisample_warn; |
| bool ARB_texture_query_lod_enable; |
| bool ARB_texture_query_lod_warn; |
| bool ARB_gpu_shader5_enable; |
| bool ARB_gpu_shader5_warn; |
| bool AMD_vertex_shader_layer_enable; |
| bool AMD_vertex_shader_layer_warn; |
| bool ARB_shading_language_420pack_enable; |
| bool ARB_shading_language_420pack_warn; |
| /*@}*/ |
| |
| /** Extensions supported by the OpenGL implementation. */ |
| const struct gl_extensions *extensions; |
| |
| /** Shaders containing built-in functions that are used for linking. */ |
| struct gl_shader *builtins_to_link[16]; |
| unsigned num_builtins_to_link; |
| }; |
| |
| # define YYLLOC_DEFAULT(Current, Rhs, N) \ |
| do { \ |
| if (N) \ |
| { \ |
| (Current).first_line = YYRHSLOC(Rhs, 1).first_line; \ |
| (Current).first_column = YYRHSLOC(Rhs, 1).first_column; \ |
| (Current).last_line = YYRHSLOC(Rhs, N).last_line; \ |
| (Current).last_column = YYRHSLOC(Rhs, N).last_column; \ |
| } \ |
| else \ |
| { \ |
| (Current).first_line = (Current).last_line = \ |
| YYRHSLOC(Rhs, 0).last_line; \ |
| (Current).first_column = (Current).last_column = \ |
| YYRHSLOC(Rhs, 0).last_column; \ |
| } \ |
| (Current).source = 0; \ |
| } while (0) |
| |
| extern void _mesa_glsl_error(YYLTYPE *locp, _mesa_glsl_parse_state *state, |
| const char *fmt, ...); |
| |
| /** |
| * Emit a warning to the shader log |
| * |
| * \sa _mesa_glsl_error |
| */ |
| extern void _mesa_glsl_warning(const YYLTYPE *locp, |
| _mesa_glsl_parse_state *state, |
| const char *fmt, ...); |
| |
| extern void _mesa_glsl_lexer_ctor(struct _mesa_glsl_parse_state *state, |
| const char *string); |
| |
| extern void _mesa_glsl_lexer_dtor(struct _mesa_glsl_parse_state *state); |
| |
| union YYSTYPE; |
| extern int _mesa_glsl_lexer_lex(union YYSTYPE *yylval, YYLTYPE *yylloc, |
| void *scanner); |
| |
| extern int _mesa_glsl_parse(struct _mesa_glsl_parse_state *); |
| |
| /** |
| * Process elements of the #extension directive |
| * |
| * \return |
| * If \c name and \c behavior are valid, \c true is returned. Otherwise |
| * \c false is returned. |
| */ |
| extern bool _mesa_glsl_process_extension(const char *name, YYLTYPE *name_locp, |
| const char *behavior, |
| YYLTYPE *behavior_locp, |
| _mesa_glsl_parse_state *state); |
| |
| /** |
| * Get the textual name of the specified shader target |
| */ |
| extern const char * |
| _mesa_glsl_shader_target_name(enum _mesa_glsl_parser_targets target); |
| |
| |
| #endif /* __cplusplus */ |
| |
| |
| /* |
| * These definitions apply to C and C++ |
| */ |
| #ifdef __cplusplus |
| extern "C" { |
| #endif |
| |
| extern const char * |
| _mesa_glsl_shader_target_name(GLenum type); |
| |
| extern int glcpp_preprocess(void *ctx, const char **shader, char **info_log, |
| const struct gl_extensions *extensions, struct gl_context *gl_ctx); |
| |
| extern void _mesa_destroy_shader_compiler(void); |
| extern void _mesa_destroy_shader_compiler_caches(void); |
| |
| #ifdef __cplusplus |
| } |
| #endif |
| |
| |
| #endif /* GLSL_PARSER_EXTRAS_H */ |