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