projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Merge branch 'mesa_7_5_branch'
[mesa.git] / src / mesa / shader / arbprogparse.c
1 /*
2 * Mesa 3-D graphics library
3 * Version: 7.1
4 *
5 * Copyright (C) 1999-2008 Brian Paul All Rights Reserved.
6 *
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:
13 *
14 * The above copyright notice and this permission notice shall be included
15 * in all copies or substantial portions of the Software.
16 *
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.
23 */
24
25 #define DEBUG_PARSING 0
26
27 /**
28 * \file arbprogparse.c
29 * ARB_*_program parser core
30 * \author Karl Rasche
31 */
32
33 /**
34 Notes on program parameters, etc.
35
36 The instructions we emit will use six kinds of source registers:
37
38 PROGRAM_INPUT - input registers
39 PROGRAM_TEMPORARY - temp registers
40 PROGRAM_ADDRESS - address/indirect register
41 PROGRAM_SAMPLER - texture sampler
42 PROGRAM_CONSTANT - indexes into program->Parameters, a known constant/literal
43 PROGRAM_STATE_VAR - indexes into program->Parameters, and may actually be:
44 + a state variable, like "state.fog.color", or
45 + a pointer to a "program.local[k]" parameter, or
46 + a pointer to a "program.env[k]" parameter
47
48 Basically, all the program.local[] and program.env[] values will get mapped
49 into the unified gl_program->Parameters array. This solves the problem of
50 having three separate program parameter arrays.
51 */
52
53
54 #include "main/glheader.h"
55 #include "main/imports.h"
56 #include "main/context.h"
57 #include "main/macros.h"
58 #include "main/mtypes.h"
59 #include "shader/grammar/grammar_mesa.h"
60 #include "arbprogparse.h"
61 #include "program.h"
62 #include "programopt.h"
63 #include "prog_parameter.h"
64 #include "prog_statevars.h"
65 #include "prog_instruction.h"
66
67 /**
68 * This is basically a union of the vertex_program and fragment_program
69 * structs that we can use to parse the program into
70 *
71 * XXX we can probably get rid of this entirely someday.
72 */
73 struct arb_program
74 {
75 struct gl_program Base;
76
77 GLuint Position; /* Just used for error reporting while parsing */
78 GLuint MajorVersion;
79 GLuint MinorVersion;
80
81 /* ARB_vertex_progmra options */
82 GLboolean HintPositionInvariant;
83
84 /* ARB_fragment_progmra options */
85 GLenum PrecisionOption; /* GL_DONT_CARE, GL_NICEST or GL_FASTEST */
86 GLenum FogOption; /* GL_NONE, GL_LINEAR, GL_EXP or GL_EXP2 */
87
88 /* ARB_fragment_program specifics */
89 GLbitfield TexturesUsed[MAX_TEXTURE_IMAGE_UNITS];
90 GLbitfield ShadowSamplers;
91 GLuint NumAluInstructions;
92 GLuint NumTexInstructions;
93 GLuint NumTexIndirections;
94
95 GLboolean UsesKill;
96 };
97
98
99
100 /* TODO:
101 * Fragment Program Stuff:
102 * -----------------------------------------------------
103 *
104 * - things from Michal's email
105 * + overflow on atoi
106 * + not-overflowing floats (don't use parse_integer..)
107 * + can remove range checking in arbparse.c
108 *
109 * - check all limits of number of various variables
110 * + parameters
111 *
112 * - test! test! test!
113 *
114 * Vertex Program Stuff:
115 * -----------------------------------------------------
116 * - Optimize param array usage and count limits correctly, see spec,
117 * section 2.14.3.7
118 * + Record if an array is reference absolutly or relatively (or both)
119 * + For absolute arrays, store a bitmap of accesses
120 * + For single parameters, store an access flag
121 * + After parsing, make a parameter cleanup and merging pass, where
122 * relative arrays are layed out first, followed by abs arrays, and
123 * finally single state.
124 * + Remap offsets for param src and dst registers
125 * + Now we can properly count parameter usage
126 *
127 * - Multiple state binding errors in param arrays (see spec, just before
128 * section 2.14.3.3)
129 * - grep for XXX
130 *
131 * Mesa Stuff
132 * -----------------------------------------------------
133 * - User clipping planes vs. PositionInvariant
134 * - Is it sufficient to just multiply by the mvp to transform in the
135 * PositionInvariant case? Or do we need something more involved?
136 *
137 * - vp_src swizzle is GLubyte, fp_src swizzle is GLuint
138 * - fetch state listed in program_parameters list
139 * + WTF should this go???
140 * + currently in nvvertexec.c and s_nvfragprog.c
141 *
142 * - allow for multiple address registers (and fetch address regs properly)
143 *
144 * Cosmetic Stuff
145 * -----------------------------------------------------
146 * - remove any leftover unused grammer.c stuff (dict_ ?)
147 * - fix grammer.c error handling so its not static
148 * - #ifdef around stuff pertaining to extentions
149 *
150 * Outstanding Questions:
151 * -----------------------------------------------------
152 * - ARB_matrix_palette / ARB_vertex_blend -- not supported
153 * what gets hacked off because of this:
154 * + VERTEX_ATTRIB_MATRIXINDEX
155 * + VERTEX_ATTRIB_WEIGHT
156 * + MATRIX_MODELVIEW
157 * + MATRIX_PALETTE
158 *
159 * - When can we fetch env/local params from their own register files, and
160 * when to we have to fetch them into the main state register file?
161 * (think arrays)
162 *
163 * Grammar Changes:
164 * -----------------------------------------------------
165 */
166
167 /* Changes since moving the file to shader directory
168
169 2004-III-4 ------------------------------------------------------------
170 - added #include "grammar_mesa.h"
171 - removed grammar specific code part (it resides now in grammar.c)
172 - added GL_ARB_fragment_program_shadow tokens
173 - modified #include "arbparse_syn.h"
174 - major changes inside _mesa_parse_arb_program()
175 - check the program string for '\0' characters
176 - copy the program string to a one-byte-longer location to have
177 it null-terminated
178 - position invariance test (not writing to result.position) moved
179 to syntax part
180 */
181
182 typedef GLubyte *production;
183
184
185 /**
186 * This is the text describing the rules to parse the grammar
187 */
188 LONGSTRING static char arb_grammar_text[] =
189 #include "arbprogram_syn.h"
190 ;
191
192 /**
193 * These should match up with the values defined in arbprogram.syn
194 */
195
196 /*
197 Changes:
198 - changed and merged V_* and F_* opcode values to OP_*.
199 - added GL_ARB_fragment_program_shadow specific tokens (michal)
200 */
201 #define REVISION 0x0a
202
203 /* program type */
204 #define FRAGMENT_PROGRAM 0x01
205 #define VERTEX_PROGRAM 0x02
206
207 /* program section */
208 #define OPTION 0x01
209 #define INSTRUCTION 0x02
210 #define DECLARATION 0x03
211 #define END 0x04
212
213 /* GL_ARB_fragment_program option */
214 #define ARB_PRECISION_HINT_FASTEST 0x00
215 #define ARB_PRECISION_HINT_NICEST 0x01
216 #define ARB_FOG_EXP 0x02
217 #define ARB_FOG_EXP2 0x03
218 #define ARB_FOG_LINEAR 0x04
219
220 /* GL_ARB_vertex_program option */
221 #define ARB_POSITION_INVARIANT 0x05
222
223 /* GL_ARB_fragment_program_shadow option */
224 #define ARB_FRAGMENT_PROGRAM_SHADOW 0x06
225
226 /* GL_ARB_draw_buffers option */
227 #define ARB_DRAW_BUFFERS 0x07
228
229 /* GL_MESA_texture_array option */
230 #define MESA_TEXTURE_ARRAY 0x08
231
232 /* GL_ARB_fragment_program instruction class */
233 #define OP_ALU_INST 0x00
234 #define OP_TEX_INST 0x01
235
236 /* GL_ARB_vertex_program instruction class */
237 /* OP_ALU_INST */
238
239 /* GL_ARB_fragment_program instruction type */
240 #define OP_ALU_VECTOR 0x00
241 #define OP_ALU_SCALAR 0x01
242 #define OP_ALU_BINSC 0x02
243 #define OP_ALU_BIN 0x03
244 #define OP_ALU_TRI 0x04
245 #define OP_ALU_SWZ 0x05
246 #define OP_TEX_SAMPLE 0x06
247 #define OP_TEX_KIL 0x07
248
249 /* GL_ARB_vertex_program instruction type */
250 #define OP_ALU_ARL 0x08
251 /* OP_ALU_VECTOR */
252 /* OP_ALU_SCALAR */
253 /* OP_ALU_BINSC */
254 /* OP_ALU_BIN */
255 /* OP_ALU_TRI */
256 /* OP_ALU_SWZ */
257
258 /* GL_ARB_fragment_program instruction code */
259 #define OP_ABS 0x00
260 #define OP_ABS_SAT 0x1B
261 #define OP_FLR 0x09
262 #define OP_FLR_SAT 0x26
263 #define OP_FRC 0x0A
264 #define OP_FRC_SAT 0x27
265 #define OP_LIT 0x0C
266 #define OP_LIT_SAT 0x2A
267 #define OP_MOV 0x11
268 #define OP_MOV_SAT 0x30
269 #define OP_COS 0x1F
270 #define OP_COS_SAT 0x20
271 #define OP_EX2 0x07
272 #define OP_EX2_SAT 0x25
273 #define OP_LG2 0x0B
274 #define OP_LG2_SAT 0x29
275 #define OP_RCP 0x14
276 #define OP_RCP_SAT 0x33
277 #define OP_RSQ 0x15
278 #define OP_RSQ_SAT 0x34
279 #define OP_SIN 0x38
280 #define OP_SIN_SAT 0x39
281 #define OP_SCS 0x35
282 #define OP_SCS_SAT 0x36
283 #define OP_POW 0x13
284 #define OP_POW_SAT 0x32
285 #define OP_ADD 0x01
286 #define OP_ADD_SAT 0x1C
287 #define OP_DP3 0x03
288 #define OP_DP3_SAT 0x21
289 #define OP_DP4 0x04
290 #define OP_DP4_SAT 0x22
291 #define OP_DPH 0x05
292 #define OP_DPH_SAT 0x23
293 #define OP_DST 0x06
294 #define OP_DST_SAT 0x24
295 #define OP_MAX 0x0F
296 #define OP_MAX_SAT 0x2E
297 #define OP_MIN 0x10
298 #define OP_MIN_SAT 0x2F
299 #define OP_MUL 0x12
300 #define OP_MUL_SAT 0x31
301 #define OP_SGE 0x16
302 #define OP_SGE_SAT 0x37
303 #define OP_SLT 0x17
304 #define OP_SLT_SAT 0x3A
305 #define OP_SUB 0x18
306 #define OP_SUB_SAT 0x3B
307 #define OP_XPD 0x1A
308 #define OP_XPD_SAT 0x43
309 #define OP_CMP 0x1D
310 #define OP_CMP_SAT 0x1E
311 #define OP_LRP 0x2B
312 #define OP_LRP_SAT 0x2C
313 #define OP_MAD 0x0E
314 #define OP_MAD_SAT 0x2D
315 #define OP_SWZ 0x19
316 #define OP_SWZ_SAT 0x3C
317 #define OP_TEX 0x3D
318 #define OP_TEX_SAT 0x3E
319 #define OP_TXB 0x3F
320 #define OP_TXB_SAT 0x40
321 #define OP_TXP 0x41
322 #define OP_TXP_SAT 0x42
323 #define OP_KIL 0x28
324
325 /* GL_ARB_vertex_program instruction code */
326 #define OP_ARL 0x02
327 /* OP_ABS */
328 /* OP_FLR */
329 /* OP_FRC */
330 /* OP_LIT */
331 /* OP_MOV */
332 /* OP_EX2 */
333 #define OP_EXP 0x08
334 /* OP_LG2 */
335 #define OP_LOG 0x0D
336 /* OP_RCP */
337 /* OP_RSQ */
338 /* OP_POW */
339 /* OP_ADD */
340 /* OP_DP3 */
341 /* OP_DP4 */
342 /* OP_DPH */
343 /* OP_DST */
344 /* OP_MAX */
345 /* OP_MIN */
346 /* OP_MUL */
347 /* OP_SGE */
348 /* OP_SLT */
349 /* OP_SUB */
350 /* OP_XPD */
351 /* OP_MAD */
352 /* OP_SWZ */
353
354 /* fragment attribute binding */
355 #define FRAGMENT_ATTRIB_COLOR 0x01
356 #define FRAGMENT_ATTRIB_TEXCOORD 0x02
357 #define FRAGMENT_ATTRIB_FOGCOORD 0x03
358 #define FRAGMENT_ATTRIB_POSITION 0x04
359
360 /* vertex attribute binding */
361 #define VERTEX_ATTRIB_POSITION 0x01
362 #define VERTEX_ATTRIB_WEIGHT 0x02
363 #define VERTEX_ATTRIB_NORMAL 0x03
364 #define VERTEX_ATTRIB_COLOR 0x04
365 #define VERTEX_ATTRIB_FOGCOORD 0x05
366 #define VERTEX_ATTRIB_TEXCOORD 0x06
367 #define VERTEX_ATTRIB_MATRIXINDEX 0x07
368 #define VERTEX_ATTRIB_GENERIC 0x08
369
370 /* fragment result binding */
371 #define FRAGMENT_RESULT_COLOR 0x01
372 #define FRAGMENT_RESULT_DEPTH 0x02
373
374 /* vertex result binding */
375 #define VERTEX_RESULT_POSITION 0x01
376 #define VERTEX_RESULT_COLOR 0x02
377 #define VERTEX_RESULT_FOGCOORD 0x03
378 #define VERTEX_RESULT_POINTSIZE 0x04
379 #define VERTEX_RESULT_TEXCOORD 0x05
380
381 /* texture target */
382 #define TEXTARGET_1D 0x01
383 #define TEXTARGET_2D 0x02
384 #define TEXTARGET_3D 0x03
385 #define TEXTARGET_RECT 0x04
386 #define TEXTARGET_CUBE 0x05
387 /* GL_ARB_fragment_program_shadow */
388 #define TEXTARGET_SHADOW1D 0x06
389 #define TEXTARGET_SHADOW2D 0x07
390 #define TEXTARGET_SHADOWRECT 0x08
391 /* GL_MESA_texture_array */
392 #define TEXTARGET_1D_ARRAY 0x09
393 #define TEXTARGET_2D_ARRAY 0x0a
394 #define TEXTARGET_SHADOW1D_ARRAY 0x0b
395 #define TEXTARGET_SHADOW2D_ARRAY 0x0c
396
397 /* face type */
398 #define FACE_FRONT 0x00
399 #define FACE_BACK 0x01
400
401 /* color type */
402 #define COLOR_PRIMARY 0x00
403 #define COLOR_SECONDARY 0x01
404
405 /* component */
406 #define COMPONENT_X 0x00
407 #define COMPONENT_Y 0x01
408 #define COMPONENT_Z 0x02
409 #define COMPONENT_W 0x03
410 #define COMPONENT_0 0x04
411 #define COMPONENT_1 0x05
412
413 /* array index type */
414 #define ARRAY_INDEX_ABSOLUTE 0x00
415 #define ARRAY_INDEX_RELATIVE 0x01
416
417 /* matrix name */
418 #define MATRIX_MODELVIEW 0x01
419 #define MATRIX_PROJECTION 0x02
420 #define MATRIX_MVP 0x03
421 #define MATRIX_TEXTURE 0x04
422 #define MATRIX_PALETTE 0x05
423 #define MATRIX_PROGRAM 0x06
424
425 /* matrix modifier */
426 #define MATRIX_MODIFIER_IDENTITY 0x00
427 #define MATRIX_MODIFIER_INVERSE 0x01
428 #define MATRIX_MODIFIER_TRANSPOSE 0x02
429 #define MATRIX_MODIFIER_INVTRANS 0x03
430
431 /* constant type */
432 #define CONSTANT_SCALAR 0x01
433 #define CONSTANT_VECTOR 0x02
434
435 /* program param type */
436 #define PROGRAM_PARAM_ENV 0x01
437 #define PROGRAM_PARAM_LOCAL 0x02
438
439 /* register type */
440 #define REGISTER_ATTRIB 0x01
441 #define REGISTER_PARAM 0x02
442 #define REGISTER_RESULT 0x03
443 #define REGISTER_ESTABLISHED_NAME 0x04
444
445 /* param binding */
446 #define PARAM_NULL 0x00
447 #define PARAM_ARRAY_ELEMENT 0x01
448 #define PARAM_STATE_ELEMENT 0x02
449 #define PARAM_PROGRAM_ELEMENT 0x03
450 #define PARAM_PROGRAM_ELEMENTS 0x04
451 #define PARAM_CONSTANT 0x05
452
453 /* param state property */
454 #define STATE_MATERIAL_PARSER 0x01
455 #define STATE_LIGHT_PARSER 0x02
456 #define STATE_LIGHT_MODEL 0x03
457 #define STATE_LIGHT_PROD 0x04
458 #define STATE_FOG 0x05
459 #define STATE_MATRIX_ROWS 0x06
460 /* GL_ARB_fragment_program */
461 #define STATE_TEX_ENV 0x07
462 #define STATE_DEPTH 0x08
463 /* GL_ARB_vertex_program */
464 #define STATE_TEX_GEN 0x09
465 #define STATE_CLIP_PLANE 0x0A
466 #define STATE_POINT 0x0B
467
468 /* state material property */
469 #define MATERIAL_AMBIENT 0x01
470 #define MATERIAL_DIFFUSE 0x02
471 #define MATERIAL_SPECULAR 0x03
472 #define MATERIAL_EMISSION 0x04
473 #define MATERIAL_SHININESS 0x05
474
475 /* state light property */
476 #define LIGHT_AMBIENT 0x01
477 #define LIGHT_DIFFUSE 0x02
478 #define LIGHT_SPECULAR 0x03
479 #define LIGHT_POSITION 0x04
480 #define LIGHT_ATTENUATION 0x05
481 #define LIGHT_HALF 0x06
482 #define LIGHT_SPOT_DIRECTION 0x07
483
484 /* state light model property */
485 #define LIGHT_MODEL_AMBIENT 0x01
486 #define LIGHT_MODEL_SCENECOLOR 0x02
487
488 /* state light product property */
489 #define LIGHT_PROD_AMBIENT 0x01
490 #define LIGHT_PROD_DIFFUSE 0x02
491 #define LIGHT_PROD_SPECULAR 0x03
492
493 /* state texture environment property */
494 #define TEX_ENV_COLOR 0x01
495
496 /* state texture generation coord property */
497 #define TEX_GEN_EYE 0x01
498 #define TEX_GEN_OBJECT 0x02
499
500 /* state fog property */
501 #define FOG_COLOR 0x01
502 #define FOG_PARAMS 0x02
503
504 /* state depth property */
505 #define DEPTH_RANGE 0x01
506
507 /* state point parameters property */
508 #define POINT_SIZE 0x01
509 #define POINT_ATTENUATION 0x02
510
511 /* declaration */
512 #define ATTRIB 0x01
513 #define PARAM 0x02
514 #define TEMP 0x03
515 #define OUTPUT 0x04
516 #define ALIAS 0x05
517 /* GL_ARB_vertex_program */
518 #define ADDRESS 0x06
519
520 /*-----------------------------------------------------------------------
521 * From here on down is the semantic checking portion
522 *
523 */
524
525 /**
526 * Variable Table Handling functions
527 */
528 typedef enum
529 {
530 vt_none,
531 vt_address,
532 vt_attrib,
533 vt_param,
534 vt_temp,
535 vt_output,
536 vt_alias
537 } var_type;
538
539
540 /**
541 * Setting an explicit field for each of the binding properties is a bit
542 * wasteful of space, but it should be much more clear when reading later on..
543 */
544 struct var_cache
545 {
546 const GLubyte *name; /* don't free() - no need */
547 var_type type;
548 GLuint address_binding; /* The index of the address register we should
549 * be using */
550 GLuint attrib_binding; /* For type vt_attrib, see nvfragprog.h for values */
551 GLuint attrib_is_generic; /* If the attrib was specified through a generic
552 * vertex attrib */
553 GLuint temp_binding; /* The index of the temp register we are to use */
554 GLuint output_binding; /* Output/result register number */
555 struct var_cache *alias_binding; /* For type vt_alias, points to the var_cache entry
556 * that this is aliased to */
557 GLuint param_binding_type; /* {PROGRAM_STATE_VAR, PROGRAM_LOCAL_PARAM,
558 * PROGRAM_ENV_PARAM} */
559 GLuint param_binding_begin; /* This is the offset into the program_parameter_list where
560 * the tokens representing our bound state (or constants)
561 * start */
562 GLuint param_binding_length; /* This is how many entries in the the program_parameter_list
563 * we take up with our state tokens or constants. Note that
564 * this is _not_ the same as the number of param registers
565 * we eventually use */
566 GLuint swizzle; /**< swizzle to access this variable */
567 struct var_cache *next;
568 };
569
570 static GLvoid
571 var_cache_create (struct var_cache **va)
572 {
573 *va = (struct var_cache *) _mesa_malloc (sizeof (struct var_cache));
574 if (*va) {
575 (**va).name = NULL;
576 (**va).type = vt_none;
577 (**va).attrib_binding = ~0;
578 (**va).attrib_is_generic = 0;
579 (**va).temp_binding = ~0;
580 (**va).output_binding = ~0;
581 (**va).param_binding_type = ~0;
582 (**va).param_binding_begin = ~0;
583 (**va).param_binding_length = ~0;
584 (**va).alias_binding = NULL;
585 (**va).swizzle = SWIZZLE_XYZW;
586 (**va).next = NULL;
587 }
588 }
589
590 static GLvoid
591 var_cache_destroy (struct var_cache **va)
592 {
593 if (*va) {
594 var_cache_destroy (&(**va).next);
595 _mesa_free (*va);
596 *va = NULL;
597 }
598 }
599
600 static GLvoid
601 var_cache_append (struct var_cache **va, struct var_cache *nv)
602 {
603 if (*va)
604 var_cache_append (&(**va).next, nv);
605 else
606 *va = nv;
607 }
608
609 static struct var_cache *
610 var_cache_find (struct var_cache *va, const GLubyte * name)
611 {
612 /*struct var_cache *first = va;*/
613
614 while (va) {
615 if (!_mesa_strcmp ( (const char*) name, (const char*) va->name)) {
616 if (va->type == vt_alias)
617 return va->alias_binding;
618 return va;
619 }
620
621 va = va->next;
622 }
623
624 return NULL;
625 }
626
627
628
629 /**
630 * Called when an error is detected while parsing/compiling a program.
631 * Sets the ctx->Program.ErrorString field to descript and records a
632 * GL_INVALID_OPERATION error.
633 * \param position position of error in program string
634 * \param descrip verbose error description
635 */
636 static void
637 program_error(GLcontext *ctx, GLint position, const char *descrip)
638 {
639 if (descrip) {
640 const char *prefix = "glProgramString(", *suffix = ")";
641 char *str = (char *) _mesa_malloc(_mesa_strlen(descrip) +
642 _mesa_strlen(prefix) +
643 _mesa_strlen(suffix) + 1);
644 if (str) {
645 _mesa_sprintf(str, "%s%s%s", prefix, descrip, suffix);
646 _mesa_error(ctx, GL_INVALID_OPERATION, str);
647 _mesa_free(str);
648 }
649 }
650 _mesa_set_program_error(ctx, position, descrip);
651 }
652
653
654 /**
655 * As above, but with an extra string parameter for more info.
656 */
657 static void
658 program_error2(GLcontext *ctx, GLint position, const char *descrip,
659 const char *var)
660 {
661 if (descrip) {
662 const char *prefix = "glProgramString(", *suffix = ")";
663 char *str = (char *) _mesa_malloc(_mesa_strlen(descrip) +
664 _mesa_strlen(": ") +
665 _mesa_strlen(var) +
666 _mesa_strlen(prefix) +
667 _mesa_strlen(suffix) + 1);
668 if (str) {
669 _mesa_sprintf(str, "%s%s: %s%s", prefix, descrip, var, suffix);
670 _mesa_error(ctx, GL_INVALID_OPERATION, str);
671 _mesa_free(str);
672 }
673 }
674 {
675 char *str = (char *) _mesa_malloc(_mesa_strlen(descrip) +
676 _mesa_strlen(": ") +
677 _mesa_strlen(var) + 1);
678 if (str) {
679 _mesa_sprintf(str, "%s: %s", descrip, var);
680 }
681 _mesa_set_program_error(ctx, position, str);
682 if (str) {
683 _mesa_free(str);
684 }
685 }
686 }
687
688
689
690 /**
691 * constructs an integer from 4 GLubytes in LE format
692 */
693 static GLuint
694 parse_position (const GLubyte ** inst)
695 {
696 GLuint value;
697
698 value = (GLuint) (*(*inst)++);
699 value += (GLuint) (*(*inst)++) * 0x100;
700 value += (GLuint) (*(*inst)++) * 0x10000;
701 value += (GLuint) (*(*inst)++) * 0x1000000;
702
703 return value;
704 }
705
706 /**
707 * This will, given a string, lookup the string as a variable name in the
708 * var cache. If the name is found, the var cache node corresponding to the
709 * var name is returned. If it is not found, a new entry is allocated
710 *
711 * \param I Points into the binary array where the string identifier begins
712 * \param found 1 if the string was found in the var_cache, 0 if it was allocated
713 * \return The location on the var_cache corresponding the the string starting at I
714 */
715 static struct var_cache *
716 parse_string (const GLubyte ** inst, struct var_cache **vc_head,
717 struct arb_program *Program, GLuint * found)
718 {
719 const GLubyte *i = *inst;
720 struct var_cache *va = NULL;
721 (void) Program;
722
723 *inst += _mesa_strlen ((char *) i) + 1;
724
725 va = var_cache_find (*vc_head, i);
726
727 if (va) {
728 *found = 1;
729 return va;
730 }
731
732 *found = 0;
733 var_cache_create (&va);
734 va->name = (const GLubyte *) i;
735
736 var_cache_append (vc_head, va);
737
738 return va;
739 }
740
741 static char *
742 parse_string_without_adding (const GLubyte ** inst, struct arb_program *Program)
743 {
744 const GLubyte *i = *inst;
745 (void) Program;
746
747 *inst += _mesa_strlen ((char *) i) + 1;
748
749 return (char *) i;
750 }
751
752 /**
753 * \return -1 if we parse '-', return 1 otherwise
754 */
755 static GLint
756 parse_sign (const GLubyte ** inst)
757 {
758 /*return *(*inst)++ != '+'; */
759
760 if (**inst == '-') {
761 (*inst)++;
762 return -1;
763 }
764 else if (**inst == '+') {
765 (*inst)++;
766 return 1;
767 }
768
769 return 1;
770 }
771
772 /**
773 * parses and returns signed integer
774 */
775 static GLint
776 parse_integer (const GLubyte ** inst, struct arb_program *Program)
777 {
778 GLint sign;
779 GLint value;
780
781 /* check if *inst points to '+' or '-'
782 * if yes, grab the sign and increment *inst
783 */
784 sign = parse_sign (inst);
785
786 /* now check if *inst points to 0
787 * if yes, increment the *inst and return the default value
788 */
789 if (**inst == 0) {
790 (*inst)++;
791 return 0;
792 }
793
794 /* parse the integer as you normally would do it */
795 value = _mesa_atoi (parse_string_without_adding (inst, Program));
796
797 /* now, after terminating 0 there is a position
798 * to parse it - parse_position()
799 */
800 Program->Position = parse_position (inst);
801
802 return value * sign;
803 }
804
805 /**
806 Accumulate this string of digits, and return them as
807 a large integer represented in floating point (for range).
808 If scale is not NULL, also accumulates a power-of-ten
809 integer scale factor that represents the number of digits
810 in the string.
811 */
812 static GLdouble
813 parse_float_string(const GLubyte ** inst, struct arb_program *Program, GLdouble *scale)
814 {
815 GLdouble value = 0.0;
816 GLdouble oscale = 1.0;
817
818 if (**inst == 0) { /* this string of digits is empty-- do nothing */
819 (*inst)++;
820 }
821 else { /* nonempty string-- parse out the digits */
822 while (**inst >= '0' && **inst <= '9') {
823 GLubyte digit = *((*inst)++);
824 value = value * 10.0 + (GLint) (digit - '0');
825 oscale *= 10.0;
826 }
827 assert(**inst == 0); /* integer string should end with 0 */
828 (*inst)++; /* skip over terminating 0 */
829 Program->Position = parse_position(inst); /* skip position (from integer) */
830 }
831 if (scale)
832 *scale = oscale;
833 return value;
834 }
835
836 /**
837 Parse an unsigned floating-point number from this stream of tokenized
838 characters. Example floating-point formats supported:
839 12.34
840 12
841 0.34
842 .34
843 12.34e-4
844 */
845 static GLfloat
846 parse_float (const GLubyte ** inst, struct arb_program *Program)
847 {
848 GLint exponent;
849 GLdouble whole, fraction, fracScale = 1.0;
850
851 whole = parse_float_string(inst, Program, 0);
852 fraction = parse_float_string(inst, Program, &fracScale);
853
854 /* Parse signed exponent */
855 exponent = parse_integer(inst, Program); /* This is the exponent */
856
857 /* Assemble parts of floating-point number: */
858 return (GLfloat) ((whole + fraction / fracScale) *
859 _mesa_pow(10.0, (GLfloat) exponent));
860 }
861
862
863 /**
864 */
865 static GLfloat
866 parse_signed_float (const GLubyte ** inst, struct arb_program *Program)
867 {
868 GLint sign = parse_sign (inst);
869 GLfloat value = parse_float (inst, Program);
870 return value * sign;
871 }
872
873 /**
874 * This picks out a constant value from the parsed array. The constant vector is r
875 * returned in the *values array, which should be of length 4.
876 *
877 * \param values - return the vector constant values.
878 * \param size - returns the number elements in valuesOut [1..4]
879 */
880 static GLvoid
881 parse_constant(const GLubyte ** inst, GLfloat *values, GLint *size,
882 struct arb_program *Program,
883 GLboolean use)
884 {
885 GLuint components, i;
886
887 switch (*(*inst)++) {
888 case CONSTANT_SCALAR:
889 if (use == GL_TRUE) {
890 values[0] =
891 values[1] =
892 values[2] = values[3] = parse_float (inst, Program);
893 }
894 else {
895 values[0] =
896 values[1] =
897 values[2] = values[3] = parse_signed_float (inst, Program);
898 }
899 *size = 1;
900 break;
901 case CONSTANT_VECTOR:
902 values[0] = values[1] = values[2] = 0;
903 values[3] = 1;
904 components = *(*inst)++;
905 for (i = 0; i < components; i++) {
906 values[i] = parse_signed_float (inst, Program);
907 }
908 *size = 4;
909 break;
910 default:
911 _mesa_problem(NULL, "unexpected case in parse_constant()");
912 values[0] = 0.0F;
913 *size = 0;
914 }
915 }
916
917 /**
918 * \param offset The offset from the address register that we should
919 * address
920 *
921 * \return 0 on sucess, 1 on error
922 */
923 static GLuint
924 parse_relative_offset(GLcontext *ctx, const GLubyte **inst,
925 struct arb_program *Program, GLint *offset)
926 {
927 (void) ctx;
928 *offset = parse_integer(inst, Program);
929 return 0;
930 }
931
932 /**
933 * \param color 0 if color type is primary, 1 if color type is secondary
934 * \return 0 on sucess, 1 on error
935 */
936 static GLuint
937 parse_color_type (GLcontext * ctx, const GLubyte ** inst, struct arb_program *Program,
938 GLint * color)
939 {
940 (void) ctx; (void) Program;
941 *color = *(*inst)++ != COLOR_PRIMARY;
942 return 0;
943 }
944
945 /**
946 * Get an integer corresponding to a generic vertex attribute.
947 *
948 * \return 0 on sucess, 1 on error
949 */
950 static GLuint
951 parse_generic_attrib_num(GLcontext *ctx, const GLubyte ** inst,
952 struct arb_program *Program, GLuint *attrib)
953 {
954 GLint i = parse_integer(inst, Program);
955
956 if ((i < 0) || (i >= MAX_VERTEX_GENERIC_ATTRIBS))
957 {
958 program_error(ctx, Program->Position,
959 "Invalid generic vertex attribute index");
960 return 1;
961 }
962
963 *attrib = (GLuint) i;
964
965 return 0;
966 }
967
968
969 /**
970 * \param color The index of the color buffer to write into
971 * \return 0 on sucess, 1 on error
972 */
973 static GLuint
974 parse_output_color_num (GLcontext * ctx, const GLubyte ** inst,
975 struct arb_program *Program, GLuint * color)
976 {
977 GLint i = parse_integer (inst, Program);
978
979 if ((i < 0) || (i >= (int)ctx->Const.MaxDrawBuffers)) {
980 *color = 0;
981 program_error(ctx, Program->Position, "Invalid draw buffer index");
982 return 1;
983 }
984
985 *color = (GLuint) i;
986 return 0;
987 }
988
989
990 /**
991 * Validate the index of a texture coordinate
992 *
993 * \param coord The texture unit index
994 * \return 0 on sucess, 1 on error
995 */
996 static GLuint
997 parse_texcoord_num (GLcontext * ctx, const GLubyte ** inst,
998 struct arb_program *Program, GLuint * coord)
999 {
1000 GLint i = parse_integer (inst, Program);
1001
1002 if ((i < 0) || (i >= (int)ctx->Const.MaxTextureCoordUnits)) {
1003 program_error(ctx, Program->Position, "Invalid texture coordinate index");
1004 return 1;
1005 }
1006
1007 *coord = (GLuint) i;
1008 return 0;
1009 }
1010
1011
1012 /**
1013 * Validate the index of a texture image unit
1014 *
1015 * \param coord The texture unit index
1016 * \return 0 on sucess, 1 on error
1017 */
1018 static GLuint
1019 parse_teximage_num (GLcontext * ctx, const GLubyte ** inst,
1020 struct arb_program *Program, GLuint * coord)
1021 {
1022 GLint i = parse_integer (inst, Program);
1023
1024 if ((i < 0) || (i >= (int)ctx->Const.MaxTextureImageUnits)) {
1025 char s[100];
1026 _mesa_snprintf(s, sizeof(s), "Invalid texture image index %d (%u is max)",
1027 i, ctx->Const.MaxTextureImageUnits);
1028 program_error(ctx, Program->Position, s);
1029 return 1;
1030 }
1031
1032 *coord = (GLuint) i;
1033 return 0;
1034 }
1035
1036
1037 /**
1038 * \param coord The weight index
1039 * \return 0 on sucess, 1 on error
1040 */
1041 static GLuint
1042 parse_weight_num (GLcontext * ctx, const GLubyte ** inst, struct arb_program *Program,
1043 GLint * coord)
1044 {
1045 *coord = parse_integer (inst, Program);
1046
1047 if ((*coord < 0) || (*coord >= 1)) {
1048 program_error(ctx, Program->Position, "Invalid weight index");
1049 return 1;
1050 }
1051
1052 return 0;
1053 }
1054
1055 /**
1056 * \param coord The clip plane index
1057 * \return 0 on sucess, 1 on error
1058 */
1059 static GLuint
1060 parse_clipplane_num (GLcontext * ctx, const GLubyte ** inst,
1061 struct arb_program *Program, GLint * coord)
1062 {
1063 *coord = parse_integer (inst, Program);
1064
1065 if ((*coord < 0) || (*coord >= (GLint) ctx->Const.MaxClipPlanes)) {
1066 program_error(ctx, Program->Position, "Invalid clip plane index");
1067 return 1;
1068 }
1069
1070 return 0;
1071 }
1072
1073
1074 /**
1075 * \return 0 on front face, 1 on back face
1076 */
1077 static GLuint
1078 parse_face_type (const GLubyte ** inst)
1079 {
1080 switch (*(*inst)++) {
1081 case FACE_FRONT:
1082 return 0;
1083
1084 case FACE_BACK:
1085 return 1;
1086 }
1087 return 0;
1088 }
1089
1090
1091 /**
1092 * Given a matrix and a modifier token on the binary array, return tokens
1093 * that _mesa_fetch_state() [program.c] can understand.
1094 *
1095 * \param matrix - the matrix we are talking about
1096 * \param matrix_idx - the index of the matrix we have (for texture & program matricies)
1097 * \param matrix_modifier - the matrix modifier (trans, inv, etc)
1098 * \return 0 on sucess, 1 on failure
1099 */
1100 static GLuint
1101 parse_matrix (GLcontext * ctx, const GLubyte ** inst, struct arb_program *Program,
1102 GLint * matrix, GLint * matrix_idx, GLint * matrix_modifier)
1103 {
1104 GLubyte mat = *(*inst)++;
1105
1106 *matrix_idx = 0;
1107
1108 switch (mat) {
1109 case MATRIX_MODELVIEW:
1110 *matrix = STATE_MODELVIEW_MATRIX;
1111 *matrix_idx = parse_integer (inst, Program);
1112 if (*matrix_idx > 0) {
1113 program_error(ctx, Program->Position,
1114 "ARB_vertex_blend not supported");
1115 return 1;
1116 }
1117 break;
1118
1119 case MATRIX_PROJECTION:
1120 *matrix = STATE_PROJECTION_MATRIX;
1121 break;
1122
1123 case MATRIX_MVP:
1124 *matrix = STATE_MVP_MATRIX;
1125 break;
1126
1127 case MATRIX_TEXTURE:
1128 *matrix = STATE_TEXTURE_MATRIX;
1129 *matrix_idx = parse_integer (inst, Program);
1130 if (*matrix_idx >= (GLint) ctx->Const.MaxTextureUnits) {
1131 program_error(ctx, Program->Position, "Invalid Texture Unit");
1132 /* bad *matrix_id */
1133 return 1;
1134 }
1135 break;
1136
1137 /* This is not currently supported (ARB_matrix_palette) */
1138 case MATRIX_PALETTE:
1139 *matrix_idx = parse_integer (inst, Program);
1140 program_error(ctx, Program->Position,
1141 "ARB_matrix_palette not supported");
1142 return 1;
1143 break;
1144
1145 case MATRIX_PROGRAM:
1146 *matrix = STATE_PROGRAM_MATRIX;
1147 *matrix_idx = parse_integer (inst, Program);
1148 if (*matrix_idx >= (GLint) ctx->Const.MaxProgramMatrices) {
1149 program_error(ctx, Program->Position, "Invalid Program Matrix");
1150 /* bad *matrix_idx */
1151 return 1;
1152 }
1153 break;
1154 }
1155
1156 switch (*(*inst)++) {
1157 case MATRIX_MODIFIER_IDENTITY:
1158 *matrix_modifier = 0;
1159 break;
1160 case MATRIX_MODIFIER_INVERSE:
1161 *matrix_modifier = STATE_MATRIX_INVERSE;
1162 break;
1163 case MATRIX_MODIFIER_TRANSPOSE:
1164 *matrix_modifier = STATE_MATRIX_TRANSPOSE;
1165 break;
1166 case MATRIX_MODIFIER_INVTRANS:
1167 *matrix_modifier = STATE_MATRIX_INVTRANS;
1168 break;
1169 }
1170
1171 return 0;
1172 }
1173
1174
1175 /**
1176 * This parses a state string (rather, the binary version of it) into
1177 * a 6-token sequence as described in _mesa_fetch_state() [program.c]
1178 *
1179 * \param inst - the start in the binary arry to start working from
1180 * \param state_tokens - the storage for the 6-token state description
1181 * \return - 0 on sucess, 1 on error
1182 */
1183 static GLuint
1184 parse_state_single_item (GLcontext * ctx, const GLubyte ** inst,
1185 struct arb_program *Program,
1186 gl_state_index state_tokens[STATE_LENGTH])
1187 {
1188 GLubyte token = *(*inst)++;
1189
1190 switch (token) {
1191 case STATE_MATERIAL_PARSER:
1192 state_tokens[0] = STATE_MATERIAL;
1193 state_tokens[1] = parse_face_type (inst);
1194 switch (*(*inst)++) {
1195 case MATERIAL_AMBIENT:
1196 state_tokens[2] = STATE_AMBIENT;
1197 break;
1198 case MATERIAL_DIFFUSE:
1199 state_tokens[2] = STATE_DIFFUSE;
1200 break;
1201 case MATERIAL_SPECULAR:
1202 state_tokens[2] = STATE_SPECULAR;
1203 break;
1204 case MATERIAL_EMISSION:
1205 state_tokens[2] = STATE_EMISSION;
1206 break;
1207 case MATERIAL_SHININESS:
1208 state_tokens[2] = STATE_SHININESS;
1209 break;
1210 }
1211 break;
1212
1213 case STATE_LIGHT_PARSER:
1214 state_tokens[0] = STATE_LIGHT;
1215 state_tokens[1] = parse_integer (inst, Program);
1216
1217 /* Check the value of state_tokens[1] against the # of lights */
1218 if (state_tokens[1] >= (GLint) ctx->Const.MaxLights) {
1219 program_error(ctx, Program->Position, "Invalid Light Number");
1220 /* bad state_tokens[1] */
1221 return 1;
1222 }
1223
1224 switch (*(*inst)++) {
1225 case LIGHT_AMBIENT:
1226 state_tokens[2] = STATE_AMBIENT;
1227 break;
1228 case LIGHT_DIFFUSE:
1229 state_tokens[2] = STATE_DIFFUSE;
1230 break;
1231 case LIGHT_SPECULAR:
1232 state_tokens[2] = STATE_SPECULAR;
1233 break;
1234 case LIGHT_POSITION:
1235 state_tokens[2] = STATE_POSITION;
1236 break;
1237 case LIGHT_ATTENUATION:
1238 state_tokens[2] = STATE_ATTENUATION;
1239 break;
1240 case LIGHT_HALF:
1241 state_tokens[2] = STATE_HALF_VECTOR;
1242 break;
1243 case LIGHT_SPOT_DIRECTION:
1244 state_tokens[2] = STATE_SPOT_DIRECTION;
1245 break;
1246 }
1247 break;
1248
1249 case STATE_LIGHT_MODEL:
1250 switch (*(*inst)++) {
1251 case LIGHT_MODEL_AMBIENT:
1252 state_tokens[0] = STATE_LIGHTMODEL_AMBIENT;
1253 break;
1254 case LIGHT_MODEL_SCENECOLOR:
1255 state_tokens[0] = STATE_LIGHTMODEL_SCENECOLOR;
1256 state_tokens[1] = parse_face_type (inst);
1257 break;
1258 }
1259 break;
1260
1261 case STATE_LIGHT_PROD:
1262 state_tokens[0] = STATE_LIGHTPROD;
1263 state_tokens[1] = parse_integer (inst, Program);
1264
1265 /* Check the value of state_tokens[1] against the # of lights */
1266 if (state_tokens[1] >= (GLint) ctx->Const.MaxLights) {
1267 program_error(ctx, Program->Position, "Invalid Light Number");
1268 /* bad state_tokens[1] */
1269 return 1;
1270 }
1271
1272 state_tokens[2] = parse_face_type (inst);
1273 switch (*(*inst)++) {
1274 case LIGHT_PROD_AMBIENT:
1275 state_tokens[3] = STATE_AMBIENT;
1276 break;
1277 case LIGHT_PROD_DIFFUSE:
1278 state_tokens[3] = STATE_DIFFUSE;
1279 break;
1280 case LIGHT_PROD_SPECULAR:
1281 state_tokens[3] = STATE_SPECULAR;
1282 break;
1283 }
1284 break;
1285
1286
1287 case STATE_FOG:
1288 switch (*(*inst)++) {
1289 case FOG_COLOR:
1290 state_tokens[0] = STATE_FOG_COLOR;
1291 break;
1292 case FOG_PARAMS:
1293 state_tokens[0] = STATE_FOG_PARAMS;
1294 break;
1295 }
1296 break;
1297
1298 case STATE_TEX_ENV:
1299 state_tokens[1] = parse_integer (inst, Program);
1300 switch (*(*inst)++) {
1301 case TEX_ENV_COLOR:
1302 state_tokens[0] = STATE_TEXENV_COLOR;
1303 break;
1304 }
1305 break;
1306
1307 case STATE_TEX_GEN:
1308 {
1309 GLuint type, coord;
1310
1311 state_tokens[0] = STATE_TEXGEN;
1312 /*state_tokens[1] = parse_integer (inst, Program);*/ /* Texture Unit */
1313
1314 if (parse_texcoord_num (ctx, inst, Program, &coord))
1315 return 1;
1316 state_tokens[1] = coord;
1317
1318 /* EYE or OBJECT */
1319 type = *(*inst)++;
1320
1321 /* 0 - s, 1 - t, 2 - r, 3 - q */
1322 coord = *(*inst)++;
1323
1324 if (type == TEX_GEN_EYE) {
1325 switch (coord) {
1326 case COMPONENT_X:
1327 state_tokens[2] = STATE_TEXGEN_EYE_S;
1328 break;
1329 case COMPONENT_Y:
1330 state_tokens[2] = STATE_TEXGEN_EYE_T;
1331 break;
1332 case COMPONENT_Z:
1333 state_tokens[2] = STATE_TEXGEN_EYE_R;
1334 break;
1335 case COMPONENT_W:
1336 state_tokens[2] = STATE_TEXGEN_EYE_Q;
1337 break;
1338 default:
1339 _mesa_problem(ctx, "bad texgen component in "
1340 "parse_state_single_item()");
1341 }
1342 }
1343 else {
1344 switch (coord) {
1345 case COMPONENT_X:
1346 state_tokens[2] = STATE_TEXGEN_OBJECT_S;
1347 break;
1348 case COMPONENT_Y:
1349 state_tokens[2] = STATE_TEXGEN_OBJECT_T;
1350 break;
1351 case COMPONENT_Z:
1352 state_tokens[2] = STATE_TEXGEN_OBJECT_R;
1353 break;
1354 case COMPONENT_W:
1355 state_tokens[2] = STATE_TEXGEN_OBJECT_Q;
1356 break;
1357 default:
1358 _mesa_problem(ctx, "bad texgen component in "
1359 "parse_state_single_item()");
1360 }
1361 }
1362 }
1363 break;
1364
1365 case STATE_DEPTH:
1366 switch (*(*inst)++) {
1367 case DEPTH_RANGE:
1368 state_tokens[0] = STATE_DEPTH_RANGE;
1369 break;
1370 }
1371 break;
1372
1373 case STATE_CLIP_PLANE:
1374 state_tokens[0] = STATE_CLIPPLANE;
1375 if (parse_clipplane_num (ctx, inst, Program,
1376 (GLint *) &state_tokens[1]))
1377 return 1;
1378 break;
1379
1380 case STATE_POINT:
1381 switch (*(*inst)++) {
1382 case POINT_SIZE:
1383 state_tokens[0] = STATE_POINT_SIZE;
1384 break;
1385
1386 case POINT_ATTENUATION:
1387 state_tokens[0] = STATE_POINT_ATTENUATION;
1388 break;
1389 }
1390 break;
1391
1392 /* XXX: I think this is the correct format for a matrix row */
1393 case STATE_MATRIX_ROWS:
1394 if (parse_matrix(ctx, inst, Program,
1395 (GLint *) &state_tokens[0],
1396 (GLint *) &state_tokens[1],
1397 (GLint *) &state_tokens[4]))
1398 return 1;
1399
1400 state_tokens[2] = parse_integer (inst, Program); /* The first row to grab */
1401
1402 if ((**inst) != 0) { /* Either the last row, 0 */
1403 state_tokens[3] = parse_integer (inst, Program);
1404 if (state_tokens[3] < state_tokens[2]) {
1405 program_error(ctx, Program->Position,
1406 "Second matrix index less than the first");
1407 /* state_tokens[4] vs. state_tokens[3] */
1408 return 1;
1409 }
1410 }
1411 else {
1412 state_tokens[3] = state_tokens[2];
1413 (*inst)++;
1414 }
1415 break;
1416 }
1417
1418 return 0;
1419 }
1420
1421 /**
1422 * This parses a state string (rather, the binary version of it) into
1423 * a 6-token similar for the state fetching code in program.c
1424 *
1425 * One might ask, why fetch these parameters into just like you fetch
1426 * state when they are already stored in other places?
1427 *
1428 * Because of array offsets -> We can stick env/local parameters in the
1429 * middle of a parameter array and then index someplace into the array
1430 * when we execute.
1431 *
1432 * One optimization might be to only do this for the cases where the
1433 * env/local parameters end up inside of an array, and leave the
1434 * single parameters (or arrays of pure env/local pareameters) in their
1435 * respective register files.
1436 *
1437 * For ENV parameters, the format is:
1438 * state_tokens[0] = STATE_FRAGMENT_PROGRAM / STATE_VERTEX_PROGRAM
1439 * state_tokens[1] = STATE_ENV
1440 * state_tokens[2] = the parameter index
1441 *
1442 * for LOCAL parameters, the format is:
1443 * state_tokens[0] = STATE_FRAGMENT_PROGRAM / STATE_VERTEX_PROGRAM
1444 * state_tokens[1] = STATE_LOCAL
1445 * state_tokens[2] = the parameter index
1446 *
1447 * \param inst - the start in the binary arry to start working from
1448 * \param state_tokens - the storage for the 6-token state description
1449 * \return - 0 on sucess, 1 on failure
1450 */
1451 static GLuint
1452 parse_program_single_item (GLcontext * ctx, const GLubyte ** inst,
1453 struct arb_program *Program,
1454 gl_state_index state_tokens[STATE_LENGTH])
1455 {
1456 if (Program->Base.Target == GL_FRAGMENT_PROGRAM_ARB)
1457 state_tokens[0] = STATE_FRAGMENT_PROGRAM;
1458 else
1459 state_tokens[0] = STATE_VERTEX_PROGRAM;
1460
1461
1462 switch (*(*inst)++) {
1463 case PROGRAM_PARAM_ENV:
1464 state_tokens[1] = STATE_ENV;
1465 state_tokens[2] = parse_integer (inst, Program);
1466
1467 /* Check state_tokens[2] against the number of ENV parameters available */
1468 if (((Program->Base.Target == GL_FRAGMENT_PROGRAM_ARB) &&
1469 (state_tokens[2] >= (GLint) ctx->Const.FragmentProgram.MaxEnvParams))
1470 ||
1471 ((Program->Base.Target == GL_VERTEX_PROGRAM_ARB) &&
1472 (state_tokens[2] >= (GLint) ctx->Const.VertexProgram.MaxEnvParams))) {
1473 program_error(ctx, Program->Position,
1474 "Invalid Program Env Parameter");
1475 /* bad state_tokens[2] */
1476 return 1;
1477 }
1478
1479 break;
1480
1481 case PROGRAM_PARAM_LOCAL:
1482 state_tokens[1] = STATE_LOCAL;
1483 state_tokens[2] = parse_integer (inst, Program);
1484
1485 /* Check state_tokens[2] against the number of LOCAL parameters available */
1486 if (((Program->Base.Target == GL_FRAGMENT_PROGRAM_ARB) &&
1487 (state_tokens[2] >= (GLint) ctx->Const.FragmentProgram.MaxLocalParams))
1488 ||
1489 ((Program->Base.Target == GL_VERTEX_PROGRAM_ARB) &&
1490 (state_tokens[2] >= (GLint) ctx->Const.VertexProgram.MaxLocalParams))) {
1491 program_error(ctx, Program->Position,
1492 "Invalid Program Local Parameter");
1493 /* bad state_tokens[2] */
1494 return 1;
1495 }
1496 break;
1497 }
1498
1499 return 0;
1500 }
1501
1502 /**
1503 * For ARB_vertex_program, programs are not allowed to use both an explicit
1504 * vertex attribute and a generic vertex attribute corresponding to the same
1505 * state. See section 2.14.3.1 of the GL_ARB_vertex_program spec.
1506 *
1507 * This will walk our var_cache and make sure that nobody does anything fishy.
1508 *
1509 * \return 0 on sucess, 1 on error
1510 */
1511 static GLuint
1512 generic_attrib_check(struct var_cache *vc_head)
1513 {
1514 int a;
1515 struct var_cache *curr;
1516 GLboolean explicitAttrib[MAX_VERTEX_GENERIC_ATTRIBS],
1517 genericAttrib[MAX_VERTEX_GENERIC_ATTRIBS];
1518
1519 for (a=0; a<MAX_VERTEX_GENERIC_ATTRIBS; a++) {
1520 explicitAttrib[a] = GL_FALSE;
1521 genericAttrib[a] = GL_FALSE;
1522 }
1523
1524 curr = vc_head;
1525 while (curr) {
1526 if (curr->type == vt_attrib) {
1527 if (curr->attrib_is_generic) {
1528 GLuint attr = (curr->attrib_binding == 0)
1529 ? 0 : (curr->attrib_binding - VERT_ATTRIB_GENERIC0);
1530 assert(attr < MAX_VERTEX_GENERIC_ATTRIBS);
1531 genericAttrib[attr] = GL_TRUE;
1532 }
1533 else {
1534 assert(curr->attrib_binding < MAX_VERTEX_GENERIC_ATTRIBS);
1535 explicitAttrib[ curr->attrib_binding ] = GL_TRUE;
1536 }
1537 }
1538
1539 curr = curr->next;
1540 }
1541
1542 for (a=0; a<MAX_VERTEX_GENERIC_ATTRIBS; a++) {
1543 if ((explicitAttrib[a]) && (genericAttrib[a]))
1544 return 1;
1545 }
1546
1547 return 0;
1548 }
1549
1550 /**
1551 * This will handle the binding side of an ATTRIB var declaration
1552 *
1553 * \param inputReg returns the input register index, one of the
1554 * VERT_ATTRIB_* or FRAG_ATTRIB_* values.
1555 * \return returns 0 on success, 1 on error
1556 */
1557 static GLuint
1558 parse_attrib_binding(GLcontext * ctx, const GLubyte ** inst,
1559 struct arb_program *Program,
1560 GLuint *inputReg, GLuint *is_generic)
1561 {
1562 GLint err = 0;
1563
1564 *is_generic = 0;
1565
1566 if (Program->Base.Target == GL_FRAGMENT_PROGRAM_ARB) {
1567 switch (*(*inst)++) {
1568 case FRAGMENT_ATTRIB_COLOR:
1569 {
1570 GLint coord;
1571 err = parse_color_type (ctx, inst, Program, &coord);
1572 *inputReg = FRAG_ATTRIB_COL0 + coord;
1573 }
1574 break;
1575 case FRAGMENT_ATTRIB_TEXCOORD:
1576 {
1577 GLuint texcoord = 0;
1578 err = parse_texcoord_num (ctx, inst, Program, &texcoord);
1579 *inputReg = FRAG_ATTRIB_TEX0 + texcoord;
1580 }
1581 break;
1582 case FRAGMENT_ATTRIB_FOGCOORD:
1583 *inputReg = FRAG_ATTRIB_FOGC;
1584 break;
1585 case FRAGMENT_ATTRIB_POSITION:
1586 *inputReg = FRAG_ATTRIB_WPOS;
1587 break;
1588 default:
1589 err = 1;
1590 break;
1591 }
1592 }
1593 else {
1594 switch (*(*inst)++) {
1595 case VERTEX_ATTRIB_POSITION:
1596 *inputReg = VERT_ATTRIB_POS;
1597 break;
1598
1599 case VERTEX_ATTRIB_WEIGHT:
1600 {
1601 GLint weight;
1602 err = parse_weight_num (ctx, inst, Program, &weight);
1603 *inputReg = VERT_ATTRIB_WEIGHT;
1604 #if 1
1605 /* hack for Warcraft (see bug 8060) */
1606 _mesa_warning(ctx, "Application error: vertex program uses 'vertex.weight' but GL_ARB_vertex_blend not supported.");
1607 break;
1608 #else
1609 program_error(ctx, Program->Position,
1610 "ARB_vertex_blend not supported");
1611 return 1;
1612 #endif
1613 }
1614
1615 case VERTEX_ATTRIB_NORMAL:
1616 *inputReg = VERT_ATTRIB_NORMAL;
1617 break;
1618
1619 case VERTEX_ATTRIB_COLOR:
1620 {
1621 GLint color;
1622 err = parse_color_type (ctx, inst, Program, &color);
1623 if (color) {
1624 *inputReg = VERT_ATTRIB_COLOR1;
1625 }
1626 else {
1627 *inputReg = VERT_ATTRIB_COLOR0;
1628 }
1629 }
1630 break;
1631
1632 case VERTEX_ATTRIB_FOGCOORD:
1633 *inputReg = VERT_ATTRIB_FOG;
1634 break;
1635
1636 case VERTEX_ATTRIB_TEXCOORD:
1637 {
1638 GLuint unit = 0;
1639 err = parse_texcoord_num (ctx, inst, Program, &unit);
1640 *inputReg = VERT_ATTRIB_TEX0 + unit;
1641 }
1642 break;
1643
1644 case VERTEX_ATTRIB_MATRIXINDEX:
1645 /* Not supported at this time */
1646 {
1647 const char *msg = "ARB_palette_matrix not supported";
1648 parse_integer (inst, Program);
1649 program_error(ctx, Program->Position, msg);
1650 }
1651 return 1;
1652
1653 case VERTEX_ATTRIB_GENERIC:
1654 {
1655 GLuint attrib;
1656 err = parse_generic_attrib_num(ctx, inst, Program, &attrib);
1657 if (!err) {
1658 *is_generic = 1;
1659 /* Add VERT_ATTRIB_GENERIC0 here because ARB_vertex_program's
1660 * attributes do not alias the conventional vertex
1661 * attributes.
1662 */
1663 if (attrib > 0)
1664 *inputReg = attrib + VERT_ATTRIB_GENERIC0;
1665 else
1666 *inputReg = 0;
1667 }
1668 }
1669 break;
1670
1671 default:
1672 err = 1;
1673 break;
1674 }
1675 }
1676
1677 if (err) {
1678 program_error(ctx, Program->Position, "Bad attribute binding");
1679 }
1680
1681 return err;
1682 }
1683
1684
1685 /**
1686 * This translates between a binary token for an output variable type
1687 * and the mesa token for the same thing.
1688 *
1689 * \param inst The parsed tokens
1690 * \param outputReg Returned index/number of the output register,
1691 * one of the VERT_RESULT_* or FRAG_RESULT_* values.
1692 */
1693 static GLuint
1694 parse_result_binding(GLcontext *ctx, const GLubyte **inst,
1695 GLuint *outputReg, struct arb_program *Program)
1696 {
1697 const GLubyte token = *(*inst)++;
1698
1699 switch (token) {
1700 case FRAGMENT_RESULT_COLOR:
1701 if (Program->Base.Target == GL_FRAGMENT_PROGRAM_ARB) {
1702 GLuint out_color;
1703
1704 /* This gets result of the color buffer we're supposed to
1705 * draw into. This pertains to GL_ARB_draw_buffers.
1706 */
1707 parse_output_color_num(ctx, inst, Program, &out_color);
1708 ASSERT(out_color < MAX_DRAW_BUFFERS);
1709 *outputReg = FRAG_RESULT_COLOR;
1710 }
1711 else {
1712 /* for vtx programs, this is VERTEX_RESULT_POSITION */
1713 *outputReg = VERT_RESULT_HPOS;
1714 }
1715 break;
1716
1717 case FRAGMENT_RESULT_DEPTH:
1718 if (Program->Base.Target == GL_FRAGMENT_PROGRAM_ARB) {
1719 /* for frag programs, this is FRAGMENT_RESULT_DEPTH */
1720 *outputReg = FRAG_RESULT_DEPTH;
1721 }
1722 else {
1723 /* for vtx programs, this is VERTEX_RESULT_COLOR */
1724 GLint color_type;
1725 GLuint face_type = parse_face_type(inst);
1726 GLint err = parse_color_type(ctx, inst, Program, &color_type);
1727 if (err)
1728 return 1;
1729
1730 if (face_type) {
1731 /* back face */
1732 if (color_type) {
1733 *outputReg = VERT_RESULT_BFC1; /* secondary color */
1734 }
1735 else {
1736 *outputReg = VERT_RESULT_BFC0; /* primary color */
1737 }
1738 }
1739 else {
1740 /* front face */
1741 if (color_type) {
1742 *outputReg = VERT_RESULT_COL1; /* secondary color */
1743 }
1744 /* primary color */
1745 else {
1746 *outputReg = VERT_RESULT_COL0; /* primary color */
1747 }
1748 }
1749 }
1750 break;
1751
1752 case VERTEX_RESULT_FOGCOORD:
1753 *outputReg = VERT_RESULT_FOGC;
1754 break;
1755
1756 case VERTEX_RESULT_POINTSIZE:
1757 *outputReg = VERT_RESULT_PSIZ;
1758 break;
1759
1760 case VERTEX_RESULT_TEXCOORD:
1761 {
1762 GLuint unit;
1763 if (parse_texcoord_num (ctx, inst, Program, &unit))
1764 return 1;
1765 *outputReg = VERT_RESULT_TEX0 + unit;
1766 }
1767 break;
1768 }
1769
1770 Program->Base.OutputsWritten |= (1 << *outputReg);
1771
1772 return 0;
1773 }
1774
1775
1776 /**
1777 * This handles the declaration of ATTRIB variables
1778 *
1779 * XXX: Still needs
1780 * parse_vert_attrib_binding(), or something like that
1781 *
1782 * \return 0 on sucess, 1 on error
1783 */
1784 static GLint
1785 parse_attrib (GLcontext * ctx, const GLubyte ** inst, struct var_cache **vc_head,
1786 struct arb_program *Program)
1787 {
1788 GLuint found;
1789 struct var_cache *attrib_var;
1790
1791 attrib_var = parse_string (inst, vc_head, Program, &found);
1792 Program->Position = parse_position (inst);
1793 if (found) {
1794 program_error2(ctx, Program->Position,
1795 "Duplicate variable declaration",
1796 (char *) attrib_var->name);
1797 return 1;
1798 }
1799
1800 attrib_var->type = vt_attrib;
1801
1802 if (parse_attrib_binding(ctx, inst, Program, &attrib_var->attrib_binding,
1803 &attrib_var->attrib_is_generic))
1804 return 1;
1805
1806 if (generic_attrib_check(*vc_head)) {
1807 program_error(ctx, Program->Position,
1808 "Cannot use both a generic vertex attribute "
1809 "and a specific attribute of the same type");
1810 return 1;
1811 }
1812
1813 Program->Base.NumAttributes++;
1814 return 0;
1815 }
1816
1817 /**
1818 * \param use -- TRUE if we're called when declaring implicit parameters,
1819 * FALSE if we're declaraing variables. This has to do with
1820 * if we get a signed or unsigned float for scalar constants
1821 */
1822 static GLuint
1823 parse_param_elements (GLcontext * ctx, const GLubyte ** inst,
1824 struct var_cache *param_var,
1825 struct arb_program *Program, GLboolean use)
1826 {
1827 GLint idx;
1828 GLuint err = 0;
1829 gl_state_index state_tokens[STATE_LENGTH] = {0, 0, 0, 0, 0};
1830
1831 GLubyte token = *(*inst)++;
1832
1833 switch (token) {
1834 case PARAM_STATE_ELEMENT:
1835 if (parse_state_single_item (ctx, inst, Program, state_tokens))
1836 return 1;
1837
1838 /* If we adding STATE_MATRIX that has multiple rows, we need to
1839 * unroll it and call _mesa_add_state_reference() for each row
1840 */
1841 if ((state_tokens[0] == STATE_MODELVIEW_MATRIX ||
1842 state_tokens[0] == STATE_PROJECTION_MATRIX ||
1843 state_tokens[0] == STATE_MVP_MATRIX ||
1844 state_tokens[0] == STATE_TEXTURE_MATRIX ||
1845 state_tokens[0] == STATE_PROGRAM_MATRIX)
1846 && (state_tokens[2] != state_tokens[3])) {
1847 GLint row;
1848 const GLint first_row = state_tokens[2];
1849 const GLint last_row = state_tokens[3];
1850
1851 for (row = first_row; row <= last_row; row++) {
1852 state_tokens[2] = state_tokens[3] = row;
1853
1854 idx = _mesa_add_state_reference(Program->Base.Parameters,
1855 state_tokens);
1856 if (param_var->param_binding_begin == ~0U)
1857 param_var->param_binding_begin = idx;
1858 param_var->param_binding_length++;
1859 }
1860 }
1861 else {
1862 idx = _mesa_add_state_reference(Program->Base.Parameters,
1863 state_tokens);
1864 if (param_var->param_binding_begin == ~0U)
1865 param_var->param_binding_begin = idx;
1866 param_var->param_binding_length++;
1867 }
1868 break;
1869
1870 case PARAM_PROGRAM_ELEMENT:
1871 if (parse_program_single_item (ctx, inst, Program, state_tokens))
1872 return 1;
1873 idx = _mesa_add_state_reference (Program->Base.Parameters, state_tokens);
1874 if (param_var->param_binding_begin == ~0U)
1875 param_var->param_binding_begin = idx;
1876 param_var->param_binding_length++;
1877
1878 /* Check if there is more: 0 -> we're done, else its an integer */
1879 if (**inst) {
1880 GLuint out_of_range, new_idx;
1881 GLuint start_idx = state_tokens[2] + 1;
1882 GLuint end_idx = parse_integer (inst, Program);
1883
1884 out_of_range = 0;
1885 if (Program->Base.Target == GL_FRAGMENT_PROGRAM_ARB) {
1886 if (((state_tokens[1] == STATE_ENV)
1887 && (end_idx >= ctx->Const.FragmentProgram.MaxEnvParams))
1888 || ((state_tokens[1] == STATE_LOCAL)
1889 && (end_idx >=
1890 ctx->Const.FragmentProgram.MaxLocalParams)))
1891 out_of_range = 1;
1892 }
1893 else {
1894 if (((state_tokens[1] == STATE_ENV)
1895 && (end_idx >= ctx->Const.VertexProgram.MaxEnvParams))
1896 || ((state_tokens[1] == STATE_LOCAL)
1897 && (end_idx >=
1898 ctx->Const.VertexProgram.MaxLocalParams)))
1899 out_of_range = 1;
1900 }
1901 if (out_of_range) {
1902 program_error(ctx, Program->Position,
1903 "Invalid Program Parameter"); /*end_idx*/
1904 return 1;
1905 }
1906
1907 for (new_idx = start_idx; new_idx <= end_idx; new_idx++) {
1908 state_tokens[2] = new_idx;
1909 idx = _mesa_add_state_reference(Program->Base.Parameters,
1910 state_tokens);
1911 param_var->param_binding_length++;
1912 }
1913 }
1914 else {
1915 (*inst)++;
1916 }
1917 break;
1918
1919 case PARAM_CONSTANT:
1920 /* parsing something like {1.0, 2.0, 3.0, 4.0} */
1921 {
1922 GLfloat const_values[4];
1923 GLint size;
1924 parse_constant(inst, const_values, &size, Program, use);
1925 if (param_var->name[0] == ' ') {
1926 /* this is an unnamed constant */
1927 idx = _mesa_add_unnamed_constant(Program->Base.Parameters,
1928 const_values, size,
1929 &param_var->swizzle);
1930 }
1931 else {
1932 /* named parameter/constant */
1933 idx = _mesa_add_named_constant(Program->Base.Parameters,
1934 (char *) param_var->name,
1935 const_values, size);
1936 }
1937 if (param_var->param_binding_begin == ~0U)
1938 param_var->param_binding_begin = idx;
1939 param_var->param_binding_type = PROGRAM_STATE_VAR;
1940 /* Note: when we reference this parameter in an instruction later,
1941 * we'll check if it's really a constant/immediate and set the
1942 * instruction register type appropriately.
1943 */
1944 param_var->param_binding_length++;
1945 }
1946 break;
1947
1948 default:
1949 program_error(ctx, Program->Position,
1950 "Unexpected token (in parse_param_elements())");
1951 return 1;
1952 }
1953
1954 Program->Base.NumParameters = Program->Base.Parameters->NumParameters;
1955
1956 /* Make sure we haven't blown past our parameter limits */
1957 if (((Program->Base.Target == GL_VERTEX_PROGRAM_ARB) &&
1958 (Program->Base.NumParameters >
1959 ctx->Const.VertexProgram.MaxLocalParams))
1960 || ((Program->Base.Target == GL_FRAGMENT_PROGRAM_ARB)
1961 && (Program->Base.NumParameters >
1962 ctx->Const.FragmentProgram.MaxLocalParams))) {
1963 program_error(ctx, Program->Position, "Too many parameter variables");
1964 return 1;
1965 }
1966
1967 return err;
1968 }
1969
1970
1971 /**
1972 * This picks out PARAM program parameter bindings.
1973 *
1974 * XXX: This needs to be stressed & tested
1975 *
1976 * \return 0 on sucess, 1 on error
1977 */
1978 static GLuint
1979 parse_param (GLcontext * ctx, const GLubyte ** inst, struct var_cache **vc_head,
1980 struct arb_program *Program)
1981 {
1982 GLuint found, err;
1983 GLint specified_length;
1984 struct var_cache *param_var;
1985
1986 err = 0;
1987 param_var = parse_string (inst, vc_head, Program, &found);
1988 Program->Position = parse_position (inst);
1989
1990 if (found) {
1991 program_error2(ctx, Program->Position,
1992 "Duplicate variable declaration",
1993 (char *) param_var->name);
1994 return 1;
1995 }
1996
1997 specified_length = parse_integer (inst, Program);
1998
1999 if (specified_length < 0) {
2000 program_error(ctx, Program->Position, "Negative parameter array length");
2001 return 1;
2002 }
2003
2004 param_var->type = vt_param;
2005 param_var->param_binding_length = 0;
2006
2007 /* Right now, everything is shoved into the main state register file.
2008 *
2009 * In the future, it would be nice to leave things ENV/LOCAL params
2010 * in their respective register files, if possible
2011 */
2012 param_var->param_binding_type = PROGRAM_STATE_VAR;
2013
2014 /* Remember to:
2015 * * - add each guy to the parameter list
2016 * * - increment the param_var->param_binding_len
2017 * * - store the param_var->param_binding_begin for the first one
2018 * * - compare the actual len to the specified len at the end
2019 */
2020 while (**inst != PARAM_NULL) {
2021 if (parse_param_elements (ctx, inst, param_var, Program, GL_FALSE))
2022 return 1;
2023 }
2024
2025 /* Test array length here! */
2026 if (specified_length) {
2027 if (specified_length != (int)param_var->param_binding_length) {
2028 program_error(ctx, Program->Position,
2029 "Declared parameter array length does not match parameter list");
2030 }
2031 }
2032
2033 (*inst)++;
2034
2035 return 0;
2036 }
2037
2038 /**
2039 *
2040 */
2041 static GLuint
2042 parse_param_use (GLcontext * ctx, const GLubyte ** inst, struct var_cache **vc_head,
2043 struct arb_program *Program, struct var_cache **new_var)
2044 {
2045 struct var_cache *param_var;
2046
2047 /* First, insert a dummy entry into the var_cache */
2048 var_cache_create (&param_var);
2049 param_var->name = (const GLubyte *) " ";
2050 param_var->type = vt_param;
2051
2052 param_var->param_binding_length = 0;
2053 /* Don't fill in binding_begin; We use the default value of -1
2054 * to tell if its already initialized, elsewhere.
2055 *
2056 * param_var->param_binding_begin = 0;
2057 */
2058 param_var->param_binding_type = PROGRAM_STATE_VAR;
2059
2060 var_cache_append (vc_head, param_var);
2061
2062 /* Then fill it with juicy parameter goodness */
2063 if (parse_param_elements (ctx, inst, param_var, Program, GL_TRUE))
2064 return 1;
2065
2066 *new_var = param_var;
2067
2068 return 0;
2069 }
2070
2071
2072 /**
2073 * This handles the declaration of TEMP variables
2074 *
2075 * \return 0 on sucess, 1 on error
2076 */
2077 static GLuint
2078 parse_temp (GLcontext * ctx, const GLubyte ** inst, struct var_cache **vc_head,
2079 struct arb_program *Program)
2080 {
2081 GLuint found;
2082 struct var_cache *temp_var;
2083
2084 while (**inst != 0) {
2085 temp_var = parse_string (inst, vc_head, Program, &found);
2086 Program->Position = parse_position (inst);
2087 if (found) {
2088 program_error2(ctx, Program->Position,
2089 "Duplicate variable declaration",
2090 (char *) temp_var->name);
2091 return 1;
2092 }
2093
2094 temp_var->type = vt_temp;
2095
2096 if (((Program->Base.Target == GL_FRAGMENT_PROGRAM_ARB) &&
2097 (Program->Base.NumTemporaries >=
2098 ctx->Const.FragmentProgram.MaxTemps))
2099 || ((Program->Base.Target == GL_VERTEX_PROGRAM_ARB)
2100 && (Program->Base.NumTemporaries >=
2101 ctx->Const.VertexProgram.MaxTemps))) {
2102 program_error(ctx, Program->Position,
2103 "Too many TEMP variables declared");
2104 return 1;
2105 }
2106
2107 temp_var->temp_binding = Program->Base.NumTemporaries;
2108 Program->Base.NumTemporaries++;
2109 }
2110 (*inst)++;
2111
2112 return 0;
2113 }
2114
2115 /**
2116 * This handles variables of the OUTPUT variety
2117 *
2118 * \return 0 on sucess, 1 on error
2119 */
2120 static GLuint
2121 parse_output (GLcontext * ctx, const GLubyte ** inst, struct var_cache **vc_head,
2122 struct arb_program *Program)
2123 {
2124 GLuint found;
2125 struct var_cache *output_var;
2126 GLuint err;
2127
2128 output_var = parse_string (inst, vc_head, Program, &found);
2129 Program->Position = parse_position (inst);
2130 if (found) {
2131 program_error2(ctx, Program->Position,
2132 "Duplicate variable declaration",
2133 (char *) output_var->name);
2134 return 1;
2135 }
2136
2137 output_var->type = vt_output;
2138
2139 err = parse_result_binding(ctx, inst, &output_var->output_binding, Program);
2140 return err;
2141 }
2142
2143 /**
2144 * This handles variables of the ALIAS kind
2145 *
2146 * \return 0 on sucess, 1 on error
2147 */
2148 static GLuint
2149 parse_alias (GLcontext * ctx, const GLubyte ** inst, struct var_cache **vc_head,
2150 struct arb_program *Program)
2151 {
2152 GLuint found;
2153 struct var_cache *temp_var;
2154
2155 temp_var = parse_string (inst, vc_head, Program, &found);
2156 Program->Position = parse_position (inst);
2157
2158 if (found) {
2159 program_error2(ctx, Program->Position,
2160 "Duplicate variable declaration",
2161 (char *) temp_var->name);
2162 return 1;
2163 }
2164
2165 temp_var->type = vt_alias;
2166 temp_var->alias_binding = parse_string (inst, vc_head, Program, &found);
2167 Program->Position = parse_position (inst);
2168
2169 if (!found)
2170 {
2171 program_error2(ctx, Program->Position,
2172 "Undefined alias value",
2173 (char *) temp_var->alias_binding->name);
2174 return 1;
2175 }
2176
2177 return 0;
2178 }
2179
2180 /**
2181 * This handles variables of the ADDRESS kind
2182 *
2183 * \return 0 on sucess, 1 on error
2184 */
2185 static GLuint
2186 parse_address (GLcontext * ctx, const GLubyte ** inst, struct var_cache **vc_head,
2187 struct arb_program *Program)
2188 {
2189 GLuint found;
2190 struct var_cache *temp_var;
2191
2192 while (**inst != 0) {
2193 temp_var = parse_string (inst, vc_head, Program, &found);
2194 Program->Position = parse_position (inst);
2195 if (found) {
2196 program_error2(ctx, Program->Position,
2197 "Duplicate variable declaration",
2198 (char *) temp_var->name);
2199 return 1;
2200 }
2201
2202 temp_var->type = vt_address;
2203
2204 if (Program->Base.NumAddressRegs >=
2205 ctx->Const.VertexProgram.MaxAddressRegs) {
2206 const char *msg = "Too many ADDRESS variables declared";
2207 program_error(ctx, Program->Position, msg);
2208 return 1;
2209 }
2210
2211 temp_var->address_binding = Program->Base.NumAddressRegs;
2212 Program->Base.NumAddressRegs++;
2213 }
2214 (*inst)++;
2215
2216 return 0;
2217 }
2218
2219 /**
2220 * Parse a program declaration
2221 *
2222 * \return 0 on sucess, 1 on error
2223 */
2224 static GLint
2225 parse_declaration (GLcontext * ctx, const GLubyte ** inst, struct var_cache **vc_head,
2226 struct arb_program *Program)
2227 {
2228 GLint err = 0;
2229
2230 switch (*(*inst)++) {
2231 case ADDRESS:
2232 err = parse_address (ctx, inst, vc_head, Program);
2233 break;
2234
2235 case ALIAS:
2236 err = parse_alias (ctx, inst, vc_head, Program);
2237 break;
2238
2239 case ATTRIB:
2240 err = parse_attrib (ctx, inst, vc_head, Program);
2241 break;
2242
2243 case OUTPUT:
2244 err = parse_output (ctx, inst, vc_head, Program);
2245 break;
2246
2247 case PARAM:
2248 err = parse_param (ctx, inst, vc_head, Program);
2249 break;
2250
2251 case TEMP:
2252 err = parse_temp (ctx, inst, vc_head, Program);
2253 break;
2254 }
2255
2256 return err;
2257 }
2258
2259 /**
2260 * Handle the parsing out of a masked destination register, either for a
2261 * vertex or fragment program.
2262 *
2263 * If we are a vertex program, make sure we don't write to
2264 * result.position if we have specified that the program is
2265 * position invariant
2266 *
2267 * \param File - The register file we write to
2268 * \param Index - The register index we write to
2269 * \param WriteMask - The mask controlling which components we write (1->write)
2270 *
2271 * \return 0 on sucess, 1 on error
2272 */
2273 static GLuint
2274 parse_masked_dst_reg (GLcontext * ctx, const GLubyte ** inst,
2275 struct var_cache **vc_head, struct arb_program *Program,
2276 gl_register_file *File, GLuint *Index, GLint *WriteMask)
2277 {
2278 GLuint tmp, result;
2279 struct var_cache *dst;
2280
2281 /* We either have a result register specified, or a
2282 * variable that may or may not be writable
2283 */
2284 switch (*(*inst)++) {
2285 case REGISTER_RESULT:
2286 if (parse_result_binding(ctx, inst, Index, Program))
2287 return 1;
2288 *File = PROGRAM_OUTPUT;
2289 break;
2290
2291 case REGISTER_ESTABLISHED_NAME:
2292 dst = parse_string (inst, vc_head, Program, &result);
2293 Program->Position = parse_position (inst);
2294
2295 /* If the name has never been added to our symbol table, we're hosed */
2296 if (!result) {
2297 program_error(ctx, Program->Position, "0: Undefined variable");
2298 return 1;
2299 }
2300
2301 switch (dst->type) {
2302 case vt_output:
2303 *File = PROGRAM_OUTPUT;
2304 *Index = dst->output_binding;
2305 break;
2306
2307 case vt_temp:
2308 *File = PROGRAM_TEMPORARY;
2309 *Index = dst->temp_binding;
2310 break;
2311
2312 /* If the var type is not vt_output or vt_temp, no go */
2313 default:
2314 program_error(ctx, Program->Position,
2315 "Destination register is read only");
2316 return 1;
2317 }
2318 break;
2319
2320 default:
2321 program_error(ctx, Program->Position,
2322 "Unexpected opcode in parse_masked_dst_reg()");
2323 return 1;
2324 }
2325
2326
2327 /* Position invariance test */
2328 /* This test is done now in syntax portion - when position invariance OPTION
2329 is specified, "result.position" rule is disabled so there is no way
2330 to write the position
2331 */
2332 /*if ((Program->HintPositionInvariant) && (*File == PROGRAM_OUTPUT) &&
2333 (*Index == 0)) {
2334 program_error(ctx, Program->Position,
2335 "Vertex program specified position invariance and wrote vertex position");
2336 }*/
2337
2338 /* And then the mask.
2339 * w,a -> bit 0
2340 * z,b -> bit 1
2341 * y,g -> bit 2
2342 * x,r -> bit 3
2343 *
2344 * ==> Need to reverse the order of bits for this!
2345 */
2346 tmp = (GLint) *(*inst)++;
2347 *WriteMask = (((tmp>>3) & 0x1) |
2348 ((tmp>>1) & 0x2) |
2349 ((tmp<<1) & 0x4) |
2350 ((tmp<<3) & 0x8));
2351
2352 return 0;
2353 }
2354
2355
2356 /**
2357 * Handle the parsing of a address register
2358 *
2359 * \param Index - The register index we write to
2360 *
2361 * \return 0 on sucess, 1 on error
2362 */
2363 static GLuint
2364 parse_address_reg (GLcontext * ctx, const GLubyte ** inst,
2365 struct var_cache **vc_head,
2366 struct arb_program *Program, GLint * Index)
2367 {
2368 struct var_cache *dst;
2369 GLuint result;
2370
2371 *Index = 0; /* XXX */
2372
2373 dst = parse_string (inst, vc_head, Program, &result);
2374 Program->Position = parse_position (inst);
2375
2376 /* If the name has never been added to our symbol table, we're hosed */
2377 if (!result) {
2378 program_error(ctx, Program->Position, "Undefined variable");
2379 return 1;
2380 }
2381
2382 if (dst->type != vt_address) {
2383 program_error(ctx, Program->Position, "Variable is not of type ADDRESS");
2384 return 1;
2385 }
2386
2387 return 0;
2388 }
2389
2390 #if 0 /* unused */
2391 /**
2392 * Handle the parsing out of a masked address register
2393 *
2394 * \param Index - The register index we write to
2395 * \param WriteMask - The mask controlling which components we write (1->write)
2396 *
2397 * \return 0 on sucess, 1 on error
2398 */
2399 static GLuint
2400 parse_masked_address_reg (GLcontext * ctx, const GLubyte ** inst,
2401 struct var_cache **vc_head,
2402 struct arb_program *Program, GLint * Index,
2403 GLboolean * WriteMask)
2404 {
2405 if (parse_address_reg (ctx, inst, vc_head, Program, Index))
2406 return 1;
2407
2408 /* This should be 0x8 */
2409 (*inst)++;
2410
2411 /* Writemask of .x is implied */
2412 WriteMask[0] = 1;
2413 WriteMask[1] = WriteMask[2] = WriteMask[3] = 0;
2414
2415 return 0;
2416 }
2417 #endif
2418
2419 /**
2420 * Parse out a swizzle mask.
2421 *
2422 * Basically convert COMPONENT_X/Y/Z/W to SWIZZLE_X/Y/Z/W
2423 *
2424 * The len parameter allows us to grab 4 components for a vector
2425 * swizzle, or just 1 component for a scalar src register selection
2426 */
2427 static void
2428 parse_swizzle_mask(const GLubyte ** inst, GLubyte *swizzle, GLint len)
2429 {
2430 GLint i;
2431
2432 for (i = 0; i < 4; i++)
2433 swizzle[i] = i;
2434
2435 for (i = 0; i < len; i++) {
2436 switch (*(*inst)++) {
2437 case COMPONENT_X:
2438 swizzle[i] = SWIZZLE_X;
2439 break;
2440 case COMPONENT_Y:
2441 swizzle[i] = SWIZZLE_Y;
2442 break;
2443 case COMPONENT_Z:
2444 swizzle[i] = SWIZZLE_Z;
2445 break;
2446 case COMPONENT_W:
2447 swizzle[i] = SWIZZLE_W;
2448 break;
2449 default:
2450 _mesa_problem(NULL, "bad component in parse_swizzle_mask()");
2451 return;
2452 }
2453 }
2454
2455 if (len == 1)
2456 swizzle[1] = swizzle[2] = swizzle[3] = swizzle[0];
2457 }
2458
2459
2460 /**
2461 * Parse an extended swizzle mask which is a sequence of
2462 * four x/y/z/w/0/1 tokens.
2463 * \return swizzle four swizzle values
2464 * \return negateMask four element bitfield
2465 */
2466 static void
2467 parse_extended_swizzle_mask(const GLubyte **inst, GLubyte swizzle[4],
2468 GLubyte *negateMask)
2469 {
2470 GLint i;
2471
2472 *negateMask = 0x0;
2473 for (i = 0; i < 4; i++) {
2474 GLubyte swz;
2475 if (parse_sign(inst) == -1)
2476 *negateMask |= (1 << i);
2477
2478 swz = *(*inst)++;
2479
2480 switch (swz) {
2481 case COMPONENT_0:
2482 swizzle[i] = SWIZZLE_ZERO;
2483 break;
2484 case COMPONENT_1:
2485 swizzle[i] = SWIZZLE_ONE;
2486 break;
2487 case COMPONENT_X:
2488 swizzle[i] = SWIZZLE_X;
2489 break;
2490 case COMPONENT_Y:
2491 swizzle[i] = SWIZZLE_Y;
2492 break;
2493 case COMPONENT_Z:
2494 swizzle[i] = SWIZZLE_Z;
2495 break;
2496 case COMPONENT_W:
2497 swizzle[i] = SWIZZLE_W;
2498 break;
2499 default:
2500 _mesa_problem(NULL, "bad case in parse_extended_swizzle_mask()");
2501 return;
2502 }
2503 }
2504 }
2505
2506
2507 static GLuint
2508 parse_src_reg (GLcontext * ctx, const GLubyte ** inst,
2509 struct var_cache **vc_head,
2510 struct arb_program *Program,
2511 gl_register_file * File, GLint * Index, GLuint *swizzle,
2512 GLboolean *IsRelOffset )
2513 {
2514 struct var_cache *src;
2515 GLuint binding, is_generic, found;
2516 GLint offset;
2517
2518 *IsRelOffset = 0;
2519
2520 *swizzle = SWIZZLE_XYZW; /* default */
2521
2522 /* And the binding for the src */
2523 switch (*(*inst)++) {
2524 case REGISTER_ATTRIB:
2525 if (parse_attrib_binding
2526 (ctx, inst, Program, &binding, &is_generic))
2527 return 1;
2528 *File = PROGRAM_INPUT;
2529 *Index = binding;
2530
2531 /* We need to insert a dummy variable into the var_cache so we can
2532 * catch generic vertex attrib aliasing errors
2533 */
2534 var_cache_create(&src);
2535 src->type = vt_attrib;
2536 src->name = (const GLubyte *) "Dummy Attrib Variable";
2537 src->attrib_binding = binding;
2538 src->attrib_is_generic = is_generic;
2539 var_cache_append(vc_head, src);
2540 if (generic_attrib_check(*vc_head)) {
2541 program_error(ctx, Program->Position,
2542 "Cannot use both a generic vertex attribute "
2543 "and a specific attribute of the same type");
2544 return 1;
2545 }
2546 break;
2547
2548 case REGISTER_PARAM:
2549 switch (**inst) {
2550 case PARAM_ARRAY_ELEMENT:
2551 (*inst)++;
2552 src = parse_string (inst, vc_head, Program, &found);
2553 Program->Position = parse_position (inst);
2554
2555 if (!found) {
2556 program_error2(ctx, Program->Position,
2557 "Undefined variable",
2558 (char *) src->name);
2559 return 1;
2560 }
2561
2562 *File = (gl_register_file) src->param_binding_type;
2563
2564 switch (*(*inst)++) {
2565 case ARRAY_INDEX_ABSOLUTE:
2566 offset = parse_integer (inst, Program);
2567
2568 if ((offset < 0)
2569 || (offset >= (int)src->param_binding_length)) {
2570 program_error(ctx, Program->Position,
2571 "Index out of range");
2572 /* offset, src->name */
2573 return 1;
2574 }
2575
2576 *Index = src->param_binding_begin + offset;
2577 *swizzle = src->swizzle;
2578 break;
2579
2580 case ARRAY_INDEX_RELATIVE:
2581 {
2582 GLint addr_reg_idx, rel_off;
2583
2584 /* First, grab the address regiseter */
2585 if (parse_address_reg (ctx, inst, vc_head, Program, &addr_reg_idx))
2586 return 1;
2587
2588 /* And the .x */
2589 ((*inst)++);
2590 ((*inst)++);
2591 ((*inst)++);
2592 ((*inst)++);
2593
2594 /* Then the relative offset */
2595 if (parse_relative_offset(ctx, inst, Program, &rel_off)) return 1;
2596
2597 /* And store it properly */
2598 *Index = src->param_binding_begin + rel_off;
2599 *IsRelOffset = 1;
2600 *swizzle = src->swizzle;
2601 }
2602 break;
2603 }
2604 break;
2605
2606 default:
2607 if (parse_param_use (ctx, inst, vc_head, Program, &src))
2608 return 1;
2609
2610 *File = (gl_register_file) src->param_binding_type;
2611 *Index = src->param_binding_begin;
2612 *swizzle = src->swizzle;
2613 break;
2614 }
2615 break;
2616
2617 case REGISTER_ESTABLISHED_NAME:
2618 src = parse_string (inst, vc_head, Program, &found);
2619 Program->Position = parse_position (inst);
2620
2621 /* If the name has never been added to our symbol table, we're hosed */
2622 if (!found) {
2623 program_error(ctx, Program->Position,
2624 "3: Undefined variable"); /* src->name */
2625 return 1;
2626 }
2627
2628 switch (src->type) {
2629 case vt_attrib:
2630 *File = PROGRAM_INPUT;
2631 *Index = src->attrib_binding;
2632 break;
2633
2634 /* XXX: We have to handle offsets someplace in here! -- or are those above? */
2635 case vt_param:
2636 *File = (gl_register_file) src->param_binding_type;
2637 *Index = src->param_binding_begin;
2638 break;
2639
2640 case vt_temp:
2641 *File = PROGRAM_TEMPORARY;
2642 *Index = src->temp_binding;
2643 break;
2644
2645 /* If the var type is vt_output no go */
2646 default:
2647 program_error(ctx, Program->Position,
2648 "destination register is read only");
2649 /* bad src->name */
2650 return 1;
2651 }
2652 break;
2653
2654 default:
2655 program_error(ctx, Program->Position,
2656 "Unknown token in parse_src_reg");
2657 return 1;
2658 }
2659
2660 if (*File == PROGRAM_STATE_VAR) {
2661 gl_register_file file;
2662
2663 /* If we're referencing the Program->Parameters[] array, check if the
2664 * parameter is really a constant/literal. If so, set File to CONSTANT.
2665 */
2666 assert(*Index < (GLint) Program->Base.Parameters->NumParameters);
2667 file = Program->Base.Parameters->Parameters[*Index].Type;
2668 if (file == PROGRAM_CONSTANT)
2669 *File = PROGRAM_CONSTANT;
2670 }
2671
2672 /* Add attributes to InputsRead only if they are used the program.
2673 * This avoids the handling of unused ATTRIB declarations in the drivers. */
2674 if (*File == PROGRAM_INPUT)
2675 Program->Base.InputsRead |= (1 << *Index);
2676
2677 return 0;
2678 }
2679
2680
2681 static GLuint
2682 swizzle_swizzle(GLuint baseSwizzle, const GLubyte swizzle[4])
2683 {
2684 GLuint i, swz, s[4];
2685 for (i = 0; i < 4; i++) {
2686 GLuint c = swizzle[i];
2687 if (c <= SWIZZLE_W)
2688 s[i] = GET_SWZ(baseSwizzle, c);
2689 else
2690 s[i] = c;
2691 }
2692 swz = MAKE_SWIZZLE4(s[0], s[1], s[2], s[3]);
2693 return swz;
2694 }
2695
2696 /**
2697 * Parse vertex/fragment program vector source register.
2698 */
2699 static GLuint
2700 parse_vector_src_reg(GLcontext *ctx, const GLubyte **inst,
2701 struct var_cache **vc_head,
2702 struct arb_program *program,
2703 struct prog_src_register *reg)
2704 {
2705 gl_register_file file;
2706 GLint index;
2707 GLubyte negateMask;
2708 GLubyte swizzle[4];
2709 GLboolean isRelOffset;
2710 GLuint baseSwizzle;
2711
2712 /* Grab the sign */
2713 negateMask = (parse_sign (inst) == -1) ? NEGATE_XYZW : NEGATE_NONE;
2714
2715 /* And the src reg */
2716 if (parse_src_reg(ctx, inst, vc_head, program, &file, &index, &baseSwizzle,
2717 &isRelOffset))
2718 return 1;
2719
2720 /* finally, the swizzle */
2721 parse_swizzle_mask(inst, swizzle, 4);
2722
2723 reg->File = file;
2724 reg->Index = index;
2725 reg->Swizzle = swizzle_swizzle(baseSwizzle, swizzle);
2726 reg->Negate = negateMask;
2727 reg->RelAddr = isRelOffset;
2728 return 0;
2729 }
2730
2731
2732 /**
2733 * Parse vertex/fragment program scalar source register.
2734 */
2735 static GLuint
2736 parse_scalar_src_reg(GLcontext *ctx, const GLubyte **inst,
2737 struct var_cache **vc_head,
2738 struct arb_program *program,
2739 struct prog_src_register *reg)
2740 {
2741 gl_register_file file;
2742 GLint index;
2743 GLubyte negateMask;
2744 GLubyte swizzle[4];
2745 GLboolean isRelOffset;
2746 GLuint baseSwizzle;
2747
2748 /* Grab the sign */
2749 negateMask = (parse_sign (inst) == -1) ? NEGATE_XYZW : NEGATE_NONE;
2750
2751 /* And the src reg */
2752 if (parse_src_reg(ctx, inst, vc_head, program, &file, &index, &baseSwizzle,
2753 &isRelOffset))
2754 return 1;
2755
2756 /* finally, the swizzle */
2757 parse_swizzle_mask(inst, swizzle, 1);
2758
2759 reg->File = file;
2760 reg->Index = index;
2761 reg->Swizzle = swizzle_swizzle(baseSwizzle, swizzle);
2762 reg->Negate = negateMask;
2763 reg->RelAddr = isRelOffset;
2764 return 0;
2765 }
2766
2767
2768 /**
2769 * Parse vertex/fragment program destination register.
2770 * \return 1 if error, 0 if no error.
2771 */
2772 static GLuint
2773 parse_dst_reg(GLcontext * ctx, const GLubyte ** inst,
2774 struct var_cache **vc_head, struct arb_program *program,
2775 struct prog_dst_register *reg )
2776 {
2777 GLint mask;
2778 GLuint idx;
2779 gl_register_file file;
2780
2781 if (parse_masked_dst_reg (ctx, inst, vc_head, program, &file, &idx, &mask))
2782 return 1;
2783
2784 reg->File = file;
2785 reg->Index = idx;
2786 reg->WriteMask = mask;
2787 return 0;
2788 }
2789
2790
2791 /**
2792 * This is a big mother that handles getting opcodes into the instruction
2793 * and handling the src & dst registers for fragment program instructions
2794 * \return 1 if error, 0 if no error
2795 */
2796 static GLuint
2797 parse_fp_instruction (GLcontext * ctx, const GLubyte ** inst,
2798 struct var_cache **vc_head, struct arb_program *Program,
2799 struct prog_instruction *fp)
2800 {
2801 GLint a;
2802 GLuint texcoord;
2803 GLubyte instClass, type, code;
2804 GLboolean rel;
2805 GLuint shadow_tex = 0;
2806
2807 _mesa_init_instructions(fp, 1);
2808
2809 /* OP_ALU_INST or OP_TEX_INST */
2810 instClass = *(*inst)++;
2811
2812 /* OP_ALU_{VECTOR, SCALAR, BINSC, BIN, TRI, SWZ},
2813 * OP_TEX_{SAMPLE, KIL}
2814 */
2815 type = *(*inst)++;
2816
2817 /* The actual opcode name */
2818 code = *(*inst)++;
2819
2820 /* Increment the correct count */
2821 switch (instClass) {
2822 case OP_ALU_INST:
2823 Program->NumAluInstructions++;
2824 break;
2825 case OP_TEX_INST:
2826 Program->NumTexInstructions++;
2827 break;
2828 }
2829
2830 switch (type) {
2831 case OP_ALU_VECTOR:
2832 switch (code) {
2833 case OP_ABS_SAT:
2834 fp->SaturateMode = SATURATE_ZERO_ONE;
2835 case OP_ABS:
2836 fp->Opcode = OPCODE_ABS;
2837 break;
2838
2839 case OP_FLR_SAT:
2840 fp->SaturateMode = SATURATE_ZERO_ONE;
2841 case OP_FLR:
2842 fp->Opcode = OPCODE_FLR;
2843 break;
2844
2845 case OP_FRC_SAT:
2846 fp->SaturateMode = SATURATE_ZERO_ONE;
2847 case OP_FRC:
2848 fp->Opcode = OPCODE_FRC;
2849 break;
2850
2851 case OP_LIT_SAT:
2852 fp->SaturateMode = SATURATE_ZERO_ONE;
2853 case OP_LIT:
2854 fp->Opcode = OPCODE_LIT;
2855 break;
2856
2857 case OP_MOV_SAT:
2858 fp->SaturateMode = SATURATE_ZERO_ONE;
2859 case OP_MOV:
2860 fp->Opcode = OPCODE_MOV;
2861 break;
2862 }
2863
2864 if (parse_dst_reg (ctx, inst, vc_head, Program, &fp->DstReg))
2865 return 1;
2866
2867 if (parse_vector_src_reg(ctx, inst, vc_head, Program, &fp->SrcReg[0]))
2868 return 1;
2869 break;
2870
2871 case OP_ALU_SCALAR:
2872 switch (code) {
2873 case OP_COS_SAT:
2874 fp->SaturateMode = SATURATE_ZERO_ONE;
2875 case OP_COS:
2876 fp->Opcode = OPCODE_COS;
2877 break;
2878
2879 case OP_EX2_SAT:
2880 fp->SaturateMode = SATURATE_ZERO_ONE;
2881 case OP_EX2:
2882 fp->Opcode = OPCODE_EX2;
2883 break;
2884
2885 case OP_LG2_SAT:
2886 fp->SaturateMode = SATURATE_ZERO_ONE;
2887 case OP_LG2:
2888 fp->Opcode = OPCODE_LG2;
2889 break;
2890
2891 case OP_RCP_SAT:
2892 fp->SaturateMode = SATURATE_ZERO_ONE;
2893 case OP_RCP:
2894 fp->Opcode = OPCODE_RCP;
2895 break;
2896
2897 case OP_RSQ_SAT:
2898 fp->SaturateMode = SATURATE_ZERO_ONE;
2899 case OP_RSQ:
2900 fp->Opcode = OPCODE_RSQ;
2901 break;
2902
2903 case OP_SIN_SAT:
2904 fp->SaturateMode = SATURATE_ZERO_ONE;
2905 case OP_SIN:
2906 fp->Opcode = OPCODE_SIN;
2907 break;
2908
2909 case OP_SCS_SAT:
2910 fp->SaturateMode = SATURATE_ZERO_ONE;
2911 case OP_SCS:
2912
2913 fp->Opcode = OPCODE_SCS;
2914 break;
2915 }
2916
2917 if (parse_dst_reg (ctx, inst, vc_head, Program, &fp->DstReg))
2918 return 1;
2919
2920 if (parse_scalar_src_reg(ctx, inst, vc_head, Program, &fp->SrcReg[0]))
2921 return 1;
2922 break;
2923
2924 case OP_ALU_BINSC:
2925 switch (code) {
2926 case OP_POW_SAT:
2927 fp->SaturateMode = SATURATE_ZERO_ONE;
2928 case OP_POW:
2929 fp->Opcode = OPCODE_POW;
2930 break;
2931 }
2932
2933 if (parse_dst_reg(ctx, inst, vc_head, Program, &fp->DstReg))
2934 return 1;
2935
2936 for (a = 0; a < 2; a++) {
2937 if (parse_scalar_src_reg(ctx, inst, vc_head, Program, &fp->SrcReg[a]))
2938 return 1;
2939 }
2940 break;
2941
2942
2943 case OP_ALU_BIN:
2944 switch (code) {
2945 case OP_ADD_SAT:
2946 fp->SaturateMode = SATURATE_ZERO_ONE;
2947 case OP_ADD:
2948 fp->Opcode = OPCODE_ADD;
2949 break;
2950
2951 case OP_DP3_SAT:
2952 fp->SaturateMode = SATURATE_ZERO_ONE;
2953 case OP_DP3:
2954 fp->Opcode = OPCODE_DP3;
2955 break;
2956
2957 case OP_DP4_SAT:
2958 fp->SaturateMode = SATURATE_ZERO_ONE;
2959 case OP_DP4:
2960 fp->Opcode = OPCODE_DP4;
2961 break;
2962
2963 case OP_DPH_SAT:
2964 fp->SaturateMode = SATURATE_ZERO_ONE;
2965 case OP_DPH:
2966 fp->Opcode = OPCODE_DPH;
2967 break;
2968
2969 case OP_DST_SAT:
2970 fp->SaturateMode = SATURATE_ZERO_ONE;
2971 case OP_DST:
2972 fp->Opcode = OPCODE_DST;
2973 break;
2974
2975 case OP_MAX_SAT:
2976 fp->SaturateMode = SATURATE_ZERO_ONE;
2977 case OP_MAX:
2978 fp->Opcode = OPCODE_MAX;
2979 break;
2980
2981 case OP_MIN_SAT:
2982 fp->SaturateMode = SATURATE_ZERO_ONE;
2983 case OP_MIN:
2984 fp->Opcode = OPCODE_MIN;
2985 break;
2986
2987 case OP_MUL_SAT:
2988 fp->SaturateMode = SATURATE_ZERO_ONE;
2989 case OP_MUL:
2990 fp->Opcode = OPCODE_MUL;
2991 break;
2992
2993 case OP_SGE_SAT:
2994 fp->SaturateMode = SATURATE_ZERO_ONE;
2995 case OP_SGE:
2996 fp->Opcode = OPCODE_SGE;
2997 break;
2998
2999 case OP_SLT_SAT:
3000 fp->SaturateMode = SATURATE_ZERO_ONE;
3001 case OP_SLT:
3002 fp->Opcode = OPCODE_SLT;
3003 break;
3004
3005 case OP_SUB_SAT:
3006 fp->SaturateMode = SATURATE_ZERO_ONE;
3007 case OP_SUB:
3008 fp->Opcode = OPCODE_SUB;
3009 break;
3010
3011 case OP_XPD_SAT:
3012 fp->SaturateMode = SATURATE_ZERO_ONE;
3013 case OP_XPD:
3014 fp->Opcode = OPCODE_XPD;
3015 break;
3016 }
3017
3018 if (parse_dst_reg (ctx, inst, vc_head, Program, &fp->DstReg))
3019 return 1;
3020 for (a = 0; a < 2; a++) {
3021 if (parse_vector_src_reg(ctx, inst, vc_head, Program, &fp->SrcReg[a]))
3022 return 1;
3023 }
3024 break;
3025
3026 case OP_ALU_TRI:
3027 switch (code) {
3028 case OP_CMP_SAT:
3029 fp->SaturateMode = SATURATE_ZERO_ONE;
3030 case OP_CMP:
3031 fp->Opcode = OPCODE_CMP;
3032 break;
3033
3034 case OP_LRP_SAT:
3035 fp->SaturateMode = SATURATE_ZERO_ONE;
3036 case OP_LRP:
3037 fp->Opcode = OPCODE_LRP;
3038 break;
3039
3040 case OP_MAD_SAT:
3041 fp->SaturateMode = SATURATE_ZERO_ONE;
3042 case OP_MAD:
3043 fp->Opcode = OPCODE_MAD;
3044 break;
3045 }
3046
3047 if (parse_dst_reg (ctx, inst, vc_head, Program, &fp->DstReg))
3048 return 1;
3049
3050 for (a = 0; a < 3; a++) {
3051 if (parse_vector_src_reg(ctx, inst, vc_head, Program, &fp->SrcReg[a]))
3052 return 1;
3053 }
3054 break;
3055
3056 case OP_ALU_SWZ:
3057 switch (code) {
3058 case OP_SWZ_SAT:
3059 fp->SaturateMode = SATURATE_ZERO_ONE;
3060 case OP_SWZ:
3061 fp->Opcode = OPCODE_SWZ;
3062 break;
3063 }
3064 if (parse_dst_reg (ctx, inst, vc_head, Program, &fp->DstReg))
3065 return 1;
3066
3067 {
3068 GLubyte swizzle[4];
3069 GLubyte negateMask;
3070 gl_register_file file;
3071 GLint index;
3072 GLuint baseSwizzle;
3073
3074 if (parse_src_reg(ctx, inst, vc_head, Program, &file, &index,
3075 &baseSwizzle, &rel))
3076 return 1;
3077 parse_extended_swizzle_mask(inst, swizzle, &negateMask);
3078 fp->SrcReg[0].File = file;
3079 fp->SrcReg[0].Index = index;
3080 fp->SrcReg[0].Negate = negateMask;
3081 fp->SrcReg[0].Swizzle = MAKE_SWIZZLE4(swizzle[0],
3082 swizzle[1],
3083 swizzle[2],
3084 swizzle[3]);
3085 }
3086 break;
3087
3088 case OP_TEX_SAMPLE:
3089 switch (code) {
3090 case OP_TEX_SAT:
3091 fp->SaturateMode = SATURATE_ZERO_ONE;
3092 case OP_TEX:
3093 fp->Opcode = OPCODE_TEX;
3094 break;
3095
3096 case OP_TXP_SAT:
3097 fp->SaturateMode = SATURATE_ZERO_ONE;
3098 case OP_TXP:
3099 fp->Opcode = OPCODE_TXP;
3100 break;
3101
3102 case OP_TXB_SAT:
3103 fp->SaturateMode = SATURATE_ZERO_ONE;
3104 case OP_TXB:
3105 fp->Opcode = OPCODE_TXB;
3106 break;
3107 }
3108
3109 if (parse_dst_reg (ctx, inst, vc_head, Program, &fp->DstReg))
3110 return 1;
3111
3112 if (parse_vector_src_reg(ctx, inst, vc_head, Program, &fp->SrcReg[0]))
3113 return 1;
3114
3115 /* texImageUnit */
3116 if (parse_teximage_num (ctx, inst, Program, &texcoord))
3117 return 1;
3118 fp->TexSrcUnit = texcoord;
3119
3120 /* texTarget */
3121 switch (*(*inst)++) {
3122 case TEXTARGET_SHADOW1D:
3123 shadow_tex = 1 << texcoord;
3124 /* FALLTHROUGH */
3125 case TEXTARGET_1D:
3126 fp->TexSrcTarget = TEXTURE_1D_INDEX;
3127 break;
3128 case TEXTARGET_SHADOW2D:
3129 shadow_tex = 1 << texcoord;
3130 /* FALLTHROUGH */
3131 case TEXTARGET_2D:
3132 fp->TexSrcTarget = TEXTURE_2D_INDEX;
3133 break;
3134 case TEXTARGET_3D:
3135 fp->TexSrcTarget = TEXTURE_3D_INDEX;
3136 break;
3137 case TEXTARGET_SHADOWRECT:
3138 shadow_tex = 1 << texcoord;
3139 /* FALLTHROUGH */
3140 case TEXTARGET_RECT:
3141 fp->TexSrcTarget = TEXTURE_RECT_INDEX;
3142 break;
3143 case TEXTARGET_CUBE:
3144 fp->TexSrcTarget = TEXTURE_CUBE_INDEX;
3145 break;
3146 case TEXTARGET_SHADOW1D_ARRAY:
3147 shadow_tex = 1 << texcoord;
3148 /* FALLTHROUGH */
3149 case TEXTARGET_1D_ARRAY:
3150 fp->TexSrcTarget = TEXTURE_1D_ARRAY_INDEX;
3151 break;
3152 case TEXTARGET_SHADOW2D_ARRAY:
3153 shadow_tex = 1 << texcoord;
3154 /* FALLTHROUGH */
3155 case TEXTARGET_2D_ARRAY:
3156 fp->TexSrcTarget = TEXTURE_2D_ARRAY_INDEX;
3157 break;
3158 }
3159
3160 if (shadow_tex)
3161 fp->TexShadow = 1;
3162
3163 /* Don't test the first time a particular sampler is seen. Each time
3164 * after that, make sure the shadow state is the same.
3165 */
3166 if ((_mesa_bitcount(Program->TexturesUsed[texcoord]) > 0)
3167 && ((Program->ShadowSamplers & (1 << texcoord)) != shadow_tex)) {
3168 program_error(ctx, Program->Position,
3169 "texture image unit used for shadow sampling and non-shadow sampling");
3170 return 1;
3171 }
3172
3173 Program->TexturesUsed[texcoord] |= (1 << fp->TexSrcTarget);
3174 /* Check that both "2D" and "CUBE" (for example) aren't both used */
3175 if (_mesa_bitcount(Program->TexturesUsed[texcoord]) > 1) {
3176 program_error(ctx, Program->Position,
3177 "multiple targets used on one texture image unit");
3178 return 1;
3179 }
3180
3181
3182 Program->ShadowSamplers |= shadow_tex;
3183 break;
3184
3185 case OP_TEX_KIL:
3186 Program->UsesKill = 1;
3187 if (parse_vector_src_reg(ctx, inst, vc_head, Program, &fp->SrcReg[0]))
3188 return 1;
3189 fp->Opcode = OPCODE_KIL;
3190 break;
3191 default:
3192 _mesa_problem(ctx, "bad type 0x%x in parse_fp_instruction()", type);
3193 return 1;
3194 }
3195
3196 return 0;
3197 }
3198
3199
3200 /**
3201 * Handle the parsing out of a masked address register
3202 *
3203 * \param Index - The register index we write to
3204 * \param WriteMask - The mask controlling which components we write (1->write)
3205 *
3206 * \return 0 on sucess, 1 on error
3207 */
3208 static GLuint
3209 parse_vp_address_reg (GLcontext * ctx, const GLubyte ** inst,
3210 struct var_cache **vc_head,
3211 struct arb_program *Program,
3212 struct prog_dst_register *reg)
3213 {
3214 GLint idx;
3215
3216 if (parse_address_reg (ctx, inst, vc_head, Program, &idx))
3217 return 1;
3218
3219 /* This should be 0x8 */
3220 (*inst)++;
3221
3222 reg->File = PROGRAM_ADDRESS;
3223 reg->Index = idx;
3224
3225 /* Writemask of .x is implied */
3226 reg->WriteMask = 0x1;
3227 return 0;
3228 }
3229
3230
3231 /**
3232 * This is a big mother that handles getting opcodes into the instruction
3233 * and handling the src & dst registers for vertex program instructions
3234 */
3235 static GLuint
3236 parse_vp_instruction (GLcontext * ctx, const GLubyte ** inst,
3237 struct var_cache **vc_head, struct arb_program *Program,
3238 struct prog_instruction *vp)
3239 {
3240 GLint a;
3241 GLubyte type, code;
3242
3243 /* OP_ALU_{ARL, VECTOR, SCALAR, BINSC, BIN, TRI, SWZ} */
3244 type = *(*inst)++;
3245
3246 /* The actual opcode name */
3247 code = *(*inst)++;
3248
3249 _mesa_init_instructions(vp, 1);
3250
3251 switch (type) {
3252 /* XXX: */
3253 case OP_ALU_ARL:
3254 vp->Opcode = OPCODE_ARL;
3255
3256 /* Remember to set SrcReg.RelAddr; */
3257
3258 /* Get the masked address register [dst] */
3259 if (parse_vp_address_reg(ctx, inst, vc_head, Program, &vp->DstReg))
3260 return 1;
3261
3262 vp->DstReg.File = PROGRAM_ADDRESS;
3263
3264 /* Get a scalar src register */
3265 if (parse_scalar_src_reg(ctx, inst, vc_head, Program, &vp->SrcReg[0]))
3266 return 1;
3267
3268 break;
3269
3270 case OP_ALU_VECTOR:
3271 switch (code) {
3272 case OP_ABS:
3273 vp->Opcode = OPCODE_ABS;
3274 break;
3275 case OP_FLR:
3276 vp->Opcode = OPCODE_FLR;
3277 break;
3278 case OP_FRC:
3279 vp->Opcode = OPCODE_FRC;
3280 break;
3281 case OP_LIT:
3282 vp->Opcode = OPCODE_LIT;
3283 break;
3284 case OP_MOV:
3285 vp->Opcode = OPCODE_MOV;
3286 break;
3287 }
3288
3289 if (parse_dst_reg(ctx, inst, vc_head, Program, &vp->DstReg))
3290 return 1;
3291
3292 if (parse_vector_src_reg(ctx, inst, vc_head, Program, &vp->SrcReg[0]))
3293 return 1;
3294 break;
3295
3296 case OP_ALU_SCALAR:
3297 switch (code) {
3298 case OP_EX2:
3299 vp->Opcode = OPCODE_EX2;
3300 break;
3301 case OP_EXP:
3302 vp->Opcode = OPCODE_EXP;
3303 break;
3304 case OP_LG2:
3305 vp->Opcode = OPCODE_LG2;
3306 break;
3307 case OP_LOG:
3308 vp->Opcode = OPCODE_LOG;
3309 break;
3310 case OP_RCP:
3311 vp->Opcode = OPCODE_RCP;
3312 break;
3313 case OP_RSQ:
3314 vp->Opcode = OPCODE_RSQ;
3315 break;
3316 }
3317 if (parse_dst_reg(ctx, inst, vc_head, Program, &vp->DstReg))
3318 return 1;
3319
3320 if (parse_scalar_src_reg(ctx, inst, vc_head, Program, &vp->SrcReg[0]))
3321 return 1;
3322 break;
3323
3324 case OP_ALU_BINSC:
3325 switch (code) {
3326 case OP_POW:
3327 vp->Opcode = OPCODE_POW;
3328 break;
3329 }
3330 if (parse_dst_reg(ctx, inst, vc_head, Program, &vp->DstReg))
3331 return 1;
3332
3333 for (a = 0; a < 2; a++) {
3334 if (parse_scalar_src_reg(ctx, inst, vc_head, Program, &vp->SrcReg[a]))
3335 return 1;
3336 }
3337 break;
3338
3339 case OP_ALU_BIN:
3340 switch (code) {
3341 case OP_ADD:
3342 vp->Opcode = OPCODE_ADD;
3343 break;
3344 case OP_DP3:
3345 vp->Opcode = OPCODE_DP3;
3346 break;
3347 case OP_DP4:
3348 vp->Opcode = OPCODE_DP4;
3349 break;
3350 case OP_DPH:
3351 vp->Opcode = OPCODE_DPH;
3352 break;
3353 case OP_DST:
3354 vp->Opcode = OPCODE_DST;
3355 break;
3356 case OP_MAX:
3357 vp->Opcode = OPCODE_MAX;
3358 break;
3359 case OP_MIN:
3360 vp->Opcode = OPCODE_MIN;
3361 break;
3362 case OP_MUL:
3363 vp->Opcode = OPCODE_MUL;
3364 break;
3365 case OP_SGE:
3366 vp->Opcode = OPCODE_SGE;
3367 break;
3368 case OP_SLT:
3369 vp->Opcode = OPCODE_SLT;
3370 break;
3371 case OP_SUB:
3372 vp->Opcode = OPCODE_SUB;
3373 break;
3374 case OP_XPD:
3375 vp->Opcode = OPCODE_XPD;
3376 break;
3377 }
3378 if (parse_dst_reg(ctx, inst, vc_head, Program, &vp->DstReg))
3379 return 1;
3380
3381 for (a = 0; a < 2; a++) {
3382 if (parse_vector_src_reg(ctx, inst, vc_head, Program, &vp->SrcReg[a]))
3383 return 1;
3384 }
3385 break;
3386
3387 case OP_ALU_TRI:
3388 switch (code) {
3389 case OP_MAD:
3390 vp->Opcode = OPCODE_MAD;
3391 break;
3392 }
3393
3394 if (parse_dst_reg(ctx, inst, vc_head, Program, &vp->DstReg))
3395 return 1;
3396
3397 for (a = 0; a < 3; a++) {
3398 if (parse_vector_src_reg(ctx, inst, vc_head, Program, &vp->SrcReg[a]))
3399 return 1;
3400 }
3401 break;
3402
3403 case OP_ALU_SWZ:
3404 switch (code) {
3405 case OP_SWZ:
3406 vp->Opcode = OPCODE_SWZ;
3407 break;
3408 }
3409 {
3410 GLubyte swizzle[4];
3411 GLubyte negateMask;
3412 GLboolean relAddr;
3413 gl_register_file file;
3414 GLint index;
3415 GLuint baseSwizzle;
3416
3417 if (parse_dst_reg(ctx, inst, vc_head, Program, &vp->DstReg))
3418 return 1;
3419
3420 if (parse_src_reg(ctx, inst, vc_head, Program, &file, &index,
3421 &baseSwizzle, &relAddr))
3422 return 1;
3423 parse_extended_swizzle_mask (inst, swizzle, &negateMask);
3424 vp->SrcReg[0].File = file;
3425 vp->SrcReg[0].Index = index;
3426 vp->SrcReg[0].Negate = negateMask;
3427 vp->SrcReg[0].Swizzle = MAKE_SWIZZLE4(swizzle[0],
3428 swizzle[1],
3429 swizzle[2],
3430 swizzle[3]);
3431 vp->SrcReg[0].RelAddr = relAddr;
3432 }
3433 break;
3434 }
3435 return 0;
3436 }
3437
3438 #if DEBUG_PARSING
3439
3440 static GLvoid
3441 debug_variables (GLcontext * ctx, struct var_cache *vc_head,
3442 struct arb_program *Program)
3443 {
3444 struct var_cache *vc;
3445 GLint a, b;
3446
3447 fprintf (stderr, "debug_variables, vc_head: %p\n", (void*) vc_head);
3448
3449 /* First of all, print out the contents of the var_cache */
3450 vc = vc_head;
3451 while (vc) {
3452 fprintf (stderr, "[%p]\n", (void*) vc);
3453 switch (vc->type) {
3454 case vt_none:
3455 fprintf (stderr, "UNDEFINED %s\n", vc->name);
3456 break;
3457 case vt_attrib:
3458 fprintf (stderr, "ATTRIB %s\n", vc->name);
3459 fprintf (stderr, " binding: 0x%x\n", vc->attrib_binding);
3460 break;
3461 case vt_param:
3462 fprintf (stderr, "PARAM %s begin: %d len: %d\n", vc->name,
3463 vc->param_binding_begin, vc->param_binding_length);
3464 b = vc->param_binding_begin;
3465 for (a = 0; a < vc->param_binding_length; a++) {
3466 fprintf (stderr, "%s\n",
3467 Program->Base.Parameters->Parameters[a + b].Name);
3468 if (Program->Base.Parameters->Parameters[a + b].Type == PROGRAM_STATE_VAR) {
3469 char *s;
3470 s = _mesa_program_state_string(Program->Base.Parameters->Parameters
3471 [a + b].StateIndexes);
3472 fprintf(stderr, "%s\n", s);
3473 _mesa_free(s);
3474 }
3475 else
3476 fprintf (stderr, "%f %f %f %f\n",
3477 Program->Base.Parameters->ParameterValues[a + b][0],
3478 Program->Base.Parameters->ParameterValues[a + b][1],
3479 Program->Base.Parameters->ParameterValues[a + b][2],
3480 Program->Base.Parameters->ParameterValues[a + b][3]);
3481 }
3482 break;
3483 case vt_temp:
3484 fprintf (stderr, "TEMP %s\n", vc->name);
3485 fprintf (stderr, " binding: 0x%x\n", vc->temp_binding);
3486 break;
3487 case vt_output:
3488 fprintf (stderr, "OUTPUT %s\n", vc->name);
3489 fprintf (stderr, " binding: 0x%x\n", vc->output_binding);
3490 break;
3491 case vt_alias:
3492 fprintf (stderr, "ALIAS %s\n", vc->name);
3493 fprintf (stderr, " binding: 0x%p (%s)\n",
3494 (void*) vc->alias_binding, vc->alias_binding->name);
3495 break;
3496 default:
3497 /* nothing */
3498 ;
3499 }
3500 vc = vc->next;
3501 }
3502 }
3503
3504 #endif /* DEBUG_PARSING */
3505
3506
3507 /**
3508 * The main loop for parsing a fragment or vertex program
3509 *
3510 * \return 1 on error, 0 on success
3511 */
3512 static GLint
3513 parse_instructions(GLcontext * ctx, const GLubyte * inst,
3514 struct var_cache **vc_head, struct arb_program *Program)
3515 {
3516 const GLuint maxInst = (Program->Base.Target == GL_FRAGMENT_PROGRAM_ARB)
3517 ? ctx->Const.FragmentProgram.MaxInstructions
3518 : ctx->Const.VertexProgram.MaxInstructions;
3519 GLint err = 0;
3520
3521 ASSERT(MAX_PROGRAM_INSTRUCTIONS >= maxInst);
3522
3523 Program->MajorVersion = (GLuint) * inst++;
3524 Program->MinorVersion = (GLuint) * inst++;
3525
3526 while (*inst != END) {
3527 switch (*inst++) {
3528
3529 case OPTION:
3530 switch (*inst++) {
3531 case ARB_PRECISION_HINT_FASTEST:
3532 Program->PrecisionOption = GL_FASTEST;
3533 break;
3534
3535 case ARB_PRECISION_HINT_NICEST:
3536 Program->PrecisionOption = GL_NICEST;
3537 break;
3538
3539 case ARB_FOG_EXP:
3540 Program->FogOption = GL_EXP;
3541 break;
3542
3543 case ARB_FOG_EXP2:
3544 Program->FogOption = GL_EXP2;
3545 break;
3546
3547 case ARB_FOG_LINEAR:
3548 Program->FogOption = GL_LINEAR;
3549 break;
3550
3551 case ARB_POSITION_INVARIANT:
3552 if (Program->Base.Target == GL_VERTEX_PROGRAM_ARB)
3553 Program->HintPositionInvariant = GL_TRUE;
3554 break;
3555
3556 case ARB_FRAGMENT_PROGRAM_SHADOW:
3557 if (Program->Base.Target == GL_FRAGMENT_PROGRAM_ARB) {
3558 /* TODO ARB_fragment_program_shadow code */
3559 }
3560 break;
3561
3562 case ARB_DRAW_BUFFERS:
3563 if (Program->Base.Target == GL_FRAGMENT_PROGRAM_ARB) {
3564 /* do nothing for now */
3565 }
3566 break;
3567
3568 case MESA_TEXTURE_ARRAY:
3569 /* do nothing for now */
3570 break;
3571 }
3572 break;
3573
3574 case INSTRUCTION:
3575 /* check length */
3576 if (Program->Base.NumInstructions + 1 >= maxInst) {
3577 program_error(ctx, Program->Position,
3578 "Max instruction count exceeded");
3579 return 1;
3580 }
3581 Program->Position = parse_position (&inst);
3582 /* parse the current instruction */
3583 if (Program->Base.Target == GL_FRAGMENT_PROGRAM_ARB) {
3584 err = parse_fp_instruction (ctx, &inst, vc_head, Program,
3585 &Program->Base.Instructions[Program->Base.NumInstructions]);
3586 }
3587 else {
3588 err = parse_vp_instruction (ctx, &inst, vc_head, Program,
3589 &Program->Base.Instructions[Program->Base.NumInstructions]);
3590 }
3591
3592 /* increment instuction count */
3593 Program->Base.NumInstructions++;
3594 break;
3595
3596 case DECLARATION:
3597 err = parse_declaration (ctx, &inst, vc_head, Program);
3598 break;
3599
3600 default:
3601 break;
3602 }
3603
3604 if (err)
3605 break;
3606 }
3607
3608 /* Finally, tag on an OPCODE_END instruction */
3609 {
3610 const GLuint numInst = Program->Base.NumInstructions;
3611 _mesa_init_instructions(Program->Base.Instructions + numInst, 1);
3612 Program->Base.Instructions[numInst].Opcode = OPCODE_END;
3613 }
3614 Program->Base.NumInstructions++;
3615
3616 /*
3617 * Initialize native counts to logical counts. The device driver may
3618 * change them if program is translated into a hardware program.
3619 */
3620 Program->Base.NumNativeInstructions = Program->Base.NumInstructions;
3621 Program->Base.NumNativeTemporaries = Program->Base.NumTemporaries;
3622 Program->Base.NumNativeParameters = Program->Base.NumParameters;
3623 Program->Base.NumNativeAttributes = Program->Base.NumAttributes;
3624 Program->Base.NumNativeAddressRegs = Program->Base.NumAddressRegs;
3625
3626 return err;
3627 }
3628
3629
3630 /* XXX temporary */
3631 LONGSTRING static char core_grammar_text[] =
3632 #include "shader/grammar/grammar_syn.h"
3633 ;
3634
3635
3636 /**
3637 * Set a grammar parameter.
3638 * \param name the grammar parameter
3639 * \param value the new parameter value
3640 * \return 0 if OK, 1 if error
3641 */
3642 static int
3643 set_reg8 (GLcontext *ctx, grammar id, const char *name, GLubyte value)
3644 {
3645 char error_msg[300];
3646 GLint error_pos;
3647
3648 if (grammar_set_reg8 (id, (const byte *) name, value))
3649 return 0;
3650
3651 grammar_get_last_error ((byte *) error_msg, 300, &error_pos);
3652 _mesa_set_program_error (ctx, error_pos, error_msg);
3653 _mesa_error (ctx, GL_INVALID_OPERATION, "Grammar Register Error");
3654 return 1;
3655 }
3656
3657
3658 /**
3659 * Enable support for the given language option in the parser.
3660 * \return 1 if OK, 0 if error
3661 */
3662 static int
3663 enable_ext(GLcontext *ctx, grammar id, const char *name)
3664 {
3665 return !set_reg8(ctx, id, name, 1);
3666 }
3667
3668
3669 /**
3670 * Enable parser extensions based on which OpenGL extensions are supported
3671 * by this rendering context.
3672 *
3673 * \return GL_TRUE if OK, GL_FALSE if error.
3674 */
3675 static GLboolean
3676 enable_parser_extensions(GLcontext *ctx, grammar id)
3677 {
3678 #if 0
3679 /* These are not supported at this time */
3680 if ((ctx->Extensions.ARB_vertex_blend ||
3681 ctx->Extensions.EXT_vertex_weighting)
3682 && !enable_ext(ctx, id, "vertex_blend"))
3683 return GL_FALSE;
3684 if (ctx->Extensions.ARB_matrix_palette
3685 && !enable_ext(ctx, id, "matrix_palette"))
3686 return GL_FALSE;
3687 #endif
3688 if (ctx->Extensions.ARB_fragment_program_shadow
3689 && !enable_ext(ctx, id, "fragment_program_shadow"))
3690 return GL_FALSE;
3691 if (ctx->Extensions.EXT_point_parameters
3692 && !enable_ext(ctx, id, "point_parameters"))
3693 return GL_FALSE;
3694 if (ctx->Extensions.EXT_secondary_color
3695 && !enable_ext(ctx, id, "secondary_color"))
3696 return GL_FALSE;
3697 if (ctx->Extensions.EXT_fog_coord
3698 && !enable_ext(ctx, id, "fog_coord"))
3699 return GL_FALSE;
3700 if (ctx->Extensions.NV_texture_rectangle
3701 && !enable_ext(ctx, id, "texture_rectangle"))
3702 return GL_FALSE;
3703 if (!enable_ext(ctx, id, "draw_buffers"))
3704 return GL_FALSE;
3705 if (ctx->Extensions.MESA_texture_array
3706 && !enable_ext(ctx, id, "texture_array"))
3707 return GL_FALSE;
3708 #if 1
3709 /* hack for Warcraft (see bug 8060) */
3710 enable_ext(ctx, id, "vertex_blend");
3711 #endif
3712
3713 return GL_TRUE;
3714 }
3715
3716
3717 /**
3718 * This kicks everything off.
3719 *
3720 * \param ctx - The GL Context
3721 * \param str - The program string
3722 * \param len - The program string length
3723 * \param program - The arb_program struct to return all the parsed info in
3724 * \return GL_TRUE on sucess, GL_FALSE on error
3725 */
3726 static GLboolean
3727 _mesa_parse_arb_program(GLcontext *ctx, GLenum target,
3728 const GLubyte *str, GLsizei len,
3729 struct arb_program *program)
3730 {
3731 GLint a, err, error_pos;
3732 char error_msg[300];
3733 GLuint parsed_len;
3734 struct var_cache *vc_head;
3735 grammar arbprogram_syn_id;
3736 GLubyte *parsed, *inst;
3737 GLubyte *strz = NULL;
3738 static int arbprogram_syn_is_ok = 0; /* XXX temporary */
3739
3740 /* set the program target before parsing */
3741 program->Base.Target = target;
3742
3743 /* Reset error state */
3744 _mesa_set_program_error(ctx, -1, NULL);
3745
3746 /* check if arb_grammar_text (arbprogram.syn) is syntactically correct */
3747 if (!arbprogram_syn_is_ok) {
3748 /* One-time initialization of parsing system */
3749 grammar grammar_syn_id;
3750 GLuint parsed_len;
3751
3752 grammar_syn_id = grammar_load_from_text ((byte *) core_grammar_text);
3753 if (grammar_syn_id == 0) {
3754 grammar_get_last_error ((byte *) error_msg, 300, &error_pos);
3755 /* XXX this is not a GL error - it's an implementation bug! - FIX */
3756 _mesa_set_program_error (ctx, error_pos, error_msg);
3757 _mesa_error (ctx, GL_INVALID_OPERATION,
3758 "glProgramStringARB(Error loading grammar rule set)");
3759 return GL_FALSE;
3760 }
3761
3762 err = !grammar_check(grammar_syn_id, (byte *) arb_grammar_text,
3763 &parsed, &parsed_len);
3764
3765 /* 'parsed' is unused here */
3766 _mesa_free (parsed);
3767 parsed = NULL;
3768
3769 /* NOTE: we can't destroy grammar_syn_id right here because
3770 * grammar_destroy() can reset the last error
3771 */
3772 if (err) {
3773 /* XXX this is not a GL error - it's an implementation bug! - FIX */
3774 grammar_get_last_error ((byte *) error_msg, 300, &error_pos);
3775 _mesa_set_program_error (ctx, error_pos, error_msg);
3776 _mesa_error (ctx, GL_INVALID_OPERATION,
3777 "glProgramString(Error loading grammar rule set");
3778 grammar_destroy (grammar_syn_id);
3779 return GL_FALSE;
3780 }
3781
3782 grammar_destroy (grammar_syn_id);
3783
3784 arbprogram_syn_is_ok = 1;
3785 }
3786
3787 /* create the grammar object */
3788 arbprogram_syn_id = grammar_load_from_text ((byte *) arb_grammar_text);
3789 if (arbprogram_syn_id == 0) {
3790 /* XXX this is not a GL error - it's an implementation bug! - FIX */
3791 grammar_get_last_error ((GLubyte *) error_msg, 300, &error_pos);
3792 _mesa_set_program_error (ctx, error_pos, error_msg);
3793 _mesa_error (ctx, GL_INVALID_OPERATION,
3794 "glProgramString(Error loading grammer rule set)");
3795 return GL_FALSE;
3796 }
3797
3798 /* Set program_target register value */
3799 if (set_reg8 (ctx, arbprogram_syn_id, "program_target",
3800 program->Base.Target == GL_FRAGMENT_PROGRAM_ARB ? 0x10 : 0x20)) {
3801 grammar_destroy (arbprogram_syn_id);
3802 return GL_FALSE;
3803 }
3804
3805 if (!enable_parser_extensions(ctx, arbprogram_syn_id)) {
3806 grammar_destroy(arbprogram_syn_id);
3807 return GL_FALSE;
3808 }
3809
3810 /* check for NULL character occurences */
3811 {
3812 GLint i;
3813 for (i = 0; i < len; i++) {
3814 if (str[i] == '\0') {
3815 program_error(ctx, i, "illegal character");
3816 grammar_destroy (arbprogram_syn_id);
3817 return GL_FALSE;
3818 }
3819 }
3820 }
3821
3822 /* copy the program string to a null-terminated string */
3823 strz = (GLubyte *) _mesa_malloc (len + 1);
3824 if (!strz) {
3825 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glProgramStringARB");
3826 grammar_destroy (arbprogram_syn_id);
3827 return GL_FALSE;
3828 }
3829 _mesa_memcpy (strz, str, len);
3830 strz[len] = '\0';
3831
3832 /* do a fast check on program string - initial production buffer is 4K */
3833 err = !grammar_fast_check(arbprogram_syn_id, strz,
3834 &parsed, &parsed_len, 0x1000);
3835
3836 /* Syntax parse error */
3837 if (err) {
3838 grammar_get_last_error((GLubyte *) error_msg, 300, &error_pos);
3839 program_error(ctx, error_pos, error_msg);
3840
3841 #if DEBUG_PARSING
3842 /* useful for debugging */
3843 do {
3844 int line, col;
3845 char *s;
3846 fprintf(stderr, "program: %s\n", (char *) strz);
3847 fprintf(stderr, "Error Pos: %d\n", ctx->Program.ErrorPos);
3848 s = (char *) _mesa_find_line_column(strz, strz+ctx->Program.ErrorPos,
3849 &line, &col);
3850 fprintf(stderr, "line %d col %d: %s\n", line, col, s);
3851 } while (0);
3852 #endif
3853
3854 _mesa_free(strz);
3855 _mesa_free(parsed);
3856
3857 grammar_destroy (arbprogram_syn_id);
3858 return GL_FALSE;
3859 }
3860
3861 grammar_destroy (arbprogram_syn_id);
3862
3863 /*
3864 * Program string is syntactically correct at this point
3865 * Parse the tokenized version of the program now, generating
3866 * vertex/fragment program instructions.
3867 */
3868
3869 /* Initialize the arb_program struct */
3870 program->Base.String = strz;
3871 program->Base.Instructions = _mesa_alloc_instructions(MAX_PROGRAM_INSTRUCTIONS);
3872 program->Base.NumInstructions =
3873 program->Base.NumTemporaries =
3874 program->Base.NumParameters =
3875 program->Base.NumAttributes = program->Base.NumAddressRegs = 0;
3876 program->Base.Parameters = _mesa_new_parameter_list ();
3877 program->Base.InputsRead = 0x0;
3878 program->Base.OutputsWritten = 0x0;
3879 program->Position = 0;
3880 program->MajorVersion = program->MinorVersion = 0;
3881 program->PrecisionOption = GL_DONT_CARE;
3882 program->FogOption = GL_NONE;
3883 program->HintPositionInvariant = GL_FALSE;
3884 for (a = 0; a < MAX_TEXTURE_IMAGE_UNITS; a++)
3885 program->TexturesUsed[a] = 0x0;
3886 program->ShadowSamplers = 0x0;
3887 program->NumAluInstructions =
3888 program->NumTexInstructions =
3889 program->NumTexIndirections = 0;
3890 program->UsesKill = 0;
3891
3892 vc_head = NULL;
3893 err = GL_FALSE;
3894
3895 /* Start examining the tokens in the array */
3896 inst = parsed;
3897
3898 /* Check the grammer rev */
3899 if (*inst++ != REVISION) {
3900 program_error (ctx, 0, "Grammar version mismatch");
3901 err = GL_TRUE;
3902 }
3903 else {
3904 /* ignore program target */
3905 inst++;
3906 err = parse_instructions(ctx, inst, &vc_head, program);
3907 }
3908
3909 /*debug_variables(ctx, vc_head, program); */
3910
3911 /* We're done with the parsed binary array */
3912 var_cache_destroy (&vc_head);
3913
3914 _mesa_free (parsed);
3915
3916 /* Reallocate the instruction array from size [MAX_PROGRAM_INSTRUCTIONS]
3917 * to size [ap.Base.NumInstructions].
3918 */
3919 program->Base.Instructions
3920 = _mesa_realloc_instructions(program->Base.Instructions,
3921 MAX_PROGRAM_INSTRUCTIONS,
3922 program->Base.NumInstructions);
3923
3924 return !err;
3925 }
3926
3927
3928
3929 void
3930 _mesa_parse_arb_fragment_program(GLcontext* ctx, GLenum target,
3931 const GLvoid *str, GLsizei len,
3932 struct gl_fragment_program *program)
3933 {
3934 struct arb_program ap;
3935 GLuint i;
3936
3937 ASSERT(target == GL_FRAGMENT_PROGRAM_ARB);
3938 if (!_mesa_parse_arb_program(ctx, target, (const GLubyte*) str, len, &ap)) {
3939 /* Error in the program. Just return. */
3940 return;
3941 }
3942
3943 /* Copy the relevant contents of the arb_program struct into the
3944 * fragment_program struct.
3945 */
3946 program->Base.String = ap.Base.String;
3947 program->Base.NumInstructions = ap.Base.NumInstructions;
3948 program->Base.NumTemporaries = ap.Base.NumTemporaries;
3949 program->Base.NumParameters = ap.Base.NumParameters;
3950 program->Base.NumAttributes = ap.Base.NumAttributes;
3951 program->Base.NumAddressRegs = ap.Base.NumAddressRegs;
3952 program->Base.NumNativeInstructions = ap.Base.NumNativeInstructions;
3953 program->Base.NumNativeTemporaries = ap.Base.NumNativeTemporaries;
3954 program->Base.NumNativeParameters = ap.Base.NumNativeParameters;
3955 program->Base.NumNativeAttributes = ap.Base.NumNativeAttributes;
3956 program->Base.NumNativeAddressRegs = ap.Base.NumNativeAddressRegs;
3957 program->Base.NumAluInstructions = ap.Base.NumAluInstructions;
3958 program->Base.NumTexInstructions = ap.Base.NumTexInstructions;
3959 program->Base.NumTexIndirections = ap.Base.NumTexIndirections;
3960 program->Base.NumNativeAluInstructions = ap.Base.NumAluInstructions;
3961 program->Base.NumNativeTexInstructions = ap.Base.NumTexInstructions;
3962 program->Base.NumNativeTexIndirections = ap.Base.NumTexIndirections;
3963 program->Base.InputsRead = ap.Base.InputsRead;
3964 program->Base.OutputsWritten = ap.Base.OutputsWritten;
3965 for (i = 0; i < MAX_TEXTURE_IMAGE_UNITS; i++) {
3966 program->Base.TexturesUsed[i] = ap.TexturesUsed[i];
3967 if (ap.TexturesUsed[i])
3968 program->Base.SamplersUsed |= (1 << i);
3969 }
3970 program->Base.ShadowSamplers = ap.ShadowSamplers;
3971 program->FogOption = ap.FogOption;
3972 program->UsesKill = ap.UsesKill;
3973
3974 if (program->FogOption)
3975 program->Base.InputsRead |= FRAG_BIT_FOGC;
3976
3977 if (program->Base.Instructions)
3978 _mesa_free(program->Base.Instructions);
3979 program->Base.Instructions = ap.Base.Instructions;
3980
3981 if (program->Base.Parameters)
3982 _mesa_free_parameter_list(program->Base.Parameters);
3983 program->Base.Parameters = ap.Base.Parameters;
3984
3985 /* Append fog instructions now if the program has "OPTION ARB_fog_exp"
3986 * or similar. We used to leave this up to drivers, but it appears
3987 * there's no hardware that wants to do fog in a discrete stage separate
3988 * from the fragment shader.
3989 */
3990 if (program->FogOption != GL_NONE) {
3991 _mesa_append_fog_code(ctx, program);
3992 program->FogOption = GL_NONE;
3993 }
3994
3995 #if DEBUG_FP
3996 _mesa_printf("____________Fragment program %u ________\n", program->Base.Id);
3997 _mesa_print_program(&program->Base);
3998 #endif
3999 }
4000
4001
4002
4003 /**
4004 * Parse the vertex program string. If success, update the given
4005 * vertex_program object with the new program. Else, leave the vertex_program
4006 * object unchanged.
4007 */
4008 void
4009 _mesa_parse_arb_vertex_program(GLcontext *ctx, GLenum target,
4010 const GLvoid *str, GLsizei len,
4011 struct gl_vertex_program *program)
4012 {
4013 struct arb_program ap;
4014
4015 ASSERT(target == GL_VERTEX_PROGRAM_ARB);
4016
4017 if (!_mesa_parse_arb_program(ctx, target, (const GLubyte*) str, len, &ap)) {
4018 _mesa_error(ctx, GL_INVALID_OPERATION, "glProgramString(bad program)");
4019 return;
4020 }
4021
4022 /* Copy the relevant contents of the arb_program struct into the
4023 * vertex_program struct.
4024 */
4025 program->Base.String = ap.Base.String;
4026 program->Base.NumInstructions = ap.Base.NumInstructions;
4027 program->Base.NumTemporaries = ap.Base.NumTemporaries;
4028 program->Base.NumParameters = ap.Base.NumParameters;
4029 program->Base.NumAttributes = ap.Base.NumAttributes;
4030 program->Base.NumAddressRegs = ap.Base.NumAddressRegs;
4031 program->Base.NumNativeInstructions = ap.Base.NumNativeInstructions;
4032 program->Base.NumNativeTemporaries = ap.Base.NumNativeTemporaries;
4033 program->Base.NumNativeParameters = ap.Base.NumNativeParameters;
4034 program->Base.NumNativeAttributes = ap.Base.NumNativeAttributes;
4035 program->Base.NumNativeAddressRegs = ap.Base.NumNativeAddressRegs;
4036 program->Base.InputsRead = ap.Base.InputsRead;
4037 program->Base.OutputsWritten = ap.Base.OutputsWritten;
4038 program->IsPositionInvariant = ap.HintPositionInvariant;
4039
4040 if (program->Base.Instructions)
4041 _mesa_free(program->Base.Instructions);
4042 program->Base.Instructions = ap.Base.Instructions;
4043
4044 if (program->Base.Parameters)
4045 _mesa_free_parameter_list(program->Base.Parameters);
4046 program->Base.Parameters = ap.Base.Parameters;
4047
4048 #if DEBUG_VP
4049 _mesa_printf("____________Vertex program %u __________\n", program->Base.Id);
4050 _mesa_print_program(&program->Base);
4051 #endif
4052 }