2 * Mesa 3-D graphics library
5 * Copyright (C) 1999-2008 Brian Paul All Rights Reserved.
7 * Permission is hereby granted, free of charge, to any person obtaining a
8 * copy of this software and associated documentation files (the "Software"),
9 * to deal in the Software without restriction, including without limitation
10 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
11 * and/or sell copies of the Software, and to permit persons to whom the
12 * Software is furnished to do so, subject to the following conditions:
14 * The above copyright notice and this permission notice shall be included
15 * in all copies or substantial portions of the Software.
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
18 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
21 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
22 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25 #define DEBUG_PARSING 0
28 * \file arbprogparse.c
29 * ARB_*_program parser core
33 #include "main/glheader.h"
34 #include "main/imports.h"
35 #include "shader/grammar/grammar_mesa.h"
36 #include "arbprogparse.h"
38 #include "programopt.h"
39 #include "prog_parameter.h"
40 #include "prog_statevars.h"
41 #include "main/context.h"
42 #include "main/macros.h"
43 #include "main/mtypes.h"
44 #include "prog_instruction.h"
47 /* For ARB programs, use the NV instruction limits */
48 #define MAX_INSTRUCTIONS MAX2(MAX_NV_FRAGMENT_PROGRAM_INSTRUCTIONS, \
49 MAX_NV_VERTEX_PROGRAM_INSTRUCTIONS)
53 * This is basically a union of the vertex_program and fragment_program
54 * structs that we can use to parse the program into
56 * XXX we can probably get rid of this entirely someday.
60 struct gl_program Base
;
62 GLuint Position
; /* Just used for error reporting while parsing */
66 /* ARB_vertex_progmra options */
67 GLboolean HintPositionInvariant
;
69 /* ARB_fragment_progmra options */
70 GLenum PrecisionOption
; /* GL_DONT_CARE, GL_NICEST or GL_FASTEST */
71 GLenum FogOption
; /* GL_NONE, GL_LINEAR, GL_EXP or GL_EXP2 */
73 /* ARB_fragment_program specifics */
74 GLbitfield TexturesUsed
[MAX_TEXTURE_IMAGE_UNITS
];
75 GLbitfield ShadowSamplers
;
76 GLuint NumAluInstructions
;
77 GLuint NumTexInstructions
;
78 GLuint NumTexIndirections
;
86 * Fragment Program Stuff:
87 * -----------------------------------------------------
89 * - things from Michal's email
91 * + not-overflowing floats (don't use parse_integer..)
92 * + can remove range checking in arbparse.c
94 * - check all limits of number of various variables
99 * Vertex Program Stuff:
100 * -----------------------------------------------------
101 * - Optimize param array usage and count limits correctly, see spec,
103 * + Record if an array is reference absolutly or relatively (or both)
104 * + For absolute arrays, store a bitmap of accesses
105 * + For single parameters, store an access flag
106 * + After parsing, make a parameter cleanup and merging pass, where
107 * relative arrays are layed out first, followed by abs arrays, and
108 * finally single state.
109 * + Remap offsets for param src and dst registers
110 * + Now we can properly count parameter usage
112 * - Multiple state binding errors in param arrays (see spec, just before
117 * -----------------------------------------------------
118 * - User clipping planes vs. PositionInvariant
119 * - Is it sufficient to just multiply by the mvp to transform in the
120 * PositionInvariant case? Or do we need something more involved?
122 * - vp_src swizzle is GLubyte, fp_src swizzle is GLuint
123 * - fetch state listed in program_parameters list
124 * + WTF should this go???
125 * + currently in nvvertexec.c and s_nvfragprog.c
127 * - allow for multiple address registers (and fetch address regs properly)
130 * -----------------------------------------------------
131 * - remove any leftover unused grammer.c stuff (dict_ ?)
132 * - fix grammer.c error handling so its not static
133 * - #ifdef around stuff pertaining to extentions
135 * Outstanding Questions:
136 * -----------------------------------------------------
137 * - ARB_matrix_palette / ARB_vertex_blend -- not supported
138 * what gets hacked off because of this:
139 * + VERTEX_ATTRIB_MATRIXINDEX
140 * + VERTEX_ATTRIB_WEIGHT
144 * - When can we fetch env/local params from their own register files, and
145 * when to we have to fetch them into the main state register file?
149 * -----------------------------------------------------
152 /* Changes since moving the file to shader directory
154 2004-III-4 ------------------------------------------------------------
155 - added #include "grammar_mesa.h"
156 - removed grammar specific code part (it resides now in grammar.c)
157 - added GL_ARB_fragment_program_shadow tokens
158 - modified #include "arbparse_syn.h"
159 - major changes inside _mesa_parse_arb_program()
160 - check the program string for '\0' characters
161 - copy the program string to a one-byte-longer location to have
163 - position invariance test (not writing to result.position) moved
167 typedef GLubyte
*production
;
171 * This is the text describing the rules to parse the grammar
173 LONGSTRING
static char arb_grammar_text
[] =
174 #include "arbprogram_syn.h"
178 * These should match up with the values defined in arbprogram.syn
183 - changed and merged V_* and F_* opcode values to OP_*.
184 - added GL_ARB_fragment_program_shadow specific tokens (michal)
186 #define REVISION 0x0a
189 #define FRAGMENT_PROGRAM 0x01
190 #define VERTEX_PROGRAM 0x02
192 /* program section */
194 #define INSTRUCTION 0x02
195 #define DECLARATION 0x03
198 /* GL_ARB_fragment_program option */
199 #define ARB_PRECISION_HINT_FASTEST 0x00
200 #define ARB_PRECISION_HINT_NICEST 0x01
201 #define ARB_FOG_EXP 0x02
202 #define ARB_FOG_EXP2 0x03
203 #define ARB_FOG_LINEAR 0x04
205 /* GL_ARB_vertex_program option */
206 #define ARB_POSITION_INVARIANT 0x05
208 /* GL_ARB_fragment_program_shadow option */
209 #define ARB_FRAGMENT_PROGRAM_SHADOW 0x06
211 /* GL_ARB_draw_buffers option */
212 #define ARB_DRAW_BUFFERS 0x07
214 /* GL_MESA_texture_array option */
215 #define MESA_TEXTURE_ARRAY 0x08
217 /* GL_ARB_fragment_program instruction class */
218 #define OP_ALU_INST 0x00
219 #define OP_TEX_INST 0x01
221 /* GL_ARB_vertex_program instruction class */
224 /* GL_ARB_fragment_program instruction type */
225 #define OP_ALU_VECTOR 0x00
226 #define OP_ALU_SCALAR 0x01
227 #define OP_ALU_BINSC 0x02
228 #define OP_ALU_BIN 0x03
229 #define OP_ALU_TRI 0x04
230 #define OP_ALU_SWZ 0x05
231 #define OP_TEX_SAMPLE 0x06
232 #define OP_TEX_KIL 0x07
234 /* GL_ARB_vertex_program instruction type */
235 #define OP_ALU_ARL 0x08
243 /* GL_ARB_fragment_program instruction code */
245 #define OP_ABS_SAT 0x1B
247 #define OP_FLR_SAT 0x26
249 #define OP_FRC_SAT 0x27
251 #define OP_LIT_SAT 0x2A
253 #define OP_MOV_SAT 0x30
255 #define OP_COS_SAT 0x20
257 #define OP_EX2_SAT 0x25
259 #define OP_LG2_SAT 0x29
261 #define OP_RCP_SAT 0x33
263 #define OP_RSQ_SAT 0x34
265 #define OP_SIN_SAT 0x39
267 #define OP_SCS_SAT 0x36
269 #define OP_POW_SAT 0x32
271 #define OP_ADD_SAT 0x1C
273 #define OP_DP3_SAT 0x21
275 #define OP_DP4_SAT 0x22
277 #define OP_DPH_SAT 0x23
279 #define OP_DST_SAT 0x24
281 #define OP_MAX_SAT 0x2E
283 #define OP_MIN_SAT 0x2F
285 #define OP_MUL_SAT 0x31
287 #define OP_SGE_SAT 0x37
289 #define OP_SLT_SAT 0x3A
291 #define OP_SUB_SAT 0x3B
293 #define OP_XPD_SAT 0x43
295 #define OP_CMP_SAT 0x1E
297 #define OP_LRP_SAT 0x2C
299 #define OP_MAD_SAT 0x2D
301 #define OP_SWZ_SAT 0x3C
303 #define OP_TEX_SAT 0x3E
305 #define OP_TXB_SAT 0x40
307 #define OP_TXP_SAT 0x42
310 /* GL_ARB_vertex_program instruction code */
339 /* fragment attribute binding */
340 #define FRAGMENT_ATTRIB_COLOR 0x01
341 #define FRAGMENT_ATTRIB_TEXCOORD 0x02
342 #define FRAGMENT_ATTRIB_FOGCOORD 0x03
343 #define FRAGMENT_ATTRIB_POSITION 0x04
345 /* vertex attribute binding */
346 #define VERTEX_ATTRIB_POSITION 0x01
347 #define VERTEX_ATTRIB_WEIGHT 0x02
348 #define VERTEX_ATTRIB_NORMAL 0x03
349 #define VERTEX_ATTRIB_COLOR 0x04
350 #define VERTEX_ATTRIB_FOGCOORD 0x05
351 #define VERTEX_ATTRIB_TEXCOORD 0x06
352 #define VERTEX_ATTRIB_MATRIXINDEX 0x07
353 #define VERTEX_ATTRIB_GENERIC 0x08
355 /* fragment result binding */
356 #define FRAGMENT_RESULT_COLOR 0x01
357 #define FRAGMENT_RESULT_DEPTH 0x02
359 /* vertex result binding */
360 #define VERTEX_RESULT_POSITION 0x01
361 #define VERTEX_RESULT_COLOR 0x02
362 #define VERTEX_RESULT_FOGCOORD 0x03
363 #define VERTEX_RESULT_POINTSIZE 0x04
364 #define VERTEX_RESULT_TEXCOORD 0x05
367 #define TEXTARGET_1D 0x01
368 #define TEXTARGET_2D 0x02
369 #define TEXTARGET_3D 0x03
370 #define TEXTARGET_RECT 0x04
371 #define TEXTARGET_CUBE 0x05
372 /* GL_ARB_fragment_program_shadow */
373 #define TEXTARGET_SHADOW1D 0x06
374 #define TEXTARGET_SHADOW2D 0x07
375 #define TEXTARGET_SHADOWRECT 0x08
376 /* GL_MESA_texture_array */
377 #define TEXTARGET_1D_ARRAY 0x09
378 #define TEXTARGET_2D_ARRAY 0x0a
379 #define TEXTARGET_SHADOW1D_ARRAY 0x0b
380 #define TEXTARGET_SHADOW2D_ARRAY 0x0c
383 #define FACE_FRONT 0x00
384 #define FACE_BACK 0x01
387 #define COLOR_PRIMARY 0x00
388 #define COLOR_SECONDARY 0x01
391 #define COMPONENT_X 0x00
392 #define COMPONENT_Y 0x01
393 #define COMPONENT_Z 0x02
394 #define COMPONENT_W 0x03
395 #define COMPONENT_0 0x04
396 #define COMPONENT_1 0x05
398 /* array index type */
399 #define ARRAY_INDEX_ABSOLUTE 0x00
400 #define ARRAY_INDEX_RELATIVE 0x01
403 #define MATRIX_MODELVIEW 0x01
404 #define MATRIX_PROJECTION 0x02
405 #define MATRIX_MVP 0x03
406 #define MATRIX_TEXTURE 0x04
407 #define MATRIX_PALETTE 0x05
408 #define MATRIX_PROGRAM 0x06
410 /* matrix modifier */
411 #define MATRIX_MODIFIER_IDENTITY 0x00
412 #define MATRIX_MODIFIER_INVERSE 0x01
413 #define MATRIX_MODIFIER_TRANSPOSE 0x02
414 #define MATRIX_MODIFIER_INVTRANS 0x03
417 #define CONSTANT_SCALAR 0x01
418 #define CONSTANT_VECTOR 0x02
420 /* program param type */
421 #define PROGRAM_PARAM_ENV 0x01
422 #define PROGRAM_PARAM_LOCAL 0x02
425 #define REGISTER_ATTRIB 0x01
426 #define REGISTER_PARAM 0x02
427 #define REGISTER_RESULT 0x03
428 #define REGISTER_ESTABLISHED_NAME 0x04
431 #define PARAM_NULL 0x00
432 #define PARAM_ARRAY_ELEMENT 0x01
433 #define PARAM_STATE_ELEMENT 0x02
434 #define PARAM_PROGRAM_ELEMENT 0x03
435 #define PARAM_PROGRAM_ELEMENTS 0x04
436 #define PARAM_CONSTANT 0x05
438 /* param state property */
439 #define STATE_MATERIAL_PARSER 0x01
440 #define STATE_LIGHT_PARSER 0x02
441 #define STATE_LIGHT_MODEL 0x03
442 #define STATE_LIGHT_PROD 0x04
443 #define STATE_FOG 0x05
444 #define STATE_MATRIX_ROWS 0x06
445 /* GL_ARB_fragment_program */
446 #define STATE_TEX_ENV 0x07
447 #define STATE_DEPTH 0x08
448 /* GL_ARB_vertex_program */
449 #define STATE_TEX_GEN 0x09
450 #define STATE_CLIP_PLANE 0x0A
451 #define STATE_POINT 0x0B
453 /* state material property */
454 #define MATERIAL_AMBIENT 0x01
455 #define MATERIAL_DIFFUSE 0x02
456 #define MATERIAL_SPECULAR 0x03
457 #define MATERIAL_EMISSION 0x04
458 #define MATERIAL_SHININESS 0x05
460 /* state light property */
461 #define LIGHT_AMBIENT 0x01
462 #define LIGHT_DIFFUSE 0x02
463 #define LIGHT_SPECULAR 0x03
464 #define LIGHT_POSITION 0x04
465 #define LIGHT_ATTENUATION 0x05
466 #define LIGHT_HALF 0x06
467 #define LIGHT_SPOT_DIRECTION 0x07
469 /* state light model property */
470 #define LIGHT_MODEL_AMBIENT 0x01
471 #define LIGHT_MODEL_SCENECOLOR 0x02
473 /* state light product property */
474 #define LIGHT_PROD_AMBIENT 0x01
475 #define LIGHT_PROD_DIFFUSE 0x02
476 #define LIGHT_PROD_SPECULAR 0x03
478 /* state texture environment property */
479 #define TEX_ENV_COLOR 0x01
481 /* state texture generation coord property */
482 #define TEX_GEN_EYE 0x01
483 #define TEX_GEN_OBJECT 0x02
485 /* state fog property */
486 #define FOG_COLOR 0x01
487 #define FOG_PARAMS 0x02
489 /* state depth property */
490 #define DEPTH_RANGE 0x01
492 /* state point parameters property */
493 #define POINT_SIZE 0x01
494 #define POINT_ATTENUATION 0x02
502 /* GL_ARB_vertex_program */
505 /*-----------------------------------------------------------------------
506 * From here on down is the semantic checking portion
511 * Variable Table Handling functions
526 * Setting an explicit field for each of the binding properties is a bit
527 * wasteful of space, but it should be much more clear when reading later on..
531 const GLubyte
*name
; /* don't free() - no need */
533 GLuint address_binding
; /* The index of the address register we should
535 GLuint attrib_binding
; /* For type vt_attrib, see nvfragprog.h for values */
536 GLuint attrib_is_generic
; /* If the attrib was specified through a generic
538 GLuint temp_binding
; /* The index of the temp register we are to use */
539 GLuint output_binding
; /* Output/result register number */
540 struct var_cache
*alias_binding
; /* For type vt_alias, points to the var_cache entry
541 * that this is aliased to */
542 GLuint param_binding_type
; /* {PROGRAM_STATE_VAR, PROGRAM_LOCAL_PARAM,
543 * PROGRAM_ENV_PARAM} */
544 GLuint param_binding_begin
; /* This is the offset into the program_parameter_list where
545 * the tokens representing our bound state (or constants)
547 GLuint param_binding_length
; /* This is how many entries in the the program_parameter_list
548 * we take up with our state tokens or constants. Note that
549 * this is _not_ the same as the number of param registers
550 * we eventually use */
551 struct var_cache
*next
;
555 var_cache_create (struct var_cache
**va
)
557 *va
= (struct var_cache
*) _mesa_malloc (sizeof (struct var_cache
));
560 (**va
).type
= vt_none
;
561 (**va
).attrib_binding
= ~0;
562 (**va
).attrib_is_generic
= 0;
563 (**va
).temp_binding
= ~0;
564 (**va
).output_binding
= ~0;
565 (**va
).param_binding_type
= ~0;
566 (**va
).param_binding_begin
= ~0;
567 (**va
).param_binding_length
= ~0;
568 (**va
).alias_binding
= NULL
;
574 var_cache_destroy (struct var_cache
**va
)
577 var_cache_destroy (&(**va
).next
);
584 var_cache_append (struct var_cache
**va
, struct var_cache
*nv
)
587 var_cache_append (&(**va
).next
, nv
);
592 static struct var_cache
*
593 var_cache_find (struct var_cache
*va
, const GLubyte
* name
)
595 /*struct var_cache *first = va;*/
598 if (!_mesa_strcmp ( (const char*) name
, (const char*) va
->name
)) {
599 if (va
->type
== vt_alias
)
600 return va
->alias_binding
;
613 * Called when an error is detected while parsing/compiling a program.
614 * Sets the ctx->Program.ErrorString field to descript and records a
615 * GL_INVALID_OPERATION error.
616 * \param position position of error in program string
617 * \param descrip verbose error description
620 program_error(GLcontext
*ctx
, GLint position
, const char *descrip
)
623 const char *prefix
= "glProgramString(", *suffix
= ")";
624 char *str
= (char *) _mesa_malloc(_mesa_strlen(descrip
) +
625 _mesa_strlen(prefix
) +
626 _mesa_strlen(suffix
) + 1);
628 _mesa_sprintf(str
, "%s%s%s", prefix
, descrip
, suffix
);
629 _mesa_error(ctx
, GL_INVALID_OPERATION
, str
);
633 _mesa_set_program_error(ctx
, position
, descrip
);
638 * As above, but with an extra string parameter for more info.
641 program_error2(GLcontext
*ctx
, GLint position
, const char *descrip
,
645 const char *prefix
= "glProgramString(", *suffix
= ")";
646 char *str
= (char *) _mesa_malloc(_mesa_strlen(descrip
) +
649 _mesa_strlen(prefix
) +
650 _mesa_strlen(suffix
) + 1);
652 _mesa_sprintf(str
, "%s%s: %s%s", prefix
, descrip
, var
, suffix
);
653 _mesa_error(ctx
, GL_INVALID_OPERATION
, str
);
658 char *str
= (char *) _mesa_malloc(_mesa_strlen(descrip
) +
660 _mesa_strlen(var
) + 1);
662 _mesa_sprintf(str
, "%s: %s", descrip
, var
);
664 _mesa_set_program_error(ctx
, position
, str
);
674 * constructs an integer from 4 GLubytes in LE format
677 parse_position (const GLubyte
** inst
)
681 value
= (GLuint
) (*(*inst
)++);
682 value
+= (GLuint
) (*(*inst
)++) * 0x100;
683 value
+= (GLuint
) (*(*inst
)++) * 0x10000;
684 value
+= (GLuint
) (*(*inst
)++) * 0x1000000;
690 * This will, given a string, lookup the string as a variable name in the
691 * var cache. If the name is found, the var cache node corresponding to the
692 * var name is returned. If it is not found, a new entry is allocated
694 * \param I Points into the binary array where the string identifier begins
695 * \param found 1 if the string was found in the var_cache, 0 if it was allocated
696 * \return The location on the var_cache corresponding the the string starting at I
698 static struct var_cache
*
699 parse_string (const GLubyte
** inst
, struct var_cache
**vc_head
,
700 struct arb_program
*Program
, GLuint
* found
)
702 const GLubyte
*i
= *inst
;
703 struct var_cache
*va
= NULL
;
706 *inst
+= _mesa_strlen ((char *) i
) + 1;
708 va
= var_cache_find (*vc_head
, i
);
716 var_cache_create (&va
);
717 va
->name
= (const GLubyte
*) i
;
719 var_cache_append (vc_head
, va
);
725 parse_string_without_adding (const GLubyte
** inst
, struct arb_program
*Program
)
727 const GLubyte
*i
= *inst
;
730 *inst
+= _mesa_strlen ((char *) i
) + 1;
736 * \return -1 if we parse '-', return 1 otherwise
739 parse_sign (const GLubyte
** inst
)
741 /*return *(*inst)++ != '+'; */
747 else if (**inst
== '+') {
756 * parses and returns signed integer
759 parse_integer (const GLubyte
** inst
, struct arb_program
*Program
)
764 /* check if *inst points to '+' or '-'
765 * if yes, grab the sign and increment *inst
767 sign
= parse_sign (inst
);
769 /* now check if *inst points to 0
770 * if yes, increment the *inst and return the default value
777 /* parse the integer as you normally would do it */
778 value
= _mesa_atoi (parse_string_without_adding (inst
, Program
));
780 /* now, after terminating 0 there is a position
781 * to parse it - parse_position()
783 Program
->Position
= parse_position (inst
);
789 Accumulate this string of digits, and return them as
790 a large integer represented in floating point (for range).
791 If scale is not NULL, also accumulates a power-of-ten
792 integer scale factor that represents the number of digits
796 parse_float_string(const GLubyte
** inst
, struct arb_program
*Program
, GLdouble
*scale
)
798 GLdouble value
= 0.0;
799 GLdouble oscale
= 1.0;
801 if (**inst
== 0) { /* this string of digits is empty-- do nothing */
804 else { /* nonempty string-- parse out the digits */
805 while (**inst
>= '0' && **inst
<= '9') {
806 GLubyte digit
= *((*inst
)++);
807 value
= value
* 10.0 + (GLint
) (digit
- '0');
810 assert(**inst
== 0); /* integer string should end with 0 */
811 (*inst
)++; /* skip over terminating 0 */
812 Program
->Position
= parse_position(inst
); /* skip position (from integer) */
820 Parse an unsigned floating-point number from this stream of tokenized
821 characters. Example floating-point formats supported:
829 parse_float (const GLubyte
** inst
, struct arb_program
*Program
)
832 GLdouble whole
, fraction
, fracScale
= 1.0;
834 whole
= parse_float_string(inst
, Program
, 0);
835 fraction
= parse_float_string(inst
, Program
, &fracScale
);
837 /* Parse signed exponent */
838 exponent
= parse_integer(inst
, Program
); /* This is the exponent */
840 /* Assemble parts of floating-point number: */
841 return (GLfloat
) ((whole
+ fraction
/ fracScale
) *
842 _mesa_pow(10.0, (GLfloat
) exponent
));
849 parse_signed_float (const GLubyte
** inst
, struct arb_program
*Program
)
851 GLint sign
= parse_sign (inst
);
852 GLfloat value
= parse_float (inst
, Program
);
857 * This picks out a constant value from the parsed array. The constant vector is r
858 * returned in the *values array, which should be of length 4.
860 * \param values - The 4 component vector with the constant value in it
863 parse_constant (const GLubyte
** inst
, GLfloat
*values
, struct arb_program
*Program
,
866 GLuint components
, i
;
869 switch (*(*inst
)++) {
870 case CONSTANT_SCALAR
:
871 if (use
== GL_TRUE
) {
874 values
[2] = values
[3] = parse_float (inst
, Program
);
879 values
[2] = values
[3] = parse_signed_float (inst
, Program
);
883 case CONSTANT_VECTOR
:
884 values
[0] = values
[1] = values
[2] = 0;
886 components
= *(*inst
)++;
887 for (i
= 0; i
< components
; i
++) {
888 values
[i
] = parse_signed_float (inst
, Program
);
895 * \param offset The offset from the address register that we should
898 * \return 0 on sucess, 1 on error
901 parse_relative_offset(GLcontext
*ctx
, const GLubyte
**inst
,
902 struct arb_program
*Program
, GLint
*offset
)
905 *offset
= parse_integer(inst
, Program
);
910 * \param color 0 if color type is primary, 1 if color type is secondary
911 * \return 0 on sucess, 1 on error
914 parse_color_type (GLcontext
* ctx
, const GLubyte
** inst
, struct arb_program
*Program
,
917 (void) ctx
; (void) Program
;
918 *color
= *(*inst
)++ != COLOR_PRIMARY
;
923 * Get an integer corresponding to a generic vertex attribute.
925 * \return 0 on sucess, 1 on error
928 parse_generic_attrib_num(GLcontext
*ctx
, const GLubyte
** inst
,
929 struct arb_program
*Program
, GLuint
*attrib
)
931 GLint i
= parse_integer(inst
, Program
);
933 if ((i
< 0) || (i
>= MAX_VERTEX_PROGRAM_ATTRIBS
))
935 program_error(ctx
, Program
->Position
,
936 "Invalid generic vertex attribute index");
940 *attrib
= (GLuint
) i
;
947 * \param color The index of the color buffer to write into
948 * \return 0 on sucess, 1 on error
951 parse_output_color_num (GLcontext
* ctx
, const GLubyte
** inst
,
952 struct arb_program
*Program
, GLuint
* color
)
954 GLint i
= parse_integer (inst
, Program
);
956 if ((i
< 0) || (i
>= (int)ctx
->Const
.MaxDrawBuffers
)) {
957 program_error(ctx
, Program
->Position
, "Invalid draw buffer index");
967 * \param coord The texture unit index
968 * \return 0 on sucess, 1 on error
971 parse_texcoord_num (GLcontext
* ctx
, const GLubyte
** inst
,
972 struct arb_program
*Program
, GLuint
* coord
)
974 GLint i
= parse_integer (inst
, Program
);
976 if ((i
< 0) || (i
>= (int)ctx
->Const
.MaxTextureUnits
)) {
977 program_error(ctx
, Program
->Position
, "Invalid texture unit index");
986 * \param coord The weight index
987 * \return 0 on sucess, 1 on error
990 parse_weight_num (GLcontext
* ctx
, const GLubyte
** inst
, struct arb_program
*Program
,
993 *coord
= parse_integer (inst
, Program
);
995 if ((*coord
< 0) || (*coord
>= 1)) {
996 program_error(ctx
, Program
->Position
, "Invalid weight index");
1004 * \param coord The clip plane index
1005 * \return 0 on sucess, 1 on error
1008 parse_clipplane_num (GLcontext
* ctx
, const GLubyte
** inst
,
1009 struct arb_program
*Program
, GLint
* coord
)
1011 *coord
= parse_integer (inst
, Program
);
1013 if ((*coord
< 0) || (*coord
>= (GLint
) ctx
->Const
.MaxClipPlanes
)) {
1014 program_error(ctx
, Program
->Position
, "Invalid clip plane index");
1023 * \return 0 on front face, 1 on back face
1026 parse_face_type (const GLubyte
** inst
)
1028 switch (*(*inst
)++) {
1040 * Given a matrix and a modifier token on the binary array, return tokens
1041 * that _mesa_fetch_state() [program.c] can understand.
1043 * \param matrix - the matrix we are talking about
1044 * \param matrix_idx - the index of the matrix we have (for texture & program matricies)
1045 * \param matrix_modifier - the matrix modifier (trans, inv, etc)
1046 * \return 0 on sucess, 1 on failure
1049 parse_matrix (GLcontext
* ctx
, const GLubyte
** inst
, struct arb_program
*Program
,
1050 GLint
* matrix
, GLint
* matrix_idx
, GLint
* matrix_modifier
)
1052 GLubyte mat
= *(*inst
)++;
1057 case MATRIX_MODELVIEW
:
1058 *matrix
= STATE_MODELVIEW_MATRIX
;
1059 *matrix_idx
= parse_integer (inst
, Program
);
1060 if (*matrix_idx
> 0) {
1061 program_error(ctx
, Program
->Position
,
1062 "ARB_vertex_blend not supported");
1067 case MATRIX_PROJECTION
:
1068 *matrix
= STATE_PROJECTION_MATRIX
;
1072 *matrix
= STATE_MVP_MATRIX
;
1075 case MATRIX_TEXTURE
:
1076 *matrix
= STATE_TEXTURE_MATRIX
;
1077 *matrix_idx
= parse_integer (inst
, Program
);
1078 if (*matrix_idx
>= (GLint
) ctx
->Const
.MaxTextureUnits
) {
1079 program_error(ctx
, Program
->Position
, "Invalid Texture Unit");
1080 /* bad *matrix_id */
1085 /* This is not currently supported (ARB_matrix_palette) */
1086 case MATRIX_PALETTE
:
1087 *matrix_idx
= parse_integer (inst
, Program
);
1088 program_error(ctx
, Program
->Position
,
1089 "ARB_matrix_palette not supported");
1093 case MATRIX_PROGRAM
:
1094 *matrix
= STATE_PROGRAM_MATRIX
;
1095 *matrix_idx
= parse_integer (inst
, Program
);
1096 if (*matrix_idx
>= (GLint
) ctx
->Const
.MaxProgramMatrices
) {
1097 program_error(ctx
, Program
->Position
, "Invalid Program Matrix");
1098 /* bad *matrix_idx */
1104 switch (*(*inst
)++) {
1105 case MATRIX_MODIFIER_IDENTITY
:
1106 *matrix_modifier
= 0;
1108 case MATRIX_MODIFIER_INVERSE
:
1109 *matrix_modifier
= STATE_MATRIX_INVERSE
;
1111 case MATRIX_MODIFIER_TRANSPOSE
:
1112 *matrix_modifier
= STATE_MATRIX_TRANSPOSE
;
1114 case MATRIX_MODIFIER_INVTRANS
:
1115 *matrix_modifier
= STATE_MATRIX_INVTRANS
;
1124 * This parses a state string (rather, the binary version of it) into
1125 * a 6-token sequence as described in _mesa_fetch_state() [program.c]
1127 * \param inst - the start in the binary arry to start working from
1128 * \param state_tokens - the storage for the 6-token state description
1129 * \return - 0 on sucess, 1 on error
1132 parse_state_single_item (GLcontext
* ctx
, const GLubyte
** inst
,
1133 struct arb_program
*Program
,
1134 gl_state_index state_tokens
[STATE_LENGTH
])
1136 GLubyte token
= *(*inst
)++;
1139 case STATE_MATERIAL_PARSER
:
1140 state_tokens
[0] = STATE_MATERIAL
;
1141 state_tokens
[1] = parse_face_type (inst
);
1142 switch (*(*inst
)++) {
1143 case MATERIAL_AMBIENT
:
1144 state_tokens
[2] = STATE_AMBIENT
;
1146 case MATERIAL_DIFFUSE
:
1147 state_tokens
[2] = STATE_DIFFUSE
;
1149 case MATERIAL_SPECULAR
:
1150 state_tokens
[2] = STATE_SPECULAR
;
1152 case MATERIAL_EMISSION
:
1153 state_tokens
[2] = STATE_EMISSION
;
1155 case MATERIAL_SHININESS
:
1156 state_tokens
[2] = STATE_SHININESS
;
1161 case STATE_LIGHT_PARSER
:
1162 state_tokens
[0] = STATE_LIGHT
;
1163 state_tokens
[1] = parse_integer (inst
, Program
);
1165 /* Check the value of state_tokens[1] against the # of lights */
1166 if (state_tokens
[1] >= (GLint
) ctx
->Const
.MaxLights
) {
1167 program_error(ctx
, Program
->Position
, "Invalid Light Number");
1168 /* bad state_tokens[1] */
1172 switch (*(*inst
)++) {
1174 state_tokens
[2] = STATE_AMBIENT
;
1177 state_tokens
[2] = STATE_DIFFUSE
;
1179 case LIGHT_SPECULAR
:
1180 state_tokens
[2] = STATE_SPECULAR
;
1182 case LIGHT_POSITION
:
1183 state_tokens
[2] = STATE_POSITION
;
1185 case LIGHT_ATTENUATION
:
1186 state_tokens
[2] = STATE_ATTENUATION
;
1189 state_tokens
[2] = STATE_HALF_VECTOR
;
1191 case LIGHT_SPOT_DIRECTION
:
1192 state_tokens
[2] = STATE_SPOT_DIRECTION
;
1197 case STATE_LIGHT_MODEL
:
1198 switch (*(*inst
)++) {
1199 case LIGHT_MODEL_AMBIENT
:
1200 state_tokens
[0] = STATE_LIGHTMODEL_AMBIENT
;
1202 case LIGHT_MODEL_SCENECOLOR
:
1203 state_tokens
[0] = STATE_LIGHTMODEL_SCENECOLOR
;
1204 state_tokens
[1] = parse_face_type (inst
);
1209 case STATE_LIGHT_PROD
:
1210 state_tokens
[0] = STATE_LIGHTPROD
;
1211 state_tokens
[1] = parse_integer (inst
, Program
);
1213 /* Check the value of state_tokens[1] against the # of lights */
1214 if (state_tokens
[1] >= (GLint
) ctx
->Const
.MaxLights
) {
1215 program_error(ctx
, Program
->Position
, "Invalid Light Number");
1216 /* bad state_tokens[1] */
1220 state_tokens
[2] = parse_face_type (inst
);
1221 switch (*(*inst
)++) {
1222 case LIGHT_PROD_AMBIENT
:
1223 state_tokens
[3] = STATE_AMBIENT
;
1225 case LIGHT_PROD_DIFFUSE
:
1226 state_tokens
[3] = STATE_DIFFUSE
;
1228 case LIGHT_PROD_SPECULAR
:
1229 state_tokens
[3] = STATE_SPECULAR
;
1236 switch (*(*inst
)++) {
1238 state_tokens
[0] = STATE_FOG_COLOR
;
1241 state_tokens
[0] = STATE_FOG_PARAMS
;
1247 state_tokens
[1] = parse_integer (inst
, Program
);
1248 switch (*(*inst
)++) {
1250 state_tokens
[0] = STATE_TEXENV_COLOR
;
1259 state_tokens
[0] = STATE_TEXGEN
;
1260 /*state_tokens[1] = parse_integer (inst, Program);*/ /* Texture Unit */
1262 if (parse_texcoord_num (ctx
, inst
, Program
, &coord
))
1264 state_tokens
[1] = coord
;
1269 /* 0 - s, 1 - t, 2 - r, 3 - q */
1272 if (type
== TEX_GEN_EYE
) {
1275 state_tokens
[2] = STATE_TEXGEN_EYE_S
;
1278 state_tokens
[2] = STATE_TEXGEN_EYE_T
;
1281 state_tokens
[2] = STATE_TEXGEN_EYE_R
;
1284 state_tokens
[2] = STATE_TEXGEN_EYE_Q
;
1287 _mesa_problem(ctx
, "bad texgen component in "
1288 "parse_state_single_item()");
1294 state_tokens
[2] = STATE_TEXGEN_OBJECT_S
;
1297 state_tokens
[2] = STATE_TEXGEN_OBJECT_T
;
1300 state_tokens
[2] = STATE_TEXGEN_OBJECT_R
;
1303 state_tokens
[2] = STATE_TEXGEN_OBJECT_Q
;
1306 _mesa_problem(ctx
, "bad texgen component in "
1307 "parse_state_single_item()");
1314 switch (*(*inst
)++) {
1316 state_tokens
[0] = STATE_DEPTH_RANGE
;
1321 case STATE_CLIP_PLANE
:
1322 state_tokens
[0] = STATE_CLIPPLANE
;
1323 if (parse_clipplane_num (ctx
, inst
, Program
,
1324 (GLint
*) &state_tokens
[1]))
1329 switch (*(*inst
)++) {
1331 state_tokens
[0] = STATE_POINT_SIZE
;
1334 case POINT_ATTENUATION
:
1335 state_tokens
[0] = STATE_POINT_ATTENUATION
;
1340 /* XXX: I think this is the correct format for a matrix row */
1341 case STATE_MATRIX_ROWS
:
1342 if (parse_matrix(ctx
, inst
, Program
,
1343 (GLint
*) &state_tokens
[0],
1344 (GLint
*) &state_tokens
[1],
1345 (GLint
*) &state_tokens
[4]))
1348 state_tokens
[2] = parse_integer (inst
, Program
); /* The first row to grab */
1350 if ((**inst
) != 0) { /* Either the last row, 0 */
1351 state_tokens
[3] = parse_integer (inst
, Program
);
1352 if (state_tokens
[3] < state_tokens
[2]) {
1353 program_error(ctx
, Program
->Position
,
1354 "Second matrix index less than the first");
1355 /* state_tokens[4] vs. state_tokens[3] */
1360 state_tokens
[3] = state_tokens
[2];
1370 * This parses a state string (rather, the binary version of it) into
1371 * a 6-token similar for the state fetching code in program.c
1373 * One might ask, why fetch these parameters into just like you fetch
1374 * state when they are already stored in other places?
1376 * Because of array offsets -> We can stick env/local parameters in the
1377 * middle of a parameter array and then index someplace into the array
1380 * One optimization might be to only do this for the cases where the
1381 * env/local parameters end up inside of an array, and leave the
1382 * single parameters (or arrays of pure env/local pareameters) in their
1383 * respective register files.
1385 * For ENV parameters, the format is:
1386 * state_tokens[0] = STATE_FRAGMENT_PROGRAM / STATE_VERTEX_PROGRAM
1387 * state_tokens[1] = STATE_ENV
1388 * state_tokens[2] = the parameter index
1390 * for LOCAL parameters, the format is:
1391 * state_tokens[0] = STATE_FRAGMENT_PROGRAM / STATE_VERTEX_PROGRAM
1392 * state_tokens[1] = STATE_LOCAL
1393 * state_tokens[2] = the parameter index
1395 * \param inst - the start in the binary arry to start working from
1396 * \param state_tokens - the storage for the 6-token state description
1397 * \return - 0 on sucess, 1 on failure
1400 parse_program_single_item (GLcontext
* ctx
, const GLubyte
** inst
,
1401 struct arb_program
*Program
,
1402 gl_state_index state_tokens
[STATE_LENGTH
])
1404 if (Program
->Base
.Target
== GL_FRAGMENT_PROGRAM_ARB
)
1405 state_tokens
[0] = STATE_FRAGMENT_PROGRAM
;
1407 state_tokens
[0] = STATE_VERTEX_PROGRAM
;
1410 switch (*(*inst
)++) {
1411 case PROGRAM_PARAM_ENV
:
1412 state_tokens
[1] = STATE_ENV
;
1413 state_tokens
[2] = parse_integer (inst
, Program
);
1415 /* Check state_tokens[2] against the number of ENV parameters available */
1416 if (((Program
->Base
.Target
== GL_FRAGMENT_PROGRAM_ARB
) &&
1417 (state_tokens
[2] >= (GLint
) ctx
->Const
.FragmentProgram
.MaxEnvParams
))
1419 ((Program
->Base
.Target
== GL_VERTEX_PROGRAM_ARB
) &&
1420 (state_tokens
[2] >= (GLint
) ctx
->Const
.VertexProgram
.MaxEnvParams
))) {
1421 program_error(ctx
, Program
->Position
,
1422 "Invalid Program Env Parameter");
1423 /* bad state_tokens[2] */
1429 case PROGRAM_PARAM_LOCAL
:
1430 state_tokens
[1] = STATE_LOCAL
;
1431 state_tokens
[2] = parse_integer (inst
, Program
);
1433 /* Check state_tokens[2] against the number of LOCAL parameters available */
1434 if (((Program
->Base
.Target
== GL_FRAGMENT_PROGRAM_ARB
) &&
1435 (state_tokens
[2] >= (GLint
) ctx
->Const
.FragmentProgram
.MaxLocalParams
))
1437 ((Program
->Base
.Target
== GL_VERTEX_PROGRAM_ARB
) &&
1438 (state_tokens
[2] >= (GLint
) ctx
->Const
.VertexProgram
.MaxLocalParams
))) {
1439 program_error(ctx
, Program
->Position
,
1440 "Invalid Program Local Parameter");
1441 /* bad state_tokens[2] */
1451 * For ARB_vertex_program, programs are not allowed to use both an explicit
1452 * vertex attribute and a generic vertex attribute corresponding to the same
1453 * state. See section 2.14.3.1 of the GL_ARB_vertex_program spec.
1455 * This will walk our var_cache and make sure that nobody does anything fishy.
1457 * \return 0 on sucess, 1 on error
1460 generic_attrib_check(struct var_cache
*vc_head
)
1463 struct var_cache
*curr
;
1464 GLboolean explicitAttrib
[MAX_VERTEX_PROGRAM_ATTRIBS
],
1465 genericAttrib
[MAX_VERTEX_PROGRAM_ATTRIBS
];
1467 for (a
=0; a
<MAX_VERTEX_PROGRAM_ATTRIBS
; a
++) {
1468 explicitAttrib
[a
] = GL_FALSE
;
1469 genericAttrib
[a
] = GL_FALSE
;
1474 if (curr
->type
== vt_attrib
) {
1475 if (curr
->attrib_is_generic
)
1476 genericAttrib
[ curr
->attrib_binding
] = GL_TRUE
;
1478 explicitAttrib
[ curr
->attrib_binding
] = GL_TRUE
;
1484 for (a
=0; a
<MAX_VERTEX_PROGRAM_ATTRIBS
; a
++) {
1485 if ((explicitAttrib
[a
]) && (genericAttrib
[a
]))
1493 * This will handle the binding side of an ATTRIB var declaration
1495 * \param inputReg returns the input register index, one of the
1496 * VERT_ATTRIB_* or FRAG_ATTRIB_* values.
1497 * \return returns 0 on success, 1 on error
1500 parse_attrib_binding(GLcontext
* ctx
, const GLubyte
** inst
,
1501 struct arb_program
*Program
,
1502 GLuint
*inputReg
, GLuint
*is_generic
)
1508 if (Program
->Base
.Target
== GL_FRAGMENT_PROGRAM_ARB
) {
1509 switch (*(*inst
)++) {
1510 case FRAGMENT_ATTRIB_COLOR
:
1513 err
= parse_color_type (ctx
, inst
, Program
, &coord
);
1514 *inputReg
= FRAG_ATTRIB_COL0
+ coord
;
1517 case FRAGMENT_ATTRIB_TEXCOORD
:
1519 GLuint texcoord
= 0;
1520 err
= parse_texcoord_num (ctx
, inst
, Program
, &texcoord
);
1521 *inputReg
= FRAG_ATTRIB_TEX0
+ texcoord
;
1524 case FRAGMENT_ATTRIB_FOGCOORD
:
1525 *inputReg
= FRAG_ATTRIB_FOGC
;
1527 case FRAGMENT_ATTRIB_POSITION
:
1528 *inputReg
= FRAG_ATTRIB_WPOS
;
1536 switch (*(*inst
)++) {
1537 case VERTEX_ATTRIB_POSITION
:
1538 *inputReg
= VERT_ATTRIB_POS
;
1541 case VERTEX_ATTRIB_WEIGHT
:
1544 err
= parse_weight_num (ctx
, inst
, Program
, &weight
);
1545 *inputReg
= VERT_ATTRIB_WEIGHT
;
1547 /* hack for Warcraft (see bug 8060) */
1548 _mesa_warning(ctx
, "Application error: vertex program uses 'vertex.weight' but GL_ARB_vertex_blend not supported.");
1551 program_error(ctx
, Program
->Position
,
1552 "ARB_vertex_blend not supported");
1557 case VERTEX_ATTRIB_NORMAL
:
1558 *inputReg
= VERT_ATTRIB_NORMAL
;
1561 case VERTEX_ATTRIB_COLOR
:
1564 err
= parse_color_type (ctx
, inst
, Program
, &color
);
1566 *inputReg
= VERT_ATTRIB_COLOR1
;
1569 *inputReg
= VERT_ATTRIB_COLOR0
;
1574 case VERTEX_ATTRIB_FOGCOORD
:
1575 *inputReg
= VERT_ATTRIB_FOG
;
1578 case VERTEX_ATTRIB_TEXCOORD
:
1581 err
= parse_texcoord_num (ctx
, inst
, Program
, &unit
);
1582 *inputReg
= VERT_ATTRIB_TEX0
+ unit
;
1586 case VERTEX_ATTRIB_MATRIXINDEX
:
1587 /* Not supported at this time */
1589 const char *msg
= "ARB_palette_matrix not supported";
1590 parse_integer (inst
, Program
);
1591 program_error(ctx
, Program
->Position
, msg
);
1595 case VERTEX_ATTRIB_GENERIC
:
1598 err
= parse_generic_attrib_num(ctx
, inst
, Program
, &attrib
);
1601 /* Add VERT_ATTRIB_GENERIC0 here because ARB_vertex_program's
1602 * attributes do not alias the conventional vertex
1606 *inputReg
= attrib
+ VERT_ATTRIB_GENERIC0
;
1620 program_error(ctx
, Program
->Position
, "Bad attribute binding");
1628 * This translates between a binary token for an output variable type
1629 * and the mesa token for the same thing.
1631 * \param inst The parsed tokens
1632 * \param outputReg Returned index/number of the output register,
1633 * one of the VERT_RESULT_* or FRAG_RESULT_* values.
1636 parse_result_binding(GLcontext
*ctx
, const GLubyte
**inst
,
1637 GLuint
*outputReg
, struct arb_program
*Program
)
1639 const GLubyte token
= *(*inst
)++;
1642 case FRAGMENT_RESULT_COLOR
:
1643 if (Program
->Base
.Target
== GL_FRAGMENT_PROGRAM_ARB
) {
1646 /* This gets result of the color buffer we're supposed to
1647 * draw into. This pertains to GL_ARB_draw_buffers.
1649 parse_output_color_num(ctx
, inst
, Program
, &out_color
);
1650 ASSERT(out_color
< MAX_DRAW_BUFFERS
);
1651 *outputReg
= FRAG_RESULT_COLR
;
1654 /* for vtx programs, this is VERTEX_RESULT_POSITION */
1655 *outputReg
= VERT_RESULT_HPOS
;
1659 case FRAGMENT_RESULT_DEPTH
:
1660 if (Program
->Base
.Target
== GL_FRAGMENT_PROGRAM_ARB
) {
1661 /* for frag programs, this is FRAGMENT_RESULT_DEPTH */
1662 *outputReg
= FRAG_RESULT_DEPR
;
1665 /* for vtx programs, this is VERTEX_RESULT_COLOR */
1667 GLuint face_type
= parse_face_type(inst
);
1668 GLint err
= parse_color_type(ctx
, inst
, Program
, &color_type
);
1675 *outputReg
= VERT_RESULT_BFC1
; /* secondary color */
1678 *outputReg
= VERT_RESULT_BFC0
; /* primary color */
1684 *outputReg
= VERT_RESULT_COL1
; /* secondary color */
1688 *outputReg
= VERT_RESULT_COL0
; /* primary color */
1694 case VERTEX_RESULT_FOGCOORD
:
1695 *outputReg
= VERT_RESULT_FOGC
;
1698 case VERTEX_RESULT_POINTSIZE
:
1699 *outputReg
= VERT_RESULT_PSIZ
;
1702 case VERTEX_RESULT_TEXCOORD
:
1705 if (parse_texcoord_num (ctx
, inst
, Program
, &unit
))
1707 *outputReg
= VERT_RESULT_TEX0
+ unit
;
1712 Program
->Base
.OutputsWritten
|= (1 << *outputReg
);
1719 * This handles the declaration of ATTRIB variables
1722 * parse_vert_attrib_binding(), or something like that
1724 * \return 0 on sucess, 1 on error
1727 parse_attrib (GLcontext
* ctx
, const GLubyte
** inst
, struct var_cache
**vc_head
,
1728 struct arb_program
*Program
)
1731 struct var_cache
*attrib_var
;
1733 attrib_var
= parse_string (inst
, vc_head
, Program
, &found
);
1734 Program
->Position
= parse_position (inst
);
1736 program_error2(ctx
, Program
->Position
,
1737 "Duplicate variable declaration",
1738 (char *) attrib_var
->name
);
1742 attrib_var
->type
= vt_attrib
;
1744 if (parse_attrib_binding(ctx
, inst
, Program
, &attrib_var
->attrib_binding
,
1745 &attrib_var
->attrib_is_generic
))
1748 if (generic_attrib_check(*vc_head
)) {
1749 program_error(ctx
, Program
->Position
,
1750 "Cannot use both a generic vertex attribute "
1751 "and a specific attribute of the same type");
1755 Program
->Base
.NumAttributes
++;
1760 * \param use -- TRUE if we're called when declaring implicit parameters,
1761 * FALSE if we're declaraing variables. This has to do with
1762 * if we get a signed or unsigned float for scalar constants
1765 parse_param_elements (GLcontext
* ctx
, const GLubyte
** inst
,
1766 struct var_cache
*param_var
,
1767 struct arb_program
*Program
, GLboolean use
)
1771 gl_state_index state_tokens
[STATE_LENGTH
] = {0, 0, 0, 0, 0};
1772 GLfloat const_values
[4];
1774 GLubyte token
= *(*inst
)++;
1777 case PARAM_STATE_ELEMENT
:
1778 if (parse_state_single_item (ctx
, inst
, Program
, state_tokens
))
1781 /* If we adding STATE_MATRIX that has multiple rows, we need to
1782 * unroll it and call _mesa_add_state_reference() for each row
1784 if ((state_tokens
[0] == STATE_MODELVIEW_MATRIX
||
1785 state_tokens
[0] == STATE_PROJECTION_MATRIX
||
1786 state_tokens
[0] == STATE_MVP_MATRIX
||
1787 state_tokens
[0] == STATE_TEXTURE_MATRIX
||
1788 state_tokens
[0] == STATE_PROGRAM_MATRIX
)
1789 && (state_tokens
[2] != state_tokens
[3])) {
1791 const GLint first_row
= state_tokens
[2];
1792 const GLint last_row
= state_tokens
[3];
1794 for (row
= first_row
; row
<= last_row
; row
++) {
1795 state_tokens
[2] = state_tokens
[3] = row
;
1797 idx
= _mesa_add_state_reference(Program
->Base
.Parameters
,
1799 if (param_var
->param_binding_begin
== ~0U)
1800 param_var
->param_binding_begin
= idx
;
1801 param_var
->param_binding_length
++;
1802 Program
->Base
.NumParameters
++;
1806 idx
= _mesa_add_state_reference(Program
->Base
.Parameters
,
1808 if (param_var
->param_binding_begin
== ~0U)
1809 param_var
->param_binding_begin
= idx
;
1810 param_var
->param_binding_length
++;
1811 Program
->Base
.NumParameters
++;
1815 case PARAM_PROGRAM_ELEMENT
:
1816 if (parse_program_single_item (ctx
, inst
, Program
, state_tokens
))
1818 idx
= _mesa_add_state_reference (Program
->Base
.Parameters
, state_tokens
);
1819 if (param_var
->param_binding_begin
== ~0U)
1820 param_var
->param_binding_begin
= idx
;
1821 param_var
->param_binding_length
++;
1822 Program
->Base
.NumParameters
++;
1824 /* Check if there is more: 0 -> we're done, else its an integer */
1826 GLuint out_of_range
, new_idx
;
1827 GLuint start_idx
= state_tokens
[2] + 1;
1828 GLuint end_idx
= parse_integer (inst
, Program
);
1831 if (Program
->Base
.Target
== GL_FRAGMENT_PROGRAM_ARB
) {
1832 if (((state_tokens
[1] == STATE_ENV
)
1833 && (end_idx
>= ctx
->Const
.FragmentProgram
.MaxEnvParams
))
1834 || ((state_tokens
[1] == STATE_LOCAL
)
1836 ctx
->Const
.FragmentProgram
.MaxLocalParams
)))
1840 if (((state_tokens
[1] == STATE_ENV
)
1841 && (end_idx
>= ctx
->Const
.VertexProgram
.MaxEnvParams
))
1842 || ((state_tokens
[1] == STATE_LOCAL
)
1844 ctx
->Const
.VertexProgram
.MaxLocalParams
)))
1848 program_error(ctx
, Program
->Position
,
1849 "Invalid Program Parameter"); /*end_idx*/
1853 for (new_idx
= start_idx
; new_idx
<= end_idx
; new_idx
++) {
1854 state_tokens
[2] = new_idx
;
1855 idx
= _mesa_add_state_reference(Program
->Base
.Parameters
,
1857 param_var
->param_binding_length
++;
1858 Program
->Base
.NumParameters
++;
1866 case PARAM_CONSTANT
:
1867 /* parsing something like {1.0, 2.0, 3.0, 4.0} */
1868 parse_constant (inst
, const_values
, Program
, use
);
1869 idx
= _mesa_add_named_constant(Program
->Base
.Parameters
,
1870 (char *) param_var
->name
,
1872 if (param_var
->param_binding_begin
== ~0U)
1873 param_var
->param_binding_begin
= idx
;
1874 param_var
->param_binding_type
= PROGRAM_CONSTANT
;
1875 param_var
->param_binding_length
++;
1876 Program
->Base
.NumParameters
++;
1880 program_error(ctx
, Program
->Position
,
1881 "Unexpected token (in parse_param_elements())");
1885 /* Make sure we haven't blown past our parameter limits */
1886 if (((Program
->Base
.Target
== GL_VERTEX_PROGRAM_ARB
) &&
1887 (Program
->Base
.NumParameters
>=
1888 ctx
->Const
.VertexProgram
.MaxLocalParams
))
1889 || ((Program
->Base
.Target
== GL_FRAGMENT_PROGRAM_ARB
)
1890 && (Program
->Base
.NumParameters
>=
1891 ctx
->Const
.FragmentProgram
.MaxLocalParams
))) {
1892 program_error(ctx
, Program
->Position
, "Too many parameter variables");
1901 * This picks out PARAM program parameter bindings.
1903 * XXX: This needs to be stressed & tested
1905 * \return 0 on sucess, 1 on error
1908 parse_param (GLcontext
* ctx
, const GLubyte
** inst
, struct var_cache
**vc_head
,
1909 struct arb_program
*Program
)
1912 GLint specified_length
;
1913 struct var_cache
*param_var
;
1916 param_var
= parse_string (inst
, vc_head
, Program
, &found
);
1917 Program
->Position
= parse_position (inst
);
1920 program_error2(ctx
, Program
->Position
,
1921 "Duplicate variable declaration",
1922 (char *) param_var
->name
);
1926 specified_length
= parse_integer (inst
, Program
);
1928 if (specified_length
< 0) {
1929 program_error(ctx
, Program
->Position
, "Negative parameter array length");
1933 param_var
->type
= vt_param
;
1934 param_var
->param_binding_length
= 0;
1936 /* Right now, everything is shoved into the main state register file.
1938 * In the future, it would be nice to leave things ENV/LOCAL params
1939 * in their respective register files, if possible
1941 param_var
->param_binding_type
= PROGRAM_STATE_VAR
;
1944 * * - add each guy to the parameter list
1945 * * - increment the param_var->param_binding_len
1946 * * - store the param_var->param_binding_begin for the first one
1947 * * - compare the actual len to the specified len at the end
1949 while (**inst
!= PARAM_NULL
) {
1950 if (parse_param_elements (ctx
, inst
, param_var
, Program
, GL_FALSE
))
1954 /* Test array length here! */
1955 if (specified_length
) {
1956 if (specified_length
!= (int)param_var
->param_binding_length
) {
1957 program_error(ctx
, Program
->Position
,
1958 "Declared parameter array length does not match parameter list");
1971 parse_param_use (GLcontext
* ctx
, const GLubyte
** inst
, struct var_cache
**vc_head
,
1972 struct arb_program
*Program
, struct var_cache
**new_var
)
1974 struct var_cache
*param_var
;
1976 /* First, insert a dummy entry into the var_cache */
1977 var_cache_create (¶m_var
);
1978 param_var
->name
= (const GLubyte
*) " ";
1979 param_var
->type
= vt_param
;
1981 param_var
->param_binding_length
= 0;
1982 /* Don't fill in binding_begin; We use the default value of -1
1983 * to tell if its already initialized, elsewhere.
1985 * param_var->param_binding_begin = 0;
1987 param_var
->param_binding_type
= PROGRAM_STATE_VAR
;
1989 var_cache_append (vc_head
, param_var
);
1991 /* Then fill it with juicy parameter goodness */
1992 if (parse_param_elements (ctx
, inst
, param_var
, Program
, GL_TRUE
))
1995 *new_var
= param_var
;
2002 * This handles the declaration of TEMP variables
2004 * \return 0 on sucess, 1 on error
2007 parse_temp (GLcontext
* ctx
, const GLubyte
** inst
, struct var_cache
**vc_head
,
2008 struct arb_program
*Program
)
2011 struct var_cache
*temp_var
;
2013 while (**inst
!= 0) {
2014 temp_var
= parse_string (inst
, vc_head
, Program
, &found
);
2015 Program
->Position
= parse_position (inst
);
2017 program_error2(ctx
, Program
->Position
,
2018 "Duplicate variable declaration",
2019 (char *) temp_var
->name
);
2023 temp_var
->type
= vt_temp
;
2025 if (((Program
->Base
.Target
== GL_FRAGMENT_PROGRAM_ARB
) &&
2026 (Program
->Base
.NumTemporaries
>=
2027 ctx
->Const
.FragmentProgram
.MaxTemps
))
2028 || ((Program
->Base
.Target
== GL_VERTEX_PROGRAM_ARB
)
2029 && (Program
->Base
.NumTemporaries
>=
2030 ctx
->Const
.VertexProgram
.MaxTemps
))) {
2031 program_error(ctx
, Program
->Position
,
2032 "Too many TEMP variables declared");
2036 temp_var
->temp_binding
= Program
->Base
.NumTemporaries
;
2037 Program
->Base
.NumTemporaries
++;
2045 * This handles variables of the OUTPUT variety
2047 * \return 0 on sucess, 1 on error
2050 parse_output (GLcontext
* ctx
, const GLubyte
** inst
, struct var_cache
**vc_head
,
2051 struct arb_program
*Program
)
2054 struct var_cache
*output_var
;
2057 output_var
= parse_string (inst
, vc_head
, Program
, &found
);
2058 Program
->Position
= parse_position (inst
);
2060 program_error2(ctx
, Program
->Position
,
2061 "Duplicate variable declaration",
2062 (char *) output_var
->name
);
2066 output_var
->type
= vt_output
;
2068 err
= parse_result_binding(ctx
, inst
, &output_var
->output_binding
, Program
);
2073 * This handles variables of the ALIAS kind
2075 * \return 0 on sucess, 1 on error
2078 parse_alias (GLcontext
* ctx
, const GLubyte
** inst
, struct var_cache
**vc_head
,
2079 struct arb_program
*Program
)
2082 struct var_cache
*temp_var
;
2084 temp_var
= parse_string (inst
, vc_head
, Program
, &found
);
2085 Program
->Position
= parse_position (inst
);
2088 program_error2(ctx
, Program
->Position
,
2089 "Duplicate variable declaration",
2090 (char *) temp_var
->name
);
2094 temp_var
->type
= vt_alias
;
2095 temp_var
->alias_binding
= parse_string (inst
, vc_head
, Program
, &found
);
2096 Program
->Position
= parse_position (inst
);
2100 program_error2(ctx
, Program
->Position
,
2101 "Undefined alias value",
2102 (char *) temp_var
->alias_binding
->name
);
2110 * This handles variables of the ADDRESS kind
2112 * \return 0 on sucess, 1 on error
2115 parse_address (GLcontext
* ctx
, const GLubyte
** inst
, struct var_cache
**vc_head
,
2116 struct arb_program
*Program
)
2119 struct var_cache
*temp_var
;
2121 while (**inst
!= 0) {
2122 temp_var
= parse_string (inst
, vc_head
, Program
, &found
);
2123 Program
->Position
= parse_position (inst
);
2125 program_error2(ctx
, Program
->Position
,
2126 "Duplicate variable declaration",
2127 (char *) temp_var
->name
);
2131 temp_var
->type
= vt_address
;
2133 if (Program
->Base
.NumAddressRegs
>=
2134 ctx
->Const
.VertexProgram
.MaxAddressRegs
) {
2135 const char *msg
= "Too many ADDRESS variables declared";
2136 program_error(ctx
, Program
->Position
, msg
);
2140 temp_var
->address_binding
= Program
->Base
.NumAddressRegs
;
2141 Program
->Base
.NumAddressRegs
++;
2149 * Parse a program declaration
2151 * \return 0 on sucess, 1 on error
2154 parse_declaration (GLcontext
* ctx
, const GLubyte
** inst
, struct var_cache
**vc_head
,
2155 struct arb_program
*Program
)
2159 switch (*(*inst
)++) {
2161 err
= parse_address (ctx
, inst
, vc_head
, Program
);
2165 err
= parse_alias (ctx
, inst
, vc_head
, Program
);
2169 err
= parse_attrib (ctx
, inst
, vc_head
, Program
);
2173 err
= parse_output (ctx
, inst
, vc_head
, Program
);
2177 err
= parse_param (ctx
, inst
, vc_head
, Program
);
2181 err
= parse_temp (ctx
, inst
, vc_head
, Program
);
2189 * Handle the parsing out of a masked destination register, either for a
2190 * vertex or fragment program.
2192 * If we are a vertex program, make sure we don't write to
2193 * result.position if we have specified that the program is
2194 * position invariant
2196 * \param File - The register file we write to
2197 * \param Index - The register index we write to
2198 * \param WriteMask - The mask controlling which components we write (1->write)
2200 * \return 0 on sucess, 1 on error
2203 parse_masked_dst_reg (GLcontext
* ctx
, const GLubyte
** inst
,
2204 struct var_cache
**vc_head
, struct arb_program
*Program
,
2205 enum register_file
*File
, GLuint
*Index
, GLint
*WriteMask
)
2208 struct var_cache
*dst
;
2210 /* We either have a result register specified, or a
2211 * variable that may or may not be writable
2213 switch (*(*inst
)++) {
2214 case REGISTER_RESULT
:
2215 if (parse_result_binding(ctx
, inst
, Index
, Program
))
2217 *File
= PROGRAM_OUTPUT
;
2220 case REGISTER_ESTABLISHED_NAME
:
2221 dst
= parse_string (inst
, vc_head
, Program
, &result
);
2222 Program
->Position
= parse_position (inst
);
2224 /* If the name has never been added to our symbol table, we're hosed */
2226 program_error(ctx
, Program
->Position
, "0: Undefined variable");
2230 switch (dst
->type
) {
2232 *File
= PROGRAM_OUTPUT
;
2233 *Index
= dst
->output_binding
;
2237 *File
= PROGRAM_TEMPORARY
;
2238 *Index
= dst
->temp_binding
;
2241 /* If the var type is not vt_output or vt_temp, no go */
2243 program_error(ctx
, Program
->Position
,
2244 "Destination register is read only");
2250 program_error(ctx
, Program
->Position
,
2251 "Unexpected opcode in parse_masked_dst_reg()");
2256 /* Position invariance test */
2257 /* This test is done now in syntax portion - when position invariance OPTION
2258 is specified, "result.position" rule is disabled so there is no way
2259 to write the position
2261 /*if ((Program->HintPositionInvariant) && (*File == PROGRAM_OUTPUT) &&
2263 program_error(ctx, Program->Position,
2264 "Vertex program specified position invariance and wrote vertex position");
2267 /* And then the mask.
2273 * ==> Need to reverse the order of bits for this!
2275 tmp
= (GLint
) *(*inst
)++;
2276 *WriteMask
= (((tmp
>>3) & 0x1) |
2286 * Handle the parsing of a address register
2288 * \param Index - The register index we write to
2290 * \return 0 on sucess, 1 on error
2293 parse_address_reg (GLcontext
* ctx
, const GLubyte
** inst
,
2294 struct var_cache
**vc_head
,
2295 struct arb_program
*Program
, GLint
* Index
)
2297 struct var_cache
*dst
;
2300 *Index
= 0; /* XXX */
2302 dst
= parse_string (inst
, vc_head
, Program
, &result
);
2303 Program
->Position
= parse_position (inst
);
2305 /* If the name has never been added to our symbol table, we're hosed */
2307 program_error(ctx
, Program
->Position
, "Undefined variable");
2311 if (dst
->type
!= vt_address
) {
2312 program_error(ctx
, Program
->Position
, "Variable is not of type ADDRESS");
2321 * Handle the parsing out of a masked address register
2323 * \param Index - The register index we write to
2324 * \param WriteMask - The mask controlling which components we write (1->write)
2326 * \return 0 on sucess, 1 on error
2329 parse_masked_address_reg (GLcontext
* ctx
, const GLubyte
** inst
,
2330 struct var_cache
**vc_head
,
2331 struct arb_program
*Program
, GLint
* Index
,
2332 GLboolean
* WriteMask
)
2334 if (parse_address_reg (ctx
, inst
, vc_head
, Program
, Index
))
2337 /* This should be 0x8 */
2340 /* Writemask of .x is implied */
2342 WriteMask
[1] = WriteMask
[2] = WriteMask
[3] = 0;
2349 * Parse out a swizzle mask.
2351 * Basically convert COMPONENT_X/Y/Z/W to SWIZZLE_X/Y/Z/W
2353 * The len parameter allows us to grab 4 components for a vector
2354 * swizzle, or just 1 component for a scalar src register selection
2357 parse_swizzle_mask(const GLubyte
** inst
, GLubyte
*swizzle
, GLint len
)
2361 for (i
= 0; i
< 4; i
++)
2364 for (i
= 0; i
< len
; i
++) {
2365 switch (*(*inst
)++) {
2367 swizzle
[i
] = SWIZZLE_X
;
2370 swizzle
[i
] = SWIZZLE_Y
;
2373 swizzle
[i
] = SWIZZLE_Z
;
2376 swizzle
[i
] = SWIZZLE_W
;
2379 _mesa_problem(NULL
, "bad component in parse_swizzle_mask()");
2387 * Parse an extended swizzle mask which is a sequence of
2388 * four x/y/z/w/0/1 tokens.
2389 * \return swizzle four swizzle values
2390 * \return negateMask four element bitfield
2393 parse_extended_swizzle_mask(const GLubyte
**inst
, GLubyte swizzle
[4],
2394 GLubyte
*negateMask
)
2399 for (i
= 0; i
< 4; i
++) {
2401 if (parse_sign(inst
) == -1)
2402 *negateMask
|= (1 << i
);
2408 swizzle
[i
] = SWIZZLE_ZERO
;
2411 swizzle
[i
] = SWIZZLE_ONE
;
2414 swizzle
[i
] = SWIZZLE_X
;
2417 swizzle
[i
] = SWIZZLE_Y
;
2420 swizzle
[i
] = SWIZZLE_Z
;
2423 swizzle
[i
] = SWIZZLE_W
;
2426 _mesa_problem(NULL
, "bad case in parse_extended_swizzle_mask()");
2434 parse_src_reg (GLcontext
* ctx
, const GLubyte
** inst
,
2435 struct var_cache
**vc_head
,
2436 struct arb_program
*Program
,
2437 enum register_file
* File
, GLint
* Index
,
2438 GLboolean
*IsRelOffset
)
2440 struct var_cache
*src
;
2441 GLuint binding
, is_generic
, found
;
2446 /* And the binding for the src */
2447 switch (*(*inst
)++) {
2448 case REGISTER_ATTRIB
:
2449 if (parse_attrib_binding
2450 (ctx
, inst
, Program
, &binding
, &is_generic
))
2452 *File
= PROGRAM_INPUT
;
2455 /* We need to insert a dummy variable into the var_cache so we can
2456 * catch generic vertex attrib aliasing errors
2458 var_cache_create(&src
);
2459 src
->type
= vt_attrib
;
2460 src
->name
= (const GLubyte
*) "Dummy Attrib Variable";
2461 src
->attrib_binding
= binding
;
2462 src
->attrib_is_generic
= is_generic
;
2463 var_cache_append(vc_head
, src
);
2464 if (generic_attrib_check(*vc_head
)) {
2465 program_error(ctx
, Program
->Position
,
2466 "Cannot use both a generic vertex attribute "
2467 "and a specific attribute of the same type");
2472 case REGISTER_PARAM
:
2474 case PARAM_ARRAY_ELEMENT
:
2476 src
= parse_string (inst
, vc_head
, Program
, &found
);
2477 Program
->Position
= parse_position (inst
);
2480 program_error2(ctx
, Program
->Position
,
2481 "Undefined variable",
2482 (char *) src
->name
);
2486 *File
= (enum register_file
) src
->param_binding_type
;
2488 switch (*(*inst
)++) {
2489 case ARRAY_INDEX_ABSOLUTE
:
2490 offset
= parse_integer (inst
, Program
);
2493 || (offset
>= (int)src
->param_binding_length
)) {
2494 program_error(ctx
, Program
->Position
,
2495 "Index out of range");
2496 /* offset, src->name */
2500 *Index
= src
->param_binding_begin
+ offset
;
2503 case ARRAY_INDEX_RELATIVE
:
2505 GLint addr_reg_idx
, rel_off
;
2507 /* First, grab the address regiseter */
2508 if (parse_address_reg (ctx
, inst
, vc_head
, Program
, &addr_reg_idx
))
2517 /* Then the relative offset */
2518 if (parse_relative_offset(ctx
, inst
, Program
, &rel_off
)) return 1;
2520 /* And store it properly */
2521 *Index
= src
->param_binding_begin
+ rel_off
;
2529 if (parse_param_use (ctx
, inst
, vc_head
, Program
, &src
))
2532 *File
= (enum register_file
) src
->param_binding_type
;
2533 *Index
= src
->param_binding_begin
;
2538 case REGISTER_ESTABLISHED_NAME
:
2539 src
= parse_string (inst
, vc_head
, Program
, &found
);
2540 Program
->Position
= parse_position (inst
);
2542 /* If the name has never been added to our symbol table, we're hosed */
2544 program_error(ctx
, Program
->Position
,
2545 "3: Undefined variable"); /* src->name */
2549 switch (src
->type
) {
2551 *File
= PROGRAM_INPUT
;
2552 *Index
= src
->attrib_binding
;
2555 /* XXX: We have to handle offsets someplace in here! -- or are those above? */
2557 *File
= (enum register_file
) src
->param_binding_type
;
2558 *Index
= src
->param_binding_begin
;
2562 *File
= PROGRAM_TEMPORARY
;
2563 *Index
= src
->temp_binding
;
2566 /* If the var type is vt_output no go */
2568 program_error(ctx
, Program
->Position
,
2569 "destination register is read only");
2576 program_error(ctx
, Program
->Position
,
2577 "Unknown token in parse_src_reg");
2581 /* Add attributes to InputsRead only if they are used the program.
2582 * This avoids the handling of unused ATTRIB declarations in the drivers. */
2583 if (*File
== PROGRAM_INPUT
)
2584 Program
->Base
.InputsRead
|= (1 << *Index
);
2591 * Parse vertex/fragment program vector source register.
2594 parse_vector_src_reg(GLcontext
*ctx
, const GLubyte
**inst
,
2595 struct var_cache
**vc_head
,
2596 struct arb_program
*program
,
2597 struct prog_src_register
*reg
)
2599 enum register_file file
;
2603 GLboolean isRelOffset
;
2606 negateMask
= (parse_sign (inst
) == -1) ? NEGATE_XYZW
: NEGATE_NONE
;
2608 /* And the src reg */
2609 if (parse_src_reg(ctx
, inst
, vc_head
, program
, &file
, &index
, &isRelOffset
))
2612 /* finally, the swizzle */
2613 parse_swizzle_mask(inst
, swizzle
, 4);
2617 reg
->Swizzle
= MAKE_SWIZZLE4(swizzle
[0], swizzle
[1], swizzle
[2], swizzle
[3]);
2618 reg
->NegateBase
= negateMask
;
2619 reg
->RelAddr
= isRelOffset
;
2625 * Parse vertex/fragment program scalar source register.
2628 parse_scalar_src_reg(GLcontext
*ctx
, const GLubyte
**inst
,
2629 struct var_cache
**vc_head
,
2630 struct arb_program
*program
,
2631 struct prog_src_register
*reg
)
2633 enum register_file file
;
2637 GLboolean isRelOffset
;
2640 negateMask
= (parse_sign (inst
) == -1) ? NEGATE_XYZW
: NEGATE_NONE
;
2642 /* And the src reg */
2643 if (parse_src_reg(ctx
, inst
, vc_head
, program
, &file
, &index
, &isRelOffset
))
2646 /* finally, the swizzle */
2647 parse_swizzle_mask(inst
, swizzle
, 1);
2651 reg
->Swizzle
= (swizzle
[0] << 0);
2652 reg
->NegateBase
= negateMask
;
2653 reg
->RelAddr
= isRelOffset
;
2659 * Parse vertex/fragment program destination register.
2660 * \return 1 if error, 0 if no error.
2663 parse_dst_reg(GLcontext
* ctx
, const GLubyte
** inst
,
2664 struct var_cache
**vc_head
, struct arb_program
*program
,
2665 struct prog_dst_register
*reg
)
2669 enum register_file file
;
2671 if (parse_masked_dst_reg (ctx
, inst
, vc_head
, program
, &file
, &idx
, &mask
))
2676 reg
->WriteMask
= mask
;
2682 * This is a big mother that handles getting opcodes into the instruction
2683 * and handling the src & dst registers for fragment program instructions
2684 * \return 1 if error, 0 if no error
2687 parse_fp_instruction (GLcontext
* ctx
, const GLubyte
** inst
,
2688 struct var_cache
**vc_head
, struct arb_program
*Program
,
2689 struct prog_instruction
*fp
)
2693 GLubyte instClass
, type
, code
;
2695 GLuint shadow_tex
= 0;
2697 _mesa_init_instructions(fp
, 1);
2699 /* Record the position in the program string for debugging */
2700 fp
->StringPos
= Program
->Position
;
2702 /* OP_ALU_INST or OP_TEX_INST */
2703 instClass
= *(*inst
)++;
2705 /* OP_ALU_{VECTOR, SCALAR, BINSC, BIN, TRI, SWZ},
2706 * OP_TEX_{SAMPLE, KIL}
2710 /* The actual opcode name */
2713 /* Increment the correct count */
2714 switch (instClass
) {
2716 Program
->NumAluInstructions
++;
2719 Program
->NumTexInstructions
++;
2727 fp
->SaturateMode
= SATURATE_ZERO_ONE
;
2729 fp
->Opcode
= OPCODE_ABS
;
2733 fp
->SaturateMode
= SATURATE_ZERO_ONE
;
2735 fp
->Opcode
= OPCODE_FLR
;
2739 fp
->SaturateMode
= SATURATE_ZERO_ONE
;
2741 fp
->Opcode
= OPCODE_FRC
;
2745 fp
->SaturateMode
= SATURATE_ZERO_ONE
;
2747 fp
->Opcode
= OPCODE_LIT
;
2751 fp
->SaturateMode
= SATURATE_ZERO_ONE
;
2753 fp
->Opcode
= OPCODE_MOV
;
2757 if (parse_dst_reg (ctx
, inst
, vc_head
, Program
, &fp
->DstReg
))
2760 if (parse_vector_src_reg(ctx
, inst
, vc_head
, Program
, &fp
->SrcReg
[0]))
2767 fp
->SaturateMode
= SATURATE_ZERO_ONE
;
2769 fp
->Opcode
= OPCODE_COS
;
2773 fp
->SaturateMode
= SATURATE_ZERO_ONE
;
2775 fp
->Opcode
= OPCODE_EX2
;
2779 fp
->SaturateMode
= SATURATE_ZERO_ONE
;
2781 fp
->Opcode
= OPCODE_LG2
;
2785 fp
->SaturateMode
= SATURATE_ZERO_ONE
;
2787 fp
->Opcode
= OPCODE_RCP
;
2791 fp
->SaturateMode
= SATURATE_ZERO_ONE
;
2793 fp
->Opcode
= OPCODE_RSQ
;
2797 fp
->SaturateMode
= SATURATE_ZERO_ONE
;
2799 fp
->Opcode
= OPCODE_SIN
;
2803 fp
->SaturateMode
= SATURATE_ZERO_ONE
;
2806 fp
->Opcode
= OPCODE_SCS
;
2810 if (parse_dst_reg (ctx
, inst
, vc_head
, Program
, &fp
->DstReg
))
2813 if (parse_scalar_src_reg(ctx
, inst
, vc_head
, Program
, &fp
->SrcReg
[0]))
2820 fp
->SaturateMode
= SATURATE_ZERO_ONE
;
2822 fp
->Opcode
= OPCODE_POW
;
2826 if (parse_dst_reg(ctx
, inst
, vc_head
, Program
, &fp
->DstReg
))
2829 for (a
= 0; a
< 2; a
++) {
2830 if (parse_scalar_src_reg(ctx
, inst
, vc_head
, Program
, &fp
->SrcReg
[a
]))
2839 fp
->SaturateMode
= SATURATE_ZERO_ONE
;
2841 fp
->Opcode
= OPCODE_ADD
;
2845 fp
->SaturateMode
= SATURATE_ZERO_ONE
;
2847 fp
->Opcode
= OPCODE_DP3
;
2851 fp
->SaturateMode
= SATURATE_ZERO_ONE
;
2853 fp
->Opcode
= OPCODE_DP4
;
2857 fp
->SaturateMode
= SATURATE_ZERO_ONE
;
2859 fp
->Opcode
= OPCODE_DPH
;
2863 fp
->SaturateMode
= SATURATE_ZERO_ONE
;
2865 fp
->Opcode
= OPCODE_DST
;
2869 fp
->SaturateMode
= SATURATE_ZERO_ONE
;
2871 fp
->Opcode
= OPCODE_MAX
;
2875 fp
->SaturateMode
= SATURATE_ZERO_ONE
;
2877 fp
->Opcode
= OPCODE_MIN
;
2881 fp
->SaturateMode
= SATURATE_ZERO_ONE
;
2883 fp
->Opcode
= OPCODE_MUL
;
2887 fp
->SaturateMode
= SATURATE_ZERO_ONE
;
2889 fp
->Opcode
= OPCODE_SGE
;
2893 fp
->SaturateMode
= SATURATE_ZERO_ONE
;
2895 fp
->Opcode
= OPCODE_SLT
;
2899 fp
->SaturateMode
= SATURATE_ZERO_ONE
;
2901 fp
->Opcode
= OPCODE_SUB
;
2905 fp
->SaturateMode
= SATURATE_ZERO_ONE
;
2907 fp
->Opcode
= OPCODE_XPD
;
2911 if (parse_dst_reg (ctx
, inst
, vc_head
, Program
, &fp
->DstReg
))
2913 for (a
= 0; a
< 2; a
++) {
2914 if (parse_vector_src_reg(ctx
, inst
, vc_head
, Program
, &fp
->SrcReg
[a
]))
2922 fp
->SaturateMode
= SATURATE_ZERO_ONE
;
2924 fp
->Opcode
= OPCODE_CMP
;
2928 fp
->SaturateMode
= SATURATE_ZERO_ONE
;
2930 fp
->Opcode
= OPCODE_LRP
;
2934 fp
->SaturateMode
= SATURATE_ZERO_ONE
;
2936 fp
->Opcode
= OPCODE_MAD
;
2940 if (parse_dst_reg (ctx
, inst
, vc_head
, Program
, &fp
->DstReg
))
2943 for (a
= 0; a
< 3; a
++) {
2944 if (parse_vector_src_reg(ctx
, inst
, vc_head
, Program
, &fp
->SrcReg
[a
]))
2952 fp
->SaturateMode
= SATURATE_ZERO_ONE
;
2954 fp
->Opcode
= OPCODE_SWZ
;
2957 if (parse_dst_reg (ctx
, inst
, vc_head
, Program
, &fp
->DstReg
))
2963 enum register_file file
;
2966 if (parse_src_reg(ctx
, inst
, vc_head
, Program
, &file
, &index
, &rel
))
2968 parse_extended_swizzle_mask(inst
, swizzle
, &negateMask
);
2969 fp
->SrcReg
[0].File
= file
;
2970 fp
->SrcReg
[0].Index
= index
;
2971 fp
->SrcReg
[0].NegateBase
= negateMask
;
2972 fp
->SrcReg
[0].Swizzle
= MAKE_SWIZZLE4(swizzle
[0],
2982 fp
->SaturateMode
= SATURATE_ZERO_ONE
;
2984 fp
->Opcode
= OPCODE_TEX
;
2988 fp
->SaturateMode
= SATURATE_ZERO_ONE
;
2990 fp
->Opcode
= OPCODE_TXP
;
2994 fp
->SaturateMode
= SATURATE_ZERO_ONE
;
2996 fp
->Opcode
= OPCODE_TXB
;
3000 if (parse_dst_reg (ctx
, inst
, vc_head
, Program
, &fp
->DstReg
))
3003 if (parse_vector_src_reg(ctx
, inst
, vc_head
, Program
, &fp
->SrcReg
[0]))
3007 if (parse_texcoord_num (ctx
, inst
, Program
, &texcoord
))
3009 fp
->TexSrcUnit
= texcoord
;
3012 switch (*(*inst
)++) {
3013 case TEXTARGET_SHADOW1D
:
3014 shadow_tex
= 1 << texcoord
;
3017 fp
->TexSrcTarget
= TEXTURE_1D_INDEX
;
3019 case TEXTARGET_SHADOW2D
:
3020 shadow_tex
= 1 << texcoord
;
3023 fp
->TexSrcTarget
= TEXTURE_2D_INDEX
;
3026 fp
->TexSrcTarget
= TEXTURE_3D_INDEX
;
3028 case TEXTARGET_SHADOWRECT
:
3029 shadow_tex
= 1 << texcoord
;
3031 case TEXTARGET_RECT
:
3032 fp
->TexSrcTarget
= TEXTURE_RECT_INDEX
;
3034 case TEXTARGET_CUBE
:
3035 fp
->TexSrcTarget
= TEXTURE_CUBE_INDEX
;
3037 case TEXTARGET_SHADOW1D_ARRAY
:
3038 shadow_tex
= 1 << texcoord
;
3040 case TEXTARGET_1D_ARRAY
:
3041 fp
->TexSrcTarget
= TEXTURE_1D_ARRAY_INDEX
;
3043 case TEXTARGET_SHADOW2D_ARRAY
:
3044 shadow_tex
= 1 << texcoord
;
3046 case TEXTARGET_2D_ARRAY
:
3047 fp
->TexSrcTarget
= TEXTURE_2D_ARRAY_INDEX
;
3051 /* Don't test the first time a particular sampler is seen. Each time
3052 * after that, make sure the shadow state is the same.
3054 if ((_mesa_bitcount(Program
->TexturesUsed
[texcoord
]) > 0)
3055 && ((Program
->ShadowSamplers
& (1 << texcoord
)) != shadow_tex
)) {
3056 program_error(ctx
, Program
->Position
,
3057 "texture image unit used for shadow sampling and non-shadow sampling");
3061 Program
->TexturesUsed
[texcoord
] |= (1 << fp
->TexSrcTarget
);
3062 /* Check that both "2D" and "CUBE" (for example) aren't both used */
3063 if (_mesa_bitcount(Program
->TexturesUsed
[texcoord
]) > 1) {
3064 program_error(ctx
, Program
->Position
,
3065 "multiple targets used on one texture image unit");
3070 Program
->ShadowSamplers
|= shadow_tex
;
3074 Program
->UsesKill
= 1;
3075 if (parse_vector_src_reg(ctx
, inst
, vc_head
, Program
, &fp
->SrcReg
[0]))
3077 fp
->Opcode
= OPCODE_KIL
;
3080 _mesa_problem(ctx
, "bad type 0x%x in parse_fp_instruction()", type
);
3089 * Handle the parsing out of a masked address register
3091 * \param Index - The register index we write to
3092 * \param WriteMask - The mask controlling which components we write (1->write)
3094 * \return 0 on sucess, 1 on error
3097 parse_vp_address_reg (GLcontext
* ctx
, const GLubyte
** inst
,
3098 struct var_cache
**vc_head
,
3099 struct arb_program
*Program
,
3100 struct prog_dst_register
*reg
)
3104 if (parse_address_reg (ctx
, inst
, vc_head
, Program
, &idx
))
3107 /* This should be 0x8 */
3110 reg
->File
= PROGRAM_ADDRESS
;
3113 /* Writemask of .x is implied */
3114 reg
->WriteMask
= 0x1;
3120 * This is a big mother that handles getting opcodes into the instruction
3121 * and handling the src & dst registers for vertex program instructions
3124 parse_vp_instruction (GLcontext
* ctx
, const GLubyte
** inst
,
3125 struct var_cache
**vc_head
, struct arb_program
*Program
,
3126 struct prog_instruction
*vp
)
3131 /* OP_ALU_{ARL, VECTOR, SCALAR, BINSC, BIN, TRI, SWZ} */
3134 /* The actual opcode name */
3137 _mesa_init_instructions(vp
, 1);
3138 /* Record the position in the program string for debugging */
3139 vp
->StringPos
= Program
->Position
;
3144 vp
->Opcode
= OPCODE_ARL
;
3146 /* Remember to set SrcReg.RelAddr; */
3148 /* Get the masked address register [dst] */
3149 if (parse_vp_address_reg(ctx
, inst
, vc_head
, Program
, &vp
->DstReg
))
3152 vp
->DstReg
.File
= PROGRAM_ADDRESS
;
3154 /* Get a scalar src register */
3155 if (parse_scalar_src_reg(ctx
, inst
, vc_head
, Program
, &vp
->SrcReg
[0]))
3163 vp
->Opcode
= OPCODE_ABS
;
3166 vp
->Opcode
= OPCODE_FLR
;
3169 vp
->Opcode
= OPCODE_FRC
;
3172 vp
->Opcode
= OPCODE_LIT
;
3175 vp
->Opcode
= OPCODE_MOV
;
3179 if (parse_dst_reg(ctx
, inst
, vc_head
, Program
, &vp
->DstReg
))
3182 if (parse_vector_src_reg(ctx
, inst
, vc_head
, Program
, &vp
->SrcReg
[0]))
3189 vp
->Opcode
= OPCODE_EX2
;
3192 vp
->Opcode
= OPCODE_EXP
;
3195 vp
->Opcode
= OPCODE_LG2
;
3198 vp
->Opcode
= OPCODE_LOG
;
3201 vp
->Opcode
= OPCODE_RCP
;
3204 vp
->Opcode
= OPCODE_RSQ
;
3207 if (parse_dst_reg(ctx
, inst
, vc_head
, Program
, &vp
->DstReg
))
3210 if (parse_scalar_src_reg(ctx
, inst
, vc_head
, Program
, &vp
->SrcReg
[0]))
3217 vp
->Opcode
= OPCODE_POW
;
3220 if (parse_dst_reg(ctx
, inst
, vc_head
, Program
, &vp
->DstReg
))
3223 for (a
= 0; a
< 2; a
++) {
3224 if (parse_scalar_src_reg(ctx
, inst
, vc_head
, Program
, &vp
->SrcReg
[a
]))
3232 vp
->Opcode
= OPCODE_ADD
;
3235 vp
->Opcode
= OPCODE_DP3
;
3238 vp
->Opcode
= OPCODE_DP4
;
3241 vp
->Opcode
= OPCODE_DPH
;
3244 vp
->Opcode
= OPCODE_DST
;
3247 vp
->Opcode
= OPCODE_MAX
;
3250 vp
->Opcode
= OPCODE_MIN
;
3253 vp
->Opcode
= OPCODE_MUL
;
3256 vp
->Opcode
= OPCODE_SGE
;
3259 vp
->Opcode
= OPCODE_SLT
;
3262 vp
->Opcode
= OPCODE_SUB
;
3265 vp
->Opcode
= OPCODE_XPD
;
3268 if (parse_dst_reg(ctx
, inst
, vc_head
, Program
, &vp
->DstReg
))
3271 for (a
= 0; a
< 2; a
++) {
3272 if (parse_vector_src_reg(ctx
, inst
, vc_head
, Program
, &vp
->SrcReg
[a
]))
3280 vp
->Opcode
= OPCODE_MAD
;
3284 if (parse_dst_reg(ctx
, inst
, vc_head
, Program
, &vp
->DstReg
))
3287 for (a
= 0; a
< 3; a
++) {
3288 if (parse_vector_src_reg(ctx
, inst
, vc_head
, Program
, &vp
->SrcReg
[a
]))
3296 vp
->Opcode
= OPCODE_SWZ
;
3303 enum register_file file
;
3306 if (parse_dst_reg(ctx
, inst
, vc_head
, Program
, &vp
->DstReg
))
3309 if (parse_src_reg(ctx
, inst
, vc_head
, Program
, &file
, &index
, &relAddr
))
3311 parse_extended_swizzle_mask (inst
, swizzle
, &negateMask
);
3312 vp
->SrcReg
[0].File
= file
;
3313 vp
->SrcReg
[0].Index
= index
;
3314 vp
->SrcReg
[0].NegateBase
= negateMask
;
3315 vp
->SrcReg
[0].Swizzle
= MAKE_SWIZZLE4(swizzle
[0],
3319 vp
->SrcReg
[0].RelAddr
= relAddr
;
3329 debug_variables (GLcontext
* ctx
, struct var_cache
*vc_head
,
3330 struct arb_program
*Program
)
3332 struct var_cache
*vc
;
3335 fprintf (stderr
, "debug_variables, vc_head: %p\n", (void*) vc_head
);
3337 /* First of all, print out the contents of the var_cache */
3340 fprintf (stderr
, "[%p]\n", (void*) vc
);
3343 fprintf (stderr
, "UNDEFINED %s\n", vc
->name
);
3346 fprintf (stderr
, "ATTRIB %s\n", vc
->name
);
3347 fprintf (stderr
, " binding: 0x%x\n", vc
->attrib_binding
);
3350 fprintf (stderr
, "PARAM %s begin: %d len: %d\n", vc
->name
,
3351 vc
->param_binding_begin
, vc
->param_binding_length
);
3352 b
= vc
->param_binding_begin
;
3353 for (a
= 0; a
< vc
->param_binding_length
; a
++) {
3354 fprintf (stderr
, "%s\n",
3355 Program
->Base
.Parameters
->Parameters
[a
+ b
].Name
);
3356 if (Program
->Base
.Parameters
->Parameters
[a
+ b
].Type
== PROGRAM_STATE_VAR
) {
3358 s
= _mesa_program_state_string(Program
->Base
.Parameters
->Parameters
3359 [a
+ b
].StateIndexes
);
3360 fprintf(stderr
, "%s\n", s
);
3361 _mesa_free((char *) s
);
3364 fprintf (stderr
, "%f %f %f %f\n",
3365 Program
->Base
.Parameters
->ParameterValues
[a
+ b
][0],
3366 Program
->Base
.Parameters
->ParameterValues
[a
+ b
][1],
3367 Program
->Base
.Parameters
->ParameterValues
[a
+ b
][2],
3368 Program
->Base
.Parameters
->ParameterValues
[a
+ b
][3]);
3372 fprintf (stderr
, "TEMP %s\n", vc
->name
);
3373 fprintf (stderr
, " binding: 0x%x\n", vc
->temp_binding
);
3376 fprintf (stderr
, "OUTPUT %s\n", vc
->name
);
3377 fprintf (stderr
, " binding: 0x%x\n", vc
->output_binding
);
3380 fprintf (stderr
, "ALIAS %s\n", vc
->name
);
3381 fprintf (stderr
, " binding: 0x%p (%s)\n",
3382 (void*) vc
->alias_binding
, vc
->alias_binding
->name
);
3392 #endif /* DEBUG_PARSING */
3396 * The main loop for parsing a fragment or vertex program
3398 * \return 1 on error, 0 on success
3401 parse_instructions(GLcontext
* ctx
, const GLubyte
* inst
,
3402 struct var_cache
**vc_head
, struct arb_program
*Program
)
3404 const GLuint maxInst
= (Program
->Base
.Target
== GL_FRAGMENT_PROGRAM_ARB
)
3405 ? ctx
->Const
.FragmentProgram
.MaxInstructions
3406 : ctx
->Const
.VertexProgram
.MaxInstructions
;
3409 ASSERT(MAX_INSTRUCTIONS
>= maxInst
);
3411 Program
->MajorVersion
= (GLuint
) * inst
++;
3412 Program
->MinorVersion
= (GLuint
) * inst
++;
3414 while (*inst
!= END
) {
3419 case ARB_PRECISION_HINT_FASTEST
:
3420 Program
->PrecisionOption
= GL_FASTEST
;
3423 case ARB_PRECISION_HINT_NICEST
:
3424 Program
->PrecisionOption
= GL_NICEST
;
3428 Program
->FogOption
= GL_EXP
;
3432 Program
->FogOption
= GL_EXP2
;
3435 case ARB_FOG_LINEAR
:
3436 Program
->FogOption
= GL_LINEAR
;
3439 case ARB_POSITION_INVARIANT
:
3440 if (Program
->Base
.Target
== GL_VERTEX_PROGRAM_ARB
)
3441 Program
->HintPositionInvariant
= GL_TRUE
;
3444 case ARB_FRAGMENT_PROGRAM_SHADOW
:
3445 if (Program
->Base
.Target
== GL_FRAGMENT_PROGRAM_ARB
) {
3446 /* TODO ARB_fragment_program_shadow code */
3450 case ARB_DRAW_BUFFERS
:
3451 if (Program
->Base
.Target
== GL_FRAGMENT_PROGRAM_ARB
) {
3452 /* do nothing for now */
3456 case MESA_TEXTURE_ARRAY
:
3457 /* do nothing for now */
3464 if (Program
->Base
.NumInstructions
+ 1 >= maxInst
) {
3465 program_error(ctx
, Program
->Position
,
3466 "Max instruction count exceeded");
3469 Program
->Position
= parse_position (&inst
);
3470 /* parse the current instruction */
3471 if (Program
->Base
.Target
== GL_FRAGMENT_PROGRAM_ARB
) {
3472 err
= parse_fp_instruction (ctx
, &inst
, vc_head
, Program
,
3473 &Program
->Base
.Instructions
[Program
->Base
.NumInstructions
]);
3476 err
= parse_vp_instruction (ctx
, &inst
, vc_head
, Program
,
3477 &Program
->Base
.Instructions
[Program
->Base
.NumInstructions
]);
3480 /* increment instuction count */
3481 Program
->Base
.NumInstructions
++;
3485 err
= parse_declaration (ctx
, &inst
, vc_head
, Program
);
3496 /* Finally, tag on an OPCODE_END instruction */
3498 const GLuint numInst
= Program
->Base
.NumInstructions
;
3499 _mesa_init_instructions(Program
->Base
.Instructions
+ numInst
, 1);
3500 Program
->Base
.Instructions
[numInst
].Opcode
= OPCODE_END
;
3501 /* YYY Wrong Position in program, whatever, at least not random -> crash
3502 Program->Position = parse_position (&inst);
3504 Program
->Base
.Instructions
[numInst
].StringPos
= Program
->Position
;
3506 Program
->Base
.NumInstructions
++;
3509 * Initialize native counts to logical counts. The device driver may
3510 * change them if program is translated into a hardware program.
3512 Program
->Base
.NumNativeInstructions
= Program
->Base
.NumInstructions
;
3513 Program
->Base
.NumNativeTemporaries
= Program
->Base
.NumTemporaries
;
3514 Program
->Base
.NumNativeParameters
= Program
->Base
.NumParameters
;
3515 Program
->Base
.NumNativeAttributes
= Program
->Base
.NumAttributes
;
3516 Program
->Base
.NumNativeAddressRegs
= Program
->Base
.NumAddressRegs
;
3523 LONGSTRING
static char core_grammar_text
[] =
3524 #include "shader/grammar/grammar_syn.h"
3529 * Set a grammar parameter.
3530 * \param name the grammar parameter
3531 * \param value the new parameter value
3532 * \return 0 if OK, 1 if error
3535 set_reg8 (GLcontext
*ctx
, grammar id
, const char *name
, GLubyte value
)
3537 char error_msg
[300];
3540 if (grammar_set_reg8 (id
, (const byte
*) name
, value
))
3543 grammar_get_last_error ((byte
*) error_msg
, 300, &error_pos
);
3544 _mesa_set_program_error (ctx
, error_pos
, error_msg
);
3545 _mesa_error (ctx
, GL_INVALID_OPERATION
, "Grammar Register Error");
3551 * Enable support for the given language option in the parser.
3552 * \return 1 if OK, 0 if error
3555 enable_ext(GLcontext
*ctx
, grammar id
, const char *name
)
3557 return !set_reg8(ctx
, id
, name
, 1);
3562 * Enable parser extensions based on which OpenGL extensions are supported
3563 * by this rendering context.
3565 * \return GL_TRUE if OK, GL_FALSE if error.
3568 enable_parser_extensions(GLcontext
*ctx
, grammar id
)
3571 /* These are not supported at this time */
3572 if ((ctx
->Extensions
.ARB_vertex_blend
||
3573 ctx
->Extensions
.EXT_vertex_weighting
)
3574 && !enable_ext(ctx
, id
, "vertex_blend"))
3576 if (ctx
->Extensions
.ARB_matrix_palette
3577 && !enable_ext(ctx
, id
, "matrix_palette"))
3580 if (ctx
->Extensions
.ARB_fragment_program_shadow
3581 && !enable_ext(ctx
, id
, "fragment_program_shadow"))
3583 if (ctx
->Extensions
.EXT_point_parameters
3584 && !enable_ext(ctx
, id
, "point_parameters"))
3586 if (ctx
->Extensions
.EXT_secondary_color
3587 && !enable_ext(ctx
, id
, "secondary_color"))
3589 if (ctx
->Extensions
.EXT_fog_coord
3590 && !enable_ext(ctx
, id
, "fog_coord"))
3592 if (ctx
->Extensions
.NV_texture_rectangle
3593 && !enable_ext(ctx
, id
, "texture_rectangle"))
3595 if (ctx
->Extensions
.ARB_draw_buffers
3596 && !enable_ext(ctx
, id
, "draw_buffers"))
3598 if (ctx
->Extensions
.MESA_texture_array
3599 && !enable_ext(ctx
, id
, "texture_array"))
3602 /* hack for Warcraft (see bug 8060) */
3603 enable_ext(ctx
, id
, "vertex_blend");
3611 * This kicks everything off.
3613 * \param ctx - The GL Context
3614 * \param str - The program string
3615 * \param len - The program string length
3616 * \param program - The arb_program struct to return all the parsed info in
3617 * \return GL_TRUE on sucess, GL_FALSE on error
3620 _mesa_parse_arb_program(GLcontext
*ctx
, GLenum target
,
3621 const GLubyte
*str
, GLsizei len
,
3622 struct arb_program
*program
)
3624 GLint a
, err
, error_pos
;
3625 char error_msg
[300];
3627 struct var_cache
*vc_head
;
3628 grammar arbprogram_syn_id
;
3629 GLubyte
*parsed
, *inst
;
3630 GLubyte
*strz
= NULL
;
3631 static int arbprogram_syn_is_ok
= 0; /* XXX temporary */
3633 /* set the program target before parsing */
3634 program
->Base
.Target
= target
;
3636 /* Reset error state */
3637 _mesa_set_program_error(ctx
, -1, NULL
);
3639 /* check if arb_grammar_text (arbprogram.syn) is syntactically correct */
3640 if (!arbprogram_syn_is_ok
) {
3641 /* One-time initialization of parsing system */
3642 grammar grammar_syn_id
;
3645 grammar_syn_id
= grammar_load_from_text ((byte
*) core_grammar_text
);
3646 if (grammar_syn_id
== 0) {
3647 grammar_get_last_error ((byte
*) error_msg
, 300, &error_pos
);
3648 /* XXX this is not a GL error - it's an implementation bug! - FIX */
3649 _mesa_set_program_error (ctx
, error_pos
, error_msg
);
3650 _mesa_error (ctx
, GL_INVALID_OPERATION
,
3651 "glProgramStringARB(Error loading grammar rule set)");
3655 err
= !grammar_check(grammar_syn_id
, (byte
*) arb_grammar_text
,
3656 &parsed
, &parsed_len
);
3658 /* 'parsed' is unused here */
3659 _mesa_free (parsed
);
3662 /* NOTE: we can't destroy grammar_syn_id right here because
3663 * grammar_destroy() can reset the last error
3666 /* XXX this is not a GL error - it's an implementation bug! - FIX */
3667 grammar_get_last_error ((byte
*) error_msg
, 300, &error_pos
);
3668 _mesa_set_program_error (ctx
, error_pos
, error_msg
);
3669 _mesa_error (ctx
, GL_INVALID_OPERATION
,
3670 "glProgramString(Error loading grammar rule set");
3671 grammar_destroy (grammar_syn_id
);
3675 grammar_destroy (grammar_syn_id
);
3677 arbprogram_syn_is_ok
= 1;
3680 /* create the grammar object */
3681 arbprogram_syn_id
= grammar_load_from_text ((byte
*) arb_grammar_text
);
3682 if (arbprogram_syn_id
== 0) {
3683 /* XXX this is not a GL error - it's an implementation bug! - FIX */
3684 grammar_get_last_error ((GLubyte
*) error_msg
, 300, &error_pos
);
3685 _mesa_set_program_error (ctx
, error_pos
, error_msg
);
3686 _mesa_error (ctx
, GL_INVALID_OPERATION
,
3687 "glProgramString(Error loading grammer rule set)");
3691 /* Set program_target register value */
3692 if (set_reg8 (ctx
, arbprogram_syn_id
, "program_target",
3693 program
->Base
.Target
== GL_FRAGMENT_PROGRAM_ARB
? 0x10 : 0x20)) {
3694 grammar_destroy (arbprogram_syn_id
);
3698 if (!enable_parser_extensions(ctx
, arbprogram_syn_id
)) {
3699 grammar_destroy(arbprogram_syn_id
);
3703 /* check for NULL character occurences */
3706 for (i
= 0; i
< len
; i
++) {
3707 if (str
[i
] == '\0') {
3708 program_error(ctx
, i
, "illegal character");
3709 grammar_destroy (arbprogram_syn_id
);
3715 /* copy the program string to a null-terminated string */
3716 strz
= (GLubyte
*) _mesa_malloc (len
+ 1);
3718 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glProgramStringARB");
3719 grammar_destroy (arbprogram_syn_id
);
3722 _mesa_memcpy (strz
, str
, len
);
3725 /* do a fast check on program string - initial production buffer is 4K */
3726 err
= !grammar_fast_check(arbprogram_syn_id
, strz
,
3727 &parsed
, &parsed_len
, 0x1000);
3729 /* Syntax parse error */
3731 grammar_get_last_error((GLubyte
*) error_msg
, 300, &error_pos
);
3732 program_error(ctx
, error_pos
, error_msg
);
3735 /* useful for debugging */
3739 fprintf(stderr
, "program: %s\n", (char *) strz
);
3740 fprintf(stderr
, "Error Pos: %d\n", ctx
->Program
.ErrorPos
);
3741 s
= (char *) _mesa_find_line_column(strz
, strz
+ctx
->Program
.ErrorPos
,
3743 fprintf(stderr
, "line %d col %d: %s\n", line
, col
, s
);
3750 grammar_destroy (arbprogram_syn_id
);
3754 grammar_destroy (arbprogram_syn_id
);
3757 * Program string is syntactically correct at this point
3758 * Parse the tokenized version of the program now, generating
3759 * vertex/fragment program instructions.
3762 /* Initialize the arb_program struct */
3763 program
->Base
.String
= strz
;
3764 program
->Base
.Instructions
= _mesa_alloc_instructions(MAX_INSTRUCTIONS
);
3765 program
->Base
.NumInstructions
=
3766 program
->Base
.NumTemporaries
=
3767 program
->Base
.NumParameters
=
3768 program
->Base
.NumAttributes
= program
->Base
.NumAddressRegs
= 0;
3769 program
->Base
.Parameters
= _mesa_new_parameter_list ();
3770 program
->Base
.InputsRead
= 0x0;
3771 program
->Base
.OutputsWritten
= 0x0;
3772 program
->Position
= 0;
3773 program
->MajorVersion
= program
->MinorVersion
= 0;
3774 program
->PrecisionOption
= GL_DONT_CARE
;
3775 program
->FogOption
= GL_NONE
;
3776 program
->HintPositionInvariant
= GL_FALSE
;
3777 for (a
= 0; a
< MAX_TEXTURE_IMAGE_UNITS
; a
++)
3778 program
->TexturesUsed
[a
] = 0x0;
3779 program
->ShadowSamplers
= 0x0;
3780 program
->NumAluInstructions
=
3781 program
->NumTexInstructions
=
3782 program
->NumTexIndirections
= 0;
3783 program
->UsesKill
= 0;
3788 /* Start examining the tokens in the array */
3791 /* Check the grammer rev */
3792 if (*inst
++ != REVISION
) {
3793 program_error (ctx
, 0, "Grammar version mismatch");
3797 /* ignore program target */
3799 err
= parse_instructions(ctx
, inst
, &vc_head
, program
);
3802 /*debug_variables(ctx, vc_head, program); */
3804 /* We're done with the parsed binary array */
3805 var_cache_destroy (&vc_head
);
3807 _mesa_free (parsed
);
3809 /* Reallocate the instruction array from size [MAX_INSTRUCTIONS]
3810 * to size [ap.Base.NumInstructions].
3812 program
->Base
.Instructions
3813 = _mesa_realloc_instructions(program
->Base
.Instructions
,
3815 program
->Base
.NumInstructions
);
3823 _mesa_parse_arb_fragment_program(GLcontext
* ctx
, GLenum target
,
3824 const GLvoid
*str
, GLsizei len
,
3825 struct gl_fragment_program
*program
)
3827 struct arb_program ap
;
3830 ASSERT(target
== GL_FRAGMENT_PROGRAM_ARB
);
3831 if (!_mesa_parse_arb_program(ctx
, target
, (const GLubyte
*) str
, len
, &ap
)) {
3832 /* Error in the program. Just return. */
3836 /* Copy the relevant contents of the arb_program struct into the
3837 * fragment_program struct.
3839 program
->Base
.String
= ap
.Base
.String
;
3840 program
->Base
.NumInstructions
= ap
.Base
.NumInstructions
;
3841 program
->Base
.NumTemporaries
= ap
.Base
.NumTemporaries
;
3842 program
->Base
.NumParameters
= ap
.Base
.NumParameters
;
3843 program
->Base
.NumAttributes
= ap
.Base
.NumAttributes
;
3844 program
->Base
.NumAddressRegs
= ap
.Base
.NumAddressRegs
;
3845 program
->Base
.NumNativeInstructions
= ap
.Base
.NumNativeInstructions
;
3846 program
->Base
.NumNativeTemporaries
= ap
.Base
.NumNativeTemporaries
;
3847 program
->Base
.NumNativeParameters
= ap
.Base
.NumNativeParameters
;
3848 program
->Base
.NumNativeAttributes
= ap
.Base
.NumNativeAttributes
;
3849 program
->Base
.NumNativeAddressRegs
= ap
.Base
.NumNativeAddressRegs
;
3850 program
->Base
.NumAluInstructions
= ap
.Base
.NumAluInstructions
;
3851 program
->Base
.NumTexInstructions
= ap
.Base
.NumTexInstructions
;
3852 program
->Base
.NumTexIndirections
= ap
.Base
.NumTexIndirections
;
3853 program
->Base
.NumNativeAluInstructions
= ap
.Base
.NumAluInstructions
;
3854 program
->Base
.NumNativeTexInstructions
= ap
.Base
.NumTexInstructions
;
3855 program
->Base
.NumNativeTexIndirections
= ap
.Base
.NumTexIndirections
;
3856 program
->Base
.InputsRead
= ap
.Base
.InputsRead
;
3857 program
->Base
.OutputsWritten
= ap
.Base
.OutputsWritten
;
3858 for (i
= 0; i
< MAX_TEXTURE_IMAGE_UNITS
; i
++) {
3859 program
->Base
.TexturesUsed
[i
] = ap
.TexturesUsed
[i
];
3860 if (ap
.TexturesUsed
[i
])
3861 program
->Base
.SamplersUsed
|= (1 << i
);
3863 program
->Base
.ShadowSamplers
= ap
.ShadowSamplers
;
3864 program
->FogOption
= ap
.FogOption
;
3865 program
->UsesKill
= ap
.UsesKill
;
3867 if (program
->Base
.Instructions
)
3868 _mesa_free(program
->Base
.Instructions
);
3869 program
->Base
.Instructions
= ap
.Base
.Instructions
;
3871 if (program
->Base
.Parameters
)
3872 _mesa_free_parameter_list(program
->Base
.Parameters
);
3873 program
->Base
.Parameters
= ap
.Base
.Parameters
;
3875 /* Append fog instructions now if the program has "OPTION ARB_fog_exp"
3876 * or similar. We used to leave this up to drivers, but it appears
3877 * there's no hardware that wants to do fog in a discrete stage separate
3878 * from the fragment shader.
3880 if (program
->FogOption
!= GL_NONE
) {
3881 _mesa_append_fog_code(ctx
, program
);
3882 program
->FogOption
= GL_NONE
;
3886 _mesa_printf("____________Fragment program %u ________\n", program
->Base
.Id
);
3887 _mesa_print_program(&program
->Base
);
3894 * Parse the vertex program string. If success, update the given
3895 * vertex_program object with the new program. Else, leave the vertex_program
3899 _mesa_parse_arb_vertex_program(GLcontext
*ctx
, GLenum target
,
3900 const GLvoid
*str
, GLsizei len
,
3901 struct gl_vertex_program
*program
)
3903 struct arb_program ap
;
3905 ASSERT(target
== GL_VERTEX_PROGRAM_ARB
);
3907 if (!_mesa_parse_arb_program(ctx
, target
, (const GLubyte
*) str
, len
, &ap
)) {
3908 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glProgramString(bad program)");
3912 /* Copy the relevant contents of the arb_program struct into the
3913 * vertex_program struct.
3915 program
->Base
.String
= ap
.Base
.String
;
3916 program
->Base
.NumInstructions
= ap
.Base
.NumInstructions
;
3917 program
->Base
.NumTemporaries
= ap
.Base
.NumTemporaries
;
3918 program
->Base
.NumParameters
= ap
.Base
.NumParameters
;
3919 program
->Base
.NumAttributes
= ap
.Base
.NumAttributes
;
3920 program
->Base
.NumAddressRegs
= ap
.Base
.NumAddressRegs
;
3921 program
->Base
.NumNativeInstructions
= ap
.Base
.NumNativeInstructions
;
3922 program
->Base
.NumNativeTemporaries
= ap
.Base
.NumNativeTemporaries
;
3923 program
->Base
.NumNativeParameters
= ap
.Base
.NumNativeParameters
;
3924 program
->Base
.NumNativeAttributes
= ap
.Base
.NumNativeAttributes
;
3925 program
->Base
.NumNativeAddressRegs
= ap
.Base
.NumNativeAddressRegs
;
3926 program
->Base
.InputsRead
= ap
.Base
.InputsRead
;
3927 program
->Base
.OutputsWritten
= ap
.Base
.OutputsWritten
;
3928 program
->IsPositionInvariant
= ap
.HintPositionInvariant
;
3930 if (program
->Base
.Instructions
)
3931 _mesa_free(program
->Base
.Instructions
);
3932 program
->Base
.Instructions
= ap
.Base
.Instructions
;
3934 if (program
->Base
.Parameters
)
3935 _mesa_free_parameter_list(program
->Base
.Parameters
);
3936 program
->Base
.Parameters
= ap
.Base
.Parameters
;
3939 _mesa_printf("____________Vertex program %u __________\n", program
->Base
.Id
);
3940 _mesa_print_program(&program
->Base
);