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