1/*
2 * Copyright © 2010 Intel Corporation
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
13 * Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
21 * DEALINGS IN THE SOFTWARE.
22 */
23
24#ifndef GLSL_PARSER_EXTRAS_H
25#define GLSL_PARSER_EXTRAS_H
26
27/*
28 * Most of the definitions here only apply to C++
29 */
30#ifdef __cplusplus
31
32
33#include <stdlib.h>
34#include "glsl_symbol_table.h"
35
36/* THIS is a macro defined somewhere deep in the Windows MSVC header files.
37 * Undefine it here to avoid collision with the lexer's THIS token.
38 */
39#undef THIS
40
41struct gl_context;
42
43struct glsl_switch_state {
44   /** Temporary variables needed for switch statement. */
45   ir_variable *test_var;
46   ir_variable *is_fallthru_var;
47   class ast_switch_statement *switch_nesting_ast;
48
49   /** Used to detect if 'continue' was called inside a switch. */
50   ir_variable *continue_inside;
51
52   /** Used to set condition if 'default' label should be chosen. */
53   ir_variable *run_default;
54
55   /** Table of constant values already used in case labels */
56   struct hash_table *labels_ht;
57   class ast_case_label *previous_default;
58
59   bool is_switch_innermost; // if switch stmt is closest to break, ...
60};
61
62const char *
63glsl_compute_version_string(void *mem_ctx, bool is_es, unsigned version);
64
65typedef struct YYLTYPE {
66   int first_line;
67   int first_column;
68   int last_line;
69   int last_column;
70   unsigned source;
71} YYLTYPE;
72# define YYLTYPE_IS_DECLARED 1
73# define YYLTYPE_IS_TRIVIAL 1
74
75extern void _mesa_glsl_error(YYLTYPE *locp, _mesa_glsl_parse_state *state,
76                             const char *fmt, ...);
77
78
79struct _mesa_glsl_parse_state {
80   _mesa_glsl_parse_state(struct gl_context *_ctx, gl_shader_stage stage,
81                          void *mem_ctx);
82
83   DECLARE_RZALLOC_CXX_OPERATORS(_mesa_glsl_parse_state);
84
85   /**
86    * Generate a string representing the GLSL version currently being compiled
87    * (useful for error messages).
88    */
89   const char *get_version_string()
90   {
91      return glsl_compute_version_string(this, this->es_shader,
92                                         this->language_version);
93   }
94
95   /**
96    * Determine whether the current GLSL version is sufficiently high to
97    * support a certain feature.
98    *
99    * \param required_glsl_version is the desktop GLSL version that is
100    * required to support the feature, or 0 if no version of desktop GLSL
101    * supports the feature.
102    *
103    * \param required_glsl_es_version is the GLSL ES version that is required
104    * to support the feature, or 0 if no version of GLSL ES supports the
105    * feature.
106    */
107   bool is_version(unsigned required_glsl_version,
108                   unsigned required_glsl_es_version) const
109   {
110      unsigned required_version = this->es_shader ?
111         required_glsl_es_version : required_glsl_version;
112      unsigned this_version = this->forced_language_version
113         ? this->forced_language_version : this->language_version;
114      return required_version != 0
115         && this_version >= required_version;
116   }
117
118   bool check_version(unsigned required_glsl_version,
119                      unsigned required_glsl_es_version,
120                      YYLTYPE *locp, const char *fmt, ...) PRINTFLIKE(5, 6);
121
122   bool check_arrays_of_arrays_allowed(YYLTYPE *locp)
123   {
124      if (!(ARB_arrays_of_arrays_enable || is_version(430, 310))) {
125         const char *const requirement = this->es_shader
126            ? "GLSL ES 3.10"
127            : "GL_ARB_arrays_of_arrays or GLSL 4.30";
128         _mesa_glsl_error(locp, this,
129                          "%s required for defining arrays of arrays.",
130                          requirement);
131         return false;
132      }
133      return true;
134   }
135
136   bool check_precision_qualifiers_allowed(YYLTYPE *locp)
137   {
138      return check_version(130, 100, locp,
139                           "precision qualifiers are forbidden");
140   }
141
142   bool check_bitwise_operations_allowed(YYLTYPE *locp)
143   {
144      return EXT_gpu_shader4_enable ||
145             check_version(130, 300, locp, "bit-wise operations are forbidden");
146   }
147
148   bool check_explicit_attrib_stream_allowed(YYLTYPE *locp)
149   {
150      if (!this->has_explicit_attrib_stream()) {
151         const char *const requirement = "GL_ARB_gpu_shader5 extension or GLSL 4.00";
152
153         _mesa_glsl_error(locp, this, "explicit stream requires %s",
154                          requirement);
155         return false;
156      }
157
158      return true;
159   }
160
161   bool check_explicit_attrib_location_allowed(YYLTYPE *locp,
162                                               const ir_variable *var)
163   {
164      if (!this->has_explicit_attrib_location()) {
165         const char *const requirement = this->es_shader
166            ? "GLSL ES 3.00"
167            : "GL_ARB_explicit_attrib_location extension or GLSL 3.30";
168
169         _mesa_glsl_error(locp, this, "%s explicit location requires %s",
170                          mode_string(var), requirement);
171         return false;
172      }
173
174      return true;
175   }
176
177   bool check_separate_shader_objects_allowed(YYLTYPE *locp,
178                                              const ir_variable *var)
179   {
180      if (!this->has_separate_shader_objects()) {
181         const char *const requirement = this->es_shader
182            ? "GL_EXT_separate_shader_objects extension or GLSL ES 3.10"
183            : "GL_ARB_separate_shader_objects extension or GLSL 4.20";
184
185         _mesa_glsl_error(locp, this, "%s explicit location requires %s",
186                          mode_string(var), requirement);
187         return false;
188      }
189
190      return true;
191   }
192
193   bool check_explicit_uniform_location_allowed(YYLTYPE *locp,
194                                                const ir_variable *)
195   {
196      if (!this->has_explicit_attrib_location() ||
197          !this->has_explicit_uniform_location()) {
198         const char *const requirement = this->es_shader
199            ? "GLSL ES 3.10"
200            : "GL_ARB_explicit_uniform_location and either "
201              "GL_ARB_explicit_attrib_location or GLSL 3.30.";
202
203         _mesa_glsl_error(locp, this,
204                          "uniform explicit location requires %s",
205                          requirement);
206         return false;
207      }
208
209      return true;
210   }
211
212   bool has_atomic_counters() const
213   {
214      return ARB_shader_atomic_counters_enable || is_version(420, 310);
215   }
216
217   bool has_enhanced_layouts() const
218   {
219      return ARB_enhanced_layouts_enable || is_version(440, 0);
220   }
221
222   bool has_explicit_attrib_stream() const
223   {
224      return ARB_gpu_shader5_enable || is_version(400, 0);
225   }
226
227   bool has_explicit_attrib_location() const
228   {
229      return ARB_explicit_attrib_location_enable || is_version(330, 300);
230   }
231
232   bool has_explicit_uniform_location() const
233   {
234      return ARB_explicit_uniform_location_enable || is_version(430, 310);
235   }
236
237   bool has_uniform_buffer_objects() const
238   {
239      return ARB_uniform_buffer_object_enable || is_version(140, 300);
240   }
241
242   bool has_shader_storage_buffer_objects() const
243   {
244      return ARB_shader_storage_buffer_object_enable || is_version(430, 310);
245   }
246
247   bool has_separate_shader_objects() const
248   {
249      return ARB_separate_shader_objects_enable || is_version(410, 310)
250         || EXT_separate_shader_objects_enable;
251   }
252
253   bool has_double() const
254   {
255      return ARB_gpu_shader_fp64_enable || is_version(400, 0);
256   }
257
258   bool has_int64() const
259   {
260      return ARB_gpu_shader_int64_enable ||
261             AMD_gpu_shader_int64_enable;
262   }
263
264   bool has_420pack() const
265   {
266      return ARB_shading_language_420pack_enable || is_version(420, 0);
267   }
268
269   bool has_420pack_or_es31() const
270   {
271      return ARB_shading_language_420pack_enable || is_version(420, 310);
272   }
273
274   bool has_compute_shader() const
275   {
276      return ARB_compute_shader_enable || is_version(430, 310);
277   }
278
279   bool has_shader_io_blocks() const
280   {
281      /* The OES_geometry_shader_specification says:
282       *
283       *    "If the OES_geometry_shader extension is enabled, the
284       *     OES_shader_io_blocks extension is also implicitly enabled."
285       *
286       * The OES_tessellation_shader extension has similar wording.
287       */
288      return OES_shader_io_blocks_enable ||
289             EXT_shader_io_blocks_enable ||
290             OES_geometry_shader_enable ||
291             EXT_geometry_shader_enable ||
292             OES_tessellation_shader_enable ||
293             EXT_tessellation_shader_enable ||
294
295             is_version(150, 320);
296   }
297
298   bool has_geometry_shader() const
299   {
300      return OES_geometry_shader_enable || EXT_geometry_shader_enable ||
301             is_version(150, 320);
302   }
303
304   bool has_tessellation_shader() const
305   {
306      return ARB_tessellation_shader_enable ||
307             OES_tessellation_shader_enable ||
308             EXT_tessellation_shader_enable ||
309             is_version(400, 320);
310   }
311
312   bool has_clip_distance() const
313   {
314      return EXT_clip_cull_distance_enable || is_version(130, 0);
315   }
316
317   bool has_cull_distance() const
318   {
319      return EXT_clip_cull_distance_enable ||
320             ARB_cull_distance_enable ||
321             is_version(450, 0);
322   }
323
324   bool has_framebuffer_fetch() const
325   {
326      return EXT_shader_framebuffer_fetch_enable ||
327             EXT_shader_framebuffer_fetch_non_coherent_enable;
328   }
329
330   bool has_texture_cube_map_array() const
331   {
332      return ARB_texture_cube_map_array_enable ||
333             EXT_texture_cube_map_array_enable ||
334             OES_texture_cube_map_array_enable ||
335             is_version(400, 320);
336   }
337
338   bool has_shader_image_load_store() const
339   {
340      return ARB_shader_image_load_store_enable || is_version(420, 310);
341   }
342
343   bool has_bindless() const
344   {
345      return ARB_bindless_texture_enable;
346   }
347
348   bool has_image_load_formatted() const
349   {
350      return EXT_shader_image_load_formatted_enable;
351   }
352
353   bool has_implicit_conversions() const
354   {
355      return EXT_shader_implicit_conversions_enable || is_version(120, 0);
356   }
357
358   bool has_implicit_uint_to_int_conversion() const
359   {
360      return ARB_gpu_shader5_enable ||
361             MESA_shader_integer_functions_enable ||
362             EXT_shader_implicit_conversions_enable ||
363             is_version(400, 0);
364   }
365
366   void process_version_directive(YYLTYPE *locp, int version,
367                                  const char *ident);
368
369   struct gl_context *const ctx;
370   void *scanner;
371   exec_list translation_unit;
372   glsl_symbol_table *symbols;
373
374   void *linalloc;
375
376   unsigned num_supported_versions;
377   struct {
378      unsigned ver;
379      uint8_t gl_ver;
380      bool es;
381   } supported_versions[17];
382
383   bool es_shader;
384   bool compat_shader;
385   unsigned language_version;
386   unsigned forced_language_version;
387   bool zero_init;
388   unsigned gl_version;
389   gl_shader_stage stage;
390
391   /**
392    * Default uniform layout qualifiers tracked during parsing.
393    * Currently affects uniform blocks and uniform buffer variables in
394    * those blocks.
395    */
396   struct ast_type_qualifier *default_uniform_qualifier;
397
398   /**
399    * Default shader storage layout qualifiers tracked during parsing.
400    * Currently affects shader storage blocks and shader storage buffer
401    * variables in those blocks.
402    */
403   struct ast_type_qualifier *default_shader_storage_qualifier;
404
405   /**
406    * Variables to track different cases if a fragment shader redeclares
407    * built-in variable gl_FragCoord.
408    *
409    * Note: These values are computed at ast_to_hir time rather than at parse
410    * time.
411    */
412   bool fs_redeclares_gl_fragcoord;
413   bool fs_origin_upper_left;
414   bool fs_pixel_center_integer;
415   bool fs_redeclares_gl_fragcoord_with_no_layout_qualifiers;
416
417   /**
418    * True if a geometry shader input primitive type or tessellation control
419    * output vertices were specified using a layout directive.
420    *
421    * Note: these values are computed at ast_to_hir time rather than at parse
422    * time.
423    */
424   bool gs_input_prim_type_specified;
425   bool tcs_output_vertices_specified;
426
427   /**
428    * Input layout qualifiers from GLSL 1.50 (geometry shader controls),
429    * and GLSL 4.00 (tessellation evaluation shader)
430    */
431   struct ast_type_qualifier *in_qualifier;
432
433   /**
434    * True if a compute shader input local size was specified using a layout
435    * directive.
436    *
437    * Note: this value is computed at ast_to_hir time rather than at parse
438    * time.
439    */
440   bool cs_input_local_size_specified;
441
442   /**
443    * If cs_input_local_size_specified is true, the local size that was
444    * specified.  Otherwise ignored.
445    */
446   unsigned cs_input_local_size[3];
447
448   /**
449    * True if a compute shader input local variable size was specified using
450    * a layout directive as specified by ARB_compute_variable_group_size.
451    */
452   bool cs_input_local_size_variable_specified;
453
454   /**
455    * Arrangement of invocations used to calculate derivatives in a compute
456    * shader.  From NV_compute_shader_derivatives.
457    */
458   enum gl_derivative_group cs_derivative_group;
459
460   /**
461    * True if a shader declare bindless_sampler/bindless_image, and
462    * respectively bound_sampler/bound_image at global scope as specified by
463    * ARB_bindless_texture.
464    */
465   bool bindless_sampler_specified;
466   bool bindless_image_specified;
467   bool bound_sampler_specified;
468   bool bound_image_specified;
469
470   /**
471    * Output layout qualifiers from GLSL 1.50 (geometry shader controls),
472    * and GLSL 4.00 (tessellation control shader).
473    */
474   struct ast_type_qualifier *out_qualifier;
475
476   /**
477    * Printable list of GLSL versions supported by the current context
478    *
479    * \note
480    * This string should probably be generated per-context instead of per
481    * invokation of the compiler.  This should be changed when the method of
482    * tracking supported GLSL versions changes.
483    */
484   const char *supported_version_string;
485
486   /**
487    * Implementation defined limits that affect built-in variables, etc.
488    *
489    * \sa struct gl_constants (in mtypes.h)
490    */
491   struct {
492      /* 1.10 */
493      unsigned MaxLights;
494      unsigned MaxClipPlanes;
495      unsigned MaxTextureUnits;
496      unsigned MaxTextureCoords;
497      unsigned MaxVertexAttribs;
498      unsigned MaxVertexUniformComponents;
499      unsigned MaxVertexTextureImageUnits;
500      unsigned MaxCombinedTextureImageUnits;
501      unsigned MaxTextureImageUnits;
502      unsigned MaxFragmentUniformComponents;
503
504      /* ARB_draw_buffers */
505      unsigned MaxDrawBuffers;
506
507      /* ARB_enhanced_layouts */
508      unsigned MaxTransformFeedbackBuffers;
509      unsigned MaxTransformFeedbackInterleavedComponents;
510
511      /* ARB_blend_func_extended */
512      unsigned MaxDualSourceDrawBuffers;
513
514      /* 3.00 ES */
515      int MinProgramTexelOffset;
516      int MaxProgramTexelOffset;
517
518      /* 1.50 */
519      unsigned MaxVertexOutputComponents;
520      unsigned MaxGeometryInputComponents;
521      unsigned MaxGeometryOutputComponents;
522      unsigned MaxGeometryShaderInvocations;
523      unsigned MaxFragmentInputComponents;
524      unsigned MaxGeometryTextureImageUnits;
525      unsigned MaxGeometryOutputVertices;
526      unsigned MaxGeometryTotalOutputComponents;
527      unsigned MaxGeometryUniformComponents;
528
529      /* ARB_shader_atomic_counters */
530      unsigned MaxVertexAtomicCounters;
531      unsigned MaxTessControlAtomicCounters;
532      unsigned MaxTessEvaluationAtomicCounters;
533      unsigned MaxGeometryAtomicCounters;
534      unsigned MaxFragmentAtomicCounters;
535      unsigned MaxCombinedAtomicCounters;
536      unsigned MaxAtomicBufferBindings;
537
538      /* These are also atomic counter related, but they weren't added to
539       * until atomic counters were added to core in GLSL 4.20 and GLSL ES
540       * 3.10.
541       */
542      unsigned MaxVertexAtomicCounterBuffers;
543      unsigned MaxTessControlAtomicCounterBuffers;
544      unsigned MaxTessEvaluationAtomicCounterBuffers;
545      unsigned MaxGeometryAtomicCounterBuffers;
546      unsigned MaxFragmentAtomicCounterBuffers;
547      unsigned MaxCombinedAtomicCounterBuffers;
548      unsigned MaxAtomicCounterBufferSize;
549
550      /* ARB_compute_shader */
551      unsigned MaxComputeAtomicCounterBuffers;
552      unsigned MaxComputeAtomicCounters;
553      unsigned MaxComputeImageUniforms;
554      unsigned MaxComputeTextureImageUnits;
555      unsigned MaxComputeUniformComponents;
556      unsigned MaxComputeWorkGroupCount[3];
557      unsigned MaxComputeWorkGroupSize[3];
558
559      /* ARB_shader_image_load_store */
560      unsigned MaxImageUnits;
561      unsigned MaxCombinedShaderOutputResources;
562      unsigned MaxImageSamples;
563      unsigned MaxVertexImageUniforms;
564      unsigned MaxTessControlImageUniforms;
565      unsigned MaxTessEvaluationImageUniforms;
566      unsigned MaxGeometryImageUniforms;
567      unsigned MaxFragmentImageUniforms;
568      unsigned MaxCombinedImageUniforms;
569
570      /* ARB_viewport_array */
571      unsigned MaxViewports;
572
573      /* ARB_tessellation_shader */
574      unsigned MaxPatchVertices;
575      unsigned MaxTessGenLevel;
576      unsigned MaxTessControlInputComponents;
577      unsigned MaxTessControlOutputComponents;
578      unsigned MaxTessControlTextureImageUnits;
579      unsigned MaxTessEvaluationInputComponents;
580      unsigned MaxTessEvaluationOutputComponents;
581      unsigned MaxTessEvaluationTextureImageUnits;
582      unsigned MaxTessPatchComponents;
583      unsigned MaxTessControlTotalOutputComponents;
584      unsigned MaxTessControlUniformComponents;
585      unsigned MaxTessEvaluationUniformComponents;
586
587      /* GL 4.5 / OES_sample_variables */
588      unsigned MaxSamples;
589   } Const;
590
591   /**
592    * During AST to IR conversion, pointer to current IR function
593    *
594    * Will be \c NULL whenever the AST to IR conversion is not inside a
595    * function definition.
596    */
597   class ir_function_signature *current_function;
598
599   /**
600    * During AST to IR conversion, pointer to the toplevel IR
601    * instruction list being generated.
602    */
603   exec_list *toplevel_ir;
604
605   /** Have we found a return statement in this function? */
606   bool found_return;
607
608   /** Was there an error during compilation? */
609   bool error;
610
611   /**
612    * Are all shader inputs / outputs invariant?
613    *
614    * This is set when the 'STDGL invariant(all)' pragma is used.
615    */
616   bool all_invariant;
617
618   /** Loop or switch statement containing the current instructions. */
619   class ast_iteration_statement *loop_nesting_ast;
620
621   struct glsl_switch_state switch_state;
622
623   /** List of structures defined in user code. */
624   const glsl_type **user_structures;
625   unsigned num_user_structures;
626
627   char *info_log;
628
629   /**
630    * Are warnings enabled?
631    *
632    * Emission of warngins is controlled by '#pragma warning(...)'.
633    */
634   bool warnings_enabled;
635
636   /**
637    * \name Enable bits for GLSL extensions
638    */
639   /*@{*/
640   /* ARB extensions go here, sorted alphabetically.
641    */
642   bool ARB_ES3_1_compatibility_enable;
643   bool ARB_ES3_1_compatibility_warn;
644   bool ARB_ES3_2_compatibility_enable;
645   bool ARB_ES3_2_compatibility_warn;
646   bool ARB_arrays_of_arrays_enable;
647   bool ARB_arrays_of_arrays_warn;
648   bool ARB_bindless_texture_enable;
649   bool ARB_bindless_texture_warn;
650   bool ARB_compatibility_enable;
651   bool ARB_compatibility_warn;
652   bool ARB_compute_shader_enable;
653   bool ARB_compute_shader_warn;
654   bool ARB_compute_variable_group_size_enable;
655   bool ARB_compute_variable_group_size_warn;
656   bool ARB_conservative_depth_enable;
657   bool ARB_conservative_depth_warn;
658   bool ARB_cull_distance_enable;
659   bool ARB_cull_distance_warn;
660   bool ARB_derivative_control_enable;
661   bool ARB_derivative_control_warn;
662   bool ARB_draw_buffers_enable;
663   bool ARB_draw_buffers_warn;
664   bool ARB_draw_instanced_enable;
665   bool ARB_draw_instanced_warn;
666   bool ARB_enhanced_layouts_enable;
667   bool ARB_enhanced_layouts_warn;
668   bool ARB_explicit_attrib_location_enable;
669   bool ARB_explicit_attrib_location_warn;
670   bool ARB_explicit_uniform_location_enable;
671   bool ARB_explicit_uniform_location_warn;
672   bool ARB_fragment_coord_conventions_enable;
673   bool ARB_fragment_coord_conventions_warn;
674   bool ARB_fragment_layer_viewport_enable;
675   bool ARB_fragment_layer_viewport_warn;
676   bool ARB_fragment_shader_interlock_enable;
677   bool ARB_fragment_shader_interlock_warn;
678   bool ARB_gpu_shader5_enable;
679   bool ARB_gpu_shader5_warn;
680   bool ARB_gpu_shader_fp64_enable;
681   bool ARB_gpu_shader_fp64_warn;
682   bool ARB_gpu_shader_int64_enable;
683   bool ARB_gpu_shader_int64_warn;
684   bool ARB_post_depth_coverage_enable;
685   bool ARB_post_depth_coverage_warn;
686   bool ARB_sample_shading_enable;
687   bool ARB_sample_shading_warn;
688   bool ARB_separate_shader_objects_enable;
689   bool ARB_separate_shader_objects_warn;
690   bool ARB_shader_atomic_counter_ops_enable;
691   bool ARB_shader_atomic_counter_ops_warn;
692   bool ARB_shader_atomic_counters_enable;
693   bool ARB_shader_atomic_counters_warn;
694   bool ARB_shader_ballot_enable;
695   bool ARB_shader_ballot_warn;
696   bool ARB_shader_bit_encoding_enable;
697   bool ARB_shader_bit_encoding_warn;
698   bool ARB_shader_clock_enable;
699   bool ARB_shader_clock_warn;
700   bool ARB_shader_draw_parameters_enable;
701   bool ARB_shader_draw_parameters_warn;
702   bool ARB_shader_group_vote_enable;
703   bool ARB_shader_group_vote_warn;
704   bool ARB_shader_image_load_store_enable;
705   bool ARB_shader_image_load_store_warn;
706   bool ARB_shader_image_size_enable;
707   bool ARB_shader_image_size_warn;
708   bool ARB_shader_precision_enable;
709   bool ARB_shader_precision_warn;
710   bool ARB_shader_stencil_export_enable;
711   bool ARB_shader_stencil_export_warn;
712   bool ARB_shader_storage_buffer_object_enable;
713   bool ARB_shader_storage_buffer_object_warn;
714   bool ARB_shader_subroutine_enable;
715   bool ARB_shader_subroutine_warn;
716   bool ARB_shader_texture_image_samples_enable;
717   bool ARB_shader_texture_image_samples_warn;
718   bool ARB_shader_texture_lod_enable;
719   bool ARB_shader_texture_lod_warn;
720   bool ARB_shader_viewport_layer_array_enable;
721   bool ARB_shader_viewport_layer_array_warn;
722   bool ARB_shading_language_420pack_enable;
723   bool ARB_shading_language_420pack_warn;
724   bool ARB_shading_language_packing_enable;
725   bool ARB_shading_language_packing_warn;
726   bool ARB_tessellation_shader_enable;
727   bool ARB_tessellation_shader_warn;
728   bool ARB_texture_cube_map_array_enable;
729   bool ARB_texture_cube_map_array_warn;
730   bool ARB_texture_gather_enable;
731   bool ARB_texture_gather_warn;
732   bool ARB_texture_multisample_enable;
733   bool ARB_texture_multisample_warn;
734   bool ARB_texture_query_levels_enable;
735   bool ARB_texture_query_levels_warn;
736   bool ARB_texture_query_lod_enable;
737   bool ARB_texture_query_lod_warn;
738   bool ARB_texture_rectangle_enable;
739   bool ARB_texture_rectangle_warn;
740   bool ARB_uniform_buffer_object_enable;
741   bool ARB_uniform_buffer_object_warn;
742   bool ARB_vertex_attrib_64bit_enable;
743   bool ARB_vertex_attrib_64bit_warn;
744   bool ARB_viewport_array_enable;
745   bool ARB_viewport_array_warn;
746
747   /* KHR extensions go here, sorted alphabetically.
748    */
749   bool KHR_blend_equation_advanced_enable;
750   bool KHR_blend_equation_advanced_warn;
751
752   /* OES extensions go here, sorted alphabetically.
753    */
754   bool OES_EGL_image_external_enable;
755   bool OES_EGL_image_external_warn;
756   bool OES_EGL_image_external_essl3_enable;
757   bool OES_EGL_image_external_essl3_warn;
758   bool OES_geometry_point_size_enable;
759   bool OES_geometry_point_size_warn;
760   bool OES_geometry_shader_enable;
761   bool OES_geometry_shader_warn;
762   bool OES_gpu_shader5_enable;
763   bool OES_gpu_shader5_warn;
764   bool OES_primitive_bounding_box_enable;
765   bool OES_primitive_bounding_box_warn;
766   bool OES_sample_variables_enable;
767   bool OES_sample_variables_warn;
768   bool OES_shader_image_atomic_enable;
769   bool OES_shader_image_atomic_warn;
770   bool OES_shader_io_blocks_enable;
771   bool OES_shader_io_blocks_warn;
772   bool OES_shader_multisample_interpolation_enable;
773   bool OES_shader_multisample_interpolation_warn;
774   bool OES_standard_derivatives_enable;
775   bool OES_standard_derivatives_warn;
776   bool OES_tessellation_point_size_enable;
777   bool OES_tessellation_point_size_warn;
778   bool OES_tessellation_shader_enable;
779   bool OES_tessellation_shader_warn;
780   bool OES_texture_3D_enable;
781   bool OES_texture_3D_warn;
782   bool OES_texture_buffer_enable;
783   bool OES_texture_buffer_warn;
784   bool OES_texture_cube_map_array_enable;
785   bool OES_texture_cube_map_array_warn;
786   bool OES_texture_storage_multisample_2d_array_enable;
787   bool OES_texture_storage_multisample_2d_array_warn;
788   bool OES_viewport_array_enable;
789   bool OES_viewport_array_warn;
790
791   /* All other extensions go here, sorted alphabetically.
792    */
793   bool AMD_conservative_depth_enable;
794   bool AMD_conservative_depth_warn;
795   bool AMD_gpu_shader_int64_enable;
796   bool AMD_gpu_shader_int64_warn;
797   bool AMD_shader_stencil_export_enable;
798   bool AMD_shader_stencil_export_warn;
799   bool AMD_shader_trinary_minmax_enable;
800   bool AMD_shader_trinary_minmax_warn;
801   bool AMD_texture_texture4_enable;
802   bool AMD_texture_texture4_warn;
803   bool AMD_vertex_shader_layer_enable;
804   bool AMD_vertex_shader_layer_warn;
805   bool AMD_vertex_shader_viewport_index_enable;
806   bool AMD_vertex_shader_viewport_index_warn;
807   bool ANDROID_extension_pack_es31a_enable;
808   bool ANDROID_extension_pack_es31a_warn;
809   bool EXT_blend_func_extended_enable;
810   bool EXT_blend_func_extended_warn;
811   bool EXT_clip_cull_distance_enable;
812   bool EXT_clip_cull_distance_warn;
813   bool EXT_draw_buffers_enable;
814   bool EXT_draw_buffers_warn;
815   bool EXT_frag_depth_enable;
816   bool EXT_frag_depth_warn;
817   bool EXT_geometry_point_size_enable;
818   bool EXT_geometry_point_size_warn;
819   bool EXT_geometry_shader_enable;
820   bool EXT_geometry_shader_warn;
821   bool EXT_gpu_shader4_enable;
822   bool EXT_gpu_shader4_warn;
823   bool EXT_gpu_shader5_enable;
824   bool EXT_gpu_shader5_warn;
825   bool EXT_primitive_bounding_box_enable;
826   bool EXT_primitive_bounding_box_warn;
827   bool EXT_separate_shader_objects_enable;
828   bool EXT_separate_shader_objects_warn;
829   bool EXT_shader_framebuffer_fetch_enable;
830   bool EXT_shader_framebuffer_fetch_warn;
831   bool EXT_shader_framebuffer_fetch_non_coherent_enable;
832   bool EXT_shader_framebuffer_fetch_non_coherent_warn;
833   bool EXT_shader_image_load_formatted_enable;
834   bool EXT_shader_image_load_formatted_warn;
835   bool EXT_shader_implicit_conversions_enable;
836   bool EXT_shader_implicit_conversions_warn;
837   bool EXT_shader_integer_mix_enable;
838   bool EXT_shader_integer_mix_warn;
839   bool EXT_shader_io_blocks_enable;
840   bool EXT_shader_io_blocks_warn;
841   bool EXT_shader_samples_identical_enable;
842   bool EXT_shader_samples_identical_warn;
843   bool EXT_tessellation_point_size_enable;
844   bool EXT_tessellation_point_size_warn;
845   bool EXT_tessellation_shader_enable;
846   bool EXT_tessellation_shader_warn;
847   bool EXT_texture_array_enable;
848   bool EXT_texture_array_warn;
849   bool EXT_texture_buffer_enable;
850   bool EXT_texture_buffer_warn;
851   bool EXT_texture_cube_map_array_enable;
852   bool EXT_texture_cube_map_array_warn;
853   bool EXT_texture_query_lod_enable;
854   bool EXT_texture_query_lod_warn;
855   bool INTEL_conservative_rasterization_enable;
856   bool INTEL_conservative_rasterization_warn;
857   bool INTEL_shader_atomic_float_minmax_enable;
858   bool INTEL_shader_atomic_float_minmax_warn;
859   bool MESA_shader_integer_functions_enable;
860   bool MESA_shader_integer_functions_warn;
861   bool NV_compute_shader_derivatives_enable;
862   bool NV_compute_shader_derivatives_warn;
863   bool NV_fragment_shader_interlock_enable;
864   bool NV_fragment_shader_interlock_warn;
865   bool NV_image_formats_enable;
866   bool NV_image_formats_warn;
867   bool NV_shader_atomic_float_enable;
868   bool NV_shader_atomic_float_warn;
869   /*@}*/
870
871   /** Extensions supported by the OpenGL implementation. */
872   const struct gl_extensions *extensions;
873
874   bool uses_builtin_functions;
875   bool fs_uses_gl_fragcoord;
876
877   /**
878    * For geometry shaders, size of the most recently seen input declaration
879    * that was a sized array, or 0 if no sized input array declarations have
880    * been seen.
881    *
882    * Unused for other shader types.
883    */
884   unsigned gs_input_size;
885
886   bool fs_early_fragment_tests;
887
888   bool fs_inner_coverage;
889
890   bool fs_post_depth_coverage;
891
892   bool fs_pixel_interlock_ordered;
893   bool fs_pixel_interlock_unordered;
894   bool fs_sample_interlock_ordered;
895   bool fs_sample_interlock_unordered;
896
897   unsigned fs_blend_support;
898
899   /**
900    * For tessellation control shaders, size of the most recently seen output
901    * declaration that was a sized array, or 0 if no sized output array
902    * declarations have been seen.
903    *
904    * Unused for other shader types.
905    */
906   unsigned tcs_output_size;
907
908   /** Atomic counter offsets by binding */
909   unsigned atomic_counter_offsets[MAX_COMBINED_ATOMIC_BUFFERS];
910
911   bool allow_extension_directive_midshader;
912   bool allow_builtin_variable_redeclaration;
913   bool allow_layout_qualifier_on_function_parameter;
914
915   /**
916    * Known subroutine type declarations.
917    */
918   int num_subroutine_types;
919   ir_function **subroutine_types;
920
921   /**
922    * Functions that are associated with
923    * subroutine types.
924    */
925   int num_subroutines;
926   ir_function **subroutines;
927
928   /**
929    * field selection temporary parser storage -
930    * did the parser just parse a dot.
931    */
932   bool is_field;
933
934   /**
935    * seen values for clip/cull distance sizes
936    * so we can check totals aren't too large.
937    */
938   unsigned clip_dist_size, cull_dist_size;
939};
940
941# define YYLLOC_DEFAULT(Current, Rhs, N)                        \
942do {                                                            \
943   if (N)                                                       \
944   {                                                            \
945      (Current).first_line   = YYRHSLOC(Rhs, 1).first_line;     \
946      (Current).first_column = YYRHSLOC(Rhs, 1).first_column;   \
947      (Current).last_line    = YYRHSLOC(Rhs, N).last_line;      \
948      (Current).last_column  = YYRHSLOC(Rhs, N).last_column;    \
949   }                                                            \
950   else                                                         \
951   {                                                            \
952      (Current).first_line   = (Current).last_line =            \
953         YYRHSLOC(Rhs, 0).last_line;                            \
954      (Current).first_column = (Current).last_column =          \
955         YYRHSLOC(Rhs, 0).last_column;                          \
956   }                                                            \
957   (Current).source = 0;                                        \
958} while (0)
959
960/**
961 * Emit a warning to the shader log
962 *
963 * \sa _mesa_glsl_error
964 */
965extern void _mesa_glsl_warning(const YYLTYPE *locp,
966                               _mesa_glsl_parse_state *state,
967                               const char *fmt, ...);
968
969extern void _mesa_glsl_lexer_ctor(struct _mesa_glsl_parse_state *state,
970                                  const char *string);
971
972extern void _mesa_glsl_lexer_dtor(struct _mesa_glsl_parse_state *state);
973
974union YYSTYPE;
975extern int _mesa_glsl_lexer_lex(union YYSTYPE *yylval, YYLTYPE *yylloc,
976                                void *scanner);
977
978extern int _mesa_glsl_parse(struct _mesa_glsl_parse_state *);
979
980/**
981 * Process elements of the #extension directive
982 *
983 * \return
984 * If \c name and \c behavior are valid, \c true is returned.  Otherwise
985 * \c false is returned.
986 */
987extern bool _mesa_glsl_process_extension(const char *name, YYLTYPE *name_locp,
988                                         const char *behavior,
989                                         YYLTYPE *behavior_locp,
990                                         _mesa_glsl_parse_state *state);
991
992#endif /* __cplusplus */
993
994
995/*
996 * These definitions apply to C and C++
997 */
998#ifdef __cplusplus
999extern "C" {
1000#endif
1001
1002struct glcpp_parser;
1003struct _mesa_glsl_parse_state;
1004
1005typedef void (*glcpp_extension_iterator)(
1006              struct _mesa_glsl_parse_state *state,
1007              void (*add_builtin_define)(struct glcpp_parser *, const char *, int),
1008              struct glcpp_parser *data,
1009              unsigned version,
1010              bool es);
1011
1012extern int glcpp_preprocess(void *ctx, const char **shader, char **info_log,
1013                            glcpp_extension_iterator extensions,
1014                            struct _mesa_glsl_parse_state *state,
1015                            struct gl_context *gl_ctx);
1016
1017extern void _mesa_init_shader_compiler_types(void);
1018extern void _mesa_destroy_shader_compiler_types(void);
1019extern void _mesa_destroy_shader_compiler(void);
1020extern void _mesa_destroy_shader_compiler_caches(void);
1021
1022extern void
1023_mesa_glsl_copy_symbols_from_table(struct exec_list *shader_ir,
1024                                   struct glsl_symbol_table *src,
1025                                   struct glsl_symbol_table *dest);
1026
1027#ifdef __cplusplus
1028}
1029#endif
1030
1031
1032#endif /* GLSL_PARSER_EXTRAS_H */
1033