blob: b60b9656c62188a2d580fbee863078590e9e6544 [file] [log] [blame]
Jouk Jansen40322e12004-04-05 08:50:36 +00001/*
2 * Mesa 3-D graphics library
Brian50a20d42008-03-27 15:51:07 -06003 * Version: 7.1
Jouk Jansen40322e12004-04-05 08:50:36 +00004 *
Brianbdf279b2008-03-27 16:19:46 -06005 * Copyright (C) 1999-2008 Brian Paul All Rights Reserved.
Jouk Jansen40322e12004-04-05 08:50:36 +00006 *
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
Brianc223c6b2007-07-04 13:15:20 -060033#include "main/glheader.h"
34#include "main/imports.h"
35#include "shader/grammar/grammar_mesa.h"
Jouk Jansen40322e12004-04-05 08:50:36 +000036#include "arbprogparse.h"
Brian Paul32df89e2005-10-29 18:26:43 +000037#include "program.h"
Brian Paulc0ef1662008-03-25 11:32:31 -060038#include "programopt.h"
Brianc0551f02006-12-14 15:02:37 -070039#include "prog_parameter.h"
40#include "prog_statevars.h"
Brian Paul8c41a142005-11-19 15:36:28 +000041#include "context.h"
Brian Paul6211a142006-08-24 23:37:13 +000042#include "macros.h"
Brian Paul8c41a142005-11-19 15:36:28 +000043#include "mtypes.h"
Brianc0551f02006-12-14 15:02:37 -070044#include "prog_instruction.h"
Brian Paul8c41a142005-11-19 15:36:28 +000045
46
Brian Paul6211a142006-08-24 23:37:13 +000047/* For ARB programs, use the NV instruction limits */
48#define MAX_INSTRUCTIONS MAX2(MAX_NV_FRAGMENT_PROGRAM_INSTRUCTIONS, \
49 MAX_NV_VERTEX_PROGRAM_INSTRUCTIONS)
Brian Paul8c41a142005-11-19 15:36:28 +000050
51
52/**
53 * This is basically a union of the vertex_program and fragment_program
54 * structs that we can use to parse the program into
55 *
56 * XXX we can probably get rid of this entirely someday.
57 */
58struct arb_program
59{
Brian Paul122629f2006-07-20 16:49:57 +000060 struct gl_program Base;
Brian Paul8c41a142005-11-19 15:36:28 +000061
62 GLuint Position; /* Just used for error reporting while parsing */
63 GLuint MajorVersion;
64 GLuint MinorVersion;
65
66 /* ARB_vertex_progmra options */
67 GLboolean HintPositionInvariant;
68
69 /* ARB_fragment_progmra options */
70 GLenum PrecisionOption; /* GL_DONT_CARE, GL_NICEST or GL_FASTEST */
71 GLenum FogOption; /* GL_NONE, GL_LINEAR, GL_EXP or GL_EXP2 */
72
73 /* ARB_fragment_program specifics */
74 GLbitfield TexturesUsed[MAX_TEXTURE_IMAGE_UNITS];
Ian Romanick7b559a92007-06-07 13:58:50 -070075 GLbitfield ShadowSamplers;
Brian Paul8c41a142005-11-19 15:36:28 +000076 GLuint NumAluInstructions;
77 GLuint NumTexInstructions;
78 GLuint NumTexIndirections;
79
80 GLboolean UsesKill;
81};
82
Ian Romanick9bdfee32005-07-18 12:31:24 +000083
Brian Paula6c423d2004-08-25 15:59:48 +000084
Jouk Jansen40322e12004-04-05 08:50:36 +000085/* TODO:
86 * Fragment Program Stuff:
87 * -----------------------------------------------------
88 *
89 * - things from Michal's email
90 * + overflow on atoi
91 * + not-overflowing floats (don't use parse_integer..)
92 * + can remove range checking in arbparse.c
93 *
94 * - check all limits of number of various variables
95 * + parameters
96 *
97 * - test! test! test!
98 *
99 * Vertex Program Stuff:
100 * -----------------------------------------------------
101 * - Optimize param array usage and count limits correctly, see spec,
102 * section 2.14.3.7
103 * + Record if an array is reference absolutly or relatively (or both)
104 * + For absolute arrays, store a bitmap of accesses
105 * + For single parameters, store an access flag
106 * + After parsing, make a parameter cleanup and merging pass, where
107 * relative arrays are layed out first, followed by abs arrays, and
108 * finally single state.
109 * + Remap offsets for param src and dst registers
110 * + Now we can properly count parameter usage
111 *
112 * - Multiple state binding errors in param arrays (see spec, just before
113 * section 2.14.3.3)
114 * - grep for XXX
115 *
116 * Mesa Stuff
117 * -----------------------------------------------------
118 * - User clipping planes vs. PositionInvariant
119 * - Is it sufficient to just multiply by the mvp to transform in the
120 * PositionInvariant case? Or do we need something more involved?
121 *
122 * - vp_src swizzle is GLubyte, fp_src swizzle is GLuint
123 * - fetch state listed in program_parameters list
124 * + WTF should this go???
125 * + currently in nvvertexec.c and s_nvfragprog.c
126 *
127 * - allow for multiple address registers (and fetch address regs properly)
128 *
129 * Cosmetic Stuff
130 * -----------------------------------------------------
131 * - remove any leftover unused grammer.c stuff (dict_ ?)
132 * - fix grammer.c error handling so its not static
133 * - #ifdef around stuff pertaining to extentions
134 *
135 * Outstanding Questions:
136 * -----------------------------------------------------
137 * - ARB_matrix_palette / ARB_vertex_blend -- not supported
138 * what gets hacked off because of this:
139 * + VERTEX_ATTRIB_MATRIXINDEX
140 * + VERTEX_ATTRIB_WEIGHT
141 * + MATRIX_MODELVIEW
142 * + MATRIX_PALETTE
143 *
144 * - When can we fetch env/local params from their own register files, and
145 * when to we have to fetch them into the main state register file?
146 * (think arrays)
147 *
148 * Grammar Changes:
149 * -----------------------------------------------------
150 */
151
152/* Changes since moving the file to shader directory
153
1542004-III-4 ------------------------------------------------------------
155- added #include "grammar_mesa.h"
156- removed grammar specific code part (it resides now in grammar.c)
157- added GL_ARB_fragment_program_shadow tokens
158- modified #include "arbparse_syn.h"
159- major changes inside _mesa_parse_arb_program()
160- check the program string for '\0' characters
161- copy the program string to a one-byte-longer location to have
162 it null-terminated
163- position invariance test (not writing to result.position) moved
164 to syntax part
165*/
166
167typedef GLubyte *production;
168
Brian Paul11a54c32006-11-15 19:54:25 +0000169
Jouk Jansen40322e12004-04-05 08:50:36 +0000170/**
171 * This is the text describing the rules to parse the grammar
172 */
Brian Paul11a54c32006-11-15 19:54:25 +0000173LONGSTRING static char arb_grammar_text[] =
Jouk Jansen40322e12004-04-05 08:50:36 +0000174#include "arbprogram_syn.h"
175;
176
177/**
178 * These should match up with the values defined in arbprogram.syn
179 */
180
181/*
182 Changes:
183 - changed and merged V_* and F_* opcode values to OP_*.
184 - added GL_ARB_fragment_program_shadow specific tokens (michal)
185*/
Ian Romanickbb372f12007-05-16 15:34:22 -0700186#define REVISION 0x0a
Jouk Jansen40322e12004-04-05 08:50:36 +0000187
188/* program type */
189#define FRAGMENT_PROGRAM 0x01
190#define VERTEX_PROGRAM 0x02
191
192/* program section */
193#define OPTION 0x01
194#define INSTRUCTION 0x02
195#define DECLARATION 0x03
196#define END 0x04
197
Michal Krolb80bc052004-10-21 14:09:54 +0000198/* GL_ARB_fragment_program option */
199#define ARB_PRECISION_HINT_FASTEST 0x00
200#define ARB_PRECISION_HINT_NICEST 0x01
201#define ARB_FOG_EXP 0x02
202#define ARB_FOG_EXP2 0x03
203#define ARB_FOG_LINEAR 0x04
Jouk Jansen40322e12004-04-05 08:50:36 +0000204
Michal Krolb80bc052004-10-21 14:09:54 +0000205/* GL_ARB_vertex_program option */
206#define ARB_POSITION_INVARIANT 0x05
Jouk Jansen40322e12004-04-05 08:50:36 +0000207
Michal Krolb80bc052004-10-21 14:09:54 +0000208/* GL_ARB_fragment_program_shadow option */
209#define ARB_FRAGMENT_PROGRAM_SHADOW 0x06
Jouk Jansen40322e12004-04-05 08:50:36 +0000210
Michal Krolb80bc052004-10-21 14:09:54 +0000211/* GL_ARB_draw_buffers option */
212#define ARB_DRAW_BUFFERS 0x07
Michal Krolad22ce82004-10-11 08:13:25 +0000213
Ian Romanickbb372f12007-05-16 15:34:22 -0700214/* GL_MESA_texture_array option */
215#define MESA_TEXTURE_ARRAY 0x08
216
Jouk Jansen40322e12004-04-05 08:50:36 +0000217/* GL_ARB_fragment_program instruction class */
218#define OP_ALU_INST 0x00
219#define OP_TEX_INST 0x01
220
221/* GL_ARB_vertex_program instruction class */
222/* OP_ALU_INST */
223
224/* GL_ARB_fragment_program instruction type */
225#define OP_ALU_VECTOR 0x00
226#define OP_ALU_SCALAR 0x01
227#define OP_ALU_BINSC 0x02
228#define OP_ALU_BIN 0x03
229#define OP_ALU_TRI 0x04
230#define OP_ALU_SWZ 0x05
231#define OP_TEX_SAMPLE 0x06
232#define OP_TEX_KIL 0x07
233
234/* GL_ARB_vertex_program instruction type */
235#define OP_ALU_ARL 0x08
236/* OP_ALU_VECTOR */
237/* OP_ALU_SCALAR */
238/* OP_ALU_BINSC */
239/* OP_ALU_BIN */
240/* OP_ALU_TRI */
241/* OP_ALU_SWZ */
242
243/* GL_ARB_fragment_program instruction code */
244#define OP_ABS 0x00
245#define OP_ABS_SAT 0x1B
246#define OP_FLR 0x09
247#define OP_FLR_SAT 0x26
248#define OP_FRC 0x0A
249#define OP_FRC_SAT 0x27
250#define OP_LIT 0x0C
251#define OP_LIT_SAT 0x2A
252#define OP_MOV 0x11
253#define OP_MOV_SAT 0x30
254#define OP_COS 0x1F
255#define OP_COS_SAT 0x20
256#define OP_EX2 0x07
257#define OP_EX2_SAT 0x25
258#define OP_LG2 0x0B
259#define OP_LG2_SAT 0x29
260#define OP_RCP 0x14
261#define OP_RCP_SAT 0x33
262#define OP_RSQ 0x15
263#define OP_RSQ_SAT 0x34
264#define OP_SIN 0x38
265#define OP_SIN_SAT 0x39
266#define OP_SCS 0x35
267#define OP_SCS_SAT 0x36
268#define OP_POW 0x13
269#define OP_POW_SAT 0x32
270#define OP_ADD 0x01
271#define OP_ADD_SAT 0x1C
272#define OP_DP3 0x03
273#define OP_DP3_SAT 0x21
274#define OP_DP4 0x04
275#define OP_DP4_SAT 0x22
276#define OP_DPH 0x05
277#define OP_DPH_SAT 0x23
278#define OP_DST 0x06
279#define OP_DST_SAT 0x24
280#define OP_MAX 0x0F
281#define OP_MAX_SAT 0x2E
282#define OP_MIN 0x10
283#define OP_MIN_SAT 0x2F
284#define OP_MUL 0x12
285#define OP_MUL_SAT 0x31
286#define OP_SGE 0x16
287#define OP_SGE_SAT 0x37
288#define OP_SLT 0x17
289#define OP_SLT_SAT 0x3A
290#define OP_SUB 0x18
291#define OP_SUB_SAT 0x3B
292#define OP_XPD 0x1A
293#define OP_XPD_SAT 0x43
294#define OP_CMP 0x1D
295#define OP_CMP_SAT 0x1E
296#define OP_LRP 0x2B
297#define OP_LRP_SAT 0x2C
298#define OP_MAD 0x0E
299#define OP_MAD_SAT 0x2D
300#define OP_SWZ 0x19
301#define OP_SWZ_SAT 0x3C
302#define OP_TEX 0x3D
303#define OP_TEX_SAT 0x3E
304#define OP_TXB 0x3F
305#define OP_TXB_SAT 0x40
306#define OP_TXP 0x41
307#define OP_TXP_SAT 0x42
308#define OP_KIL 0x28
309
310/* GL_ARB_vertex_program instruction code */
311#define OP_ARL 0x02
312/* OP_ABS */
313/* OP_FLR */
314/* OP_FRC */
315/* OP_LIT */
316/* OP_MOV */
317/* OP_EX2 */
318#define OP_EXP 0x08
319/* OP_LG2 */
320#define OP_LOG 0x0D
321/* OP_RCP */
322/* OP_RSQ */
323/* OP_POW */
324/* OP_ADD */
325/* OP_DP3 */
326/* OP_DP4 */
327/* OP_DPH */
328/* OP_DST */
329/* OP_MAX */
330/* OP_MIN */
331/* OP_MUL */
332/* OP_SGE */
333/* OP_SLT */
334/* OP_SUB */
335/* OP_XPD */
336/* OP_MAD */
337/* OP_SWZ */
338
339/* fragment attribute binding */
340#define FRAGMENT_ATTRIB_COLOR 0x01
341#define FRAGMENT_ATTRIB_TEXCOORD 0x02
342#define FRAGMENT_ATTRIB_FOGCOORD 0x03
343#define FRAGMENT_ATTRIB_POSITION 0x04
344
345/* vertex attribute binding */
346#define VERTEX_ATTRIB_POSITION 0x01
347#define VERTEX_ATTRIB_WEIGHT 0x02
348#define VERTEX_ATTRIB_NORMAL 0x03
349#define VERTEX_ATTRIB_COLOR 0x04
350#define VERTEX_ATTRIB_FOGCOORD 0x05
351#define VERTEX_ATTRIB_TEXCOORD 0x06
352#define VERTEX_ATTRIB_MATRIXINDEX 0x07
353#define VERTEX_ATTRIB_GENERIC 0x08
354
355/* fragment result binding */
356#define FRAGMENT_RESULT_COLOR 0x01
357#define FRAGMENT_RESULT_DEPTH 0x02
358
359/* vertex result binding */
360#define VERTEX_RESULT_POSITION 0x01
361#define VERTEX_RESULT_COLOR 0x02
362#define VERTEX_RESULT_FOGCOORD 0x03
363#define VERTEX_RESULT_POINTSIZE 0x04
364#define VERTEX_RESULT_TEXCOORD 0x05
365
366/* texture target */
367#define TEXTARGET_1D 0x01
368#define TEXTARGET_2D 0x02
369#define TEXTARGET_3D 0x03
370#define TEXTARGET_RECT 0x04
371#define TEXTARGET_CUBE 0x05
372/* GL_ARB_fragment_program_shadow */
373#define TEXTARGET_SHADOW1D 0x06
374#define TEXTARGET_SHADOW2D 0x07
375#define TEXTARGET_SHADOWRECT 0x08
Ian Romanickbb372f12007-05-16 15:34:22 -0700376/* GL_MESA_texture_array */
377#define TEXTARGET_1D_ARRAY 0x09
378#define TEXTARGET_2D_ARRAY 0x0a
Ian Romanick69358e72007-06-05 09:24:27 -0700379#define TEXTARGET_SHADOW1D_ARRAY 0x0b
380#define TEXTARGET_SHADOW2D_ARRAY 0x0c
Jouk Jansen40322e12004-04-05 08:50:36 +0000381
382/* face type */
383#define FACE_FRONT 0x00
384#define FACE_BACK 0x01
385
386/* color type */
387#define COLOR_PRIMARY 0x00
388#define COLOR_SECONDARY 0x01
389
390/* component */
391#define COMPONENT_X 0x00
392#define COMPONENT_Y 0x01
393#define COMPONENT_Z 0x02
394#define COMPONENT_W 0x03
395#define COMPONENT_0 0x04
396#define COMPONENT_1 0x05
397
398/* array index type */
399#define ARRAY_INDEX_ABSOLUTE 0x00
400#define ARRAY_INDEX_RELATIVE 0x01
401
402/* matrix name */
403#define MATRIX_MODELVIEW 0x01
404#define MATRIX_PROJECTION 0x02
405#define MATRIX_MVP 0x03
406#define MATRIX_TEXTURE 0x04
407#define MATRIX_PALETTE 0x05
408#define MATRIX_PROGRAM 0x06
409
410/* matrix modifier */
411#define MATRIX_MODIFIER_IDENTITY 0x00
412#define MATRIX_MODIFIER_INVERSE 0x01
413#define MATRIX_MODIFIER_TRANSPOSE 0x02
414#define MATRIX_MODIFIER_INVTRANS 0x03
415
416/* constant type */
417#define CONSTANT_SCALAR 0x01
418#define CONSTANT_VECTOR 0x02
419
420/* program param type */
421#define PROGRAM_PARAM_ENV 0x01
422#define PROGRAM_PARAM_LOCAL 0x02
423
424/* register type */
425#define REGISTER_ATTRIB 0x01
426#define REGISTER_PARAM 0x02
427#define REGISTER_RESULT 0x03
428#define REGISTER_ESTABLISHED_NAME 0x04
429
430/* param binding */
431#define PARAM_NULL 0x00
432#define PARAM_ARRAY_ELEMENT 0x01
433#define PARAM_STATE_ELEMENT 0x02
434#define PARAM_PROGRAM_ELEMENT 0x03
435#define PARAM_PROGRAM_ELEMENTS 0x04
436#define PARAM_CONSTANT 0x05
437
438/* param state property */
439#define STATE_MATERIAL_PARSER 0x01
440#define STATE_LIGHT_PARSER 0x02
441#define STATE_LIGHT_MODEL 0x03
442#define STATE_LIGHT_PROD 0x04
443#define STATE_FOG 0x05
444#define STATE_MATRIX_ROWS 0x06
445/* GL_ARB_fragment_program */
446#define STATE_TEX_ENV 0x07
447#define STATE_DEPTH 0x08
448/* GL_ARB_vertex_program */
449#define STATE_TEX_GEN 0x09
450#define STATE_CLIP_PLANE 0x0A
451#define STATE_POINT 0x0B
452
453/* state material property */
454#define MATERIAL_AMBIENT 0x01
455#define MATERIAL_DIFFUSE 0x02
456#define MATERIAL_SPECULAR 0x03
457#define MATERIAL_EMISSION 0x04
458#define MATERIAL_SHININESS 0x05
459
460/* state light property */
461#define LIGHT_AMBIENT 0x01
462#define LIGHT_DIFFUSE 0x02
463#define LIGHT_SPECULAR 0x03
464#define LIGHT_POSITION 0x04
465#define LIGHT_ATTENUATION 0x05
466#define LIGHT_HALF 0x06
467#define LIGHT_SPOT_DIRECTION 0x07
468
469/* state light model property */
470#define LIGHT_MODEL_AMBIENT 0x01
471#define LIGHT_MODEL_SCENECOLOR 0x02
472
473/* state light product property */
474#define LIGHT_PROD_AMBIENT 0x01
475#define LIGHT_PROD_DIFFUSE 0x02
476#define LIGHT_PROD_SPECULAR 0x03
477
478/* state texture environment property */
479#define TEX_ENV_COLOR 0x01
480
481/* state texture generation coord property */
482#define TEX_GEN_EYE 0x01
483#define TEX_GEN_OBJECT 0x02
484
485/* state fog property */
486#define FOG_COLOR 0x01
487#define FOG_PARAMS 0x02
488
489/* state depth property */
490#define DEPTH_RANGE 0x01
491
492/* state point parameters property */
493#define POINT_SIZE 0x01
494#define POINT_ATTENUATION 0x02
495
496/* declaration */
497#define ATTRIB 0x01
498#define PARAM 0x02
499#define TEMP 0x03
500#define OUTPUT 0x04
501#define ALIAS 0x05
502/* GL_ARB_vertex_program */
503#define ADDRESS 0x06
504
505/*-----------------------------------------------------------------------
506 * From here on down is the semantic checking portion
507 *
508 */
509
510/**
511 * Variable Table Handling functions
512 */
513typedef enum
514{
515 vt_none,
516 vt_address,
517 vt_attrib,
518 vt_param,
519 vt_temp,
520 vt_output,
521 vt_alias
522} var_type;
523
524
Brian Paul7aebaf32005-10-30 21:23:23 +0000525/**
526 * Setting an explicit field for each of the binding properties is a bit
527 * wasteful of space, but it should be much more clear when reading later on..
Jouk Jansen40322e12004-04-05 08:50:36 +0000528 */
529struct var_cache
530{
Brian Paul6a769d92006-04-28 15:42:15 +0000531 const GLubyte *name; /* don't free() - no need */
Jouk Jansen40322e12004-04-05 08:50:36 +0000532 var_type type;
533 GLuint address_binding; /* The index of the address register we should
534 * be using */
535 GLuint attrib_binding; /* For type vt_attrib, see nvfragprog.h for values */
Jouk Jansen40322e12004-04-05 08:50:36 +0000536 GLuint attrib_is_generic; /* If the attrib was specified through a generic
537 * vertex attrib */
538 GLuint temp_binding; /* The index of the temp register we are to use */
Brian Paul7aebaf32005-10-30 21:23:23 +0000539 GLuint output_binding; /* Output/result register number */
Jouk Jansen40322e12004-04-05 08:50:36 +0000540 struct var_cache *alias_binding; /* For type vt_alias, points to the var_cache entry
541 * that this is aliased to */
542 GLuint param_binding_type; /* {PROGRAM_STATE_VAR, PROGRAM_LOCAL_PARAM,
543 * PROGRAM_ENV_PARAM} */
544 GLuint param_binding_begin; /* This is the offset into the program_parameter_list where
545 * the tokens representing our bound state (or constants)
546 * start */
547 GLuint param_binding_length; /* This is how many entries in the the program_parameter_list
548 * we take up with our state tokens or constants. Note that
549 * this is _not_ the same as the number of param registers
550 * we eventually use */
551 struct var_cache *next;
552};
553
554static GLvoid
555var_cache_create (struct var_cache **va)
556{
557 *va = (struct var_cache *) _mesa_malloc (sizeof (struct var_cache));
558 if (*va) {
559 (**va).name = NULL;
560 (**va).type = vt_none;
561 (**va).attrib_binding = ~0;
562 (**va).attrib_is_generic = 0;
563 (**va).temp_binding = ~0;
564 (**va).output_binding = ~0;
Jouk Jansen40322e12004-04-05 08:50:36 +0000565 (**va).param_binding_type = ~0;
566 (**va).param_binding_begin = ~0;
567 (**va).param_binding_length = ~0;
568 (**va).alias_binding = NULL;
569 (**va).next = NULL;
570 }
571}
572
573static GLvoid
574var_cache_destroy (struct var_cache **va)
575{
576 if (*va) {
577 var_cache_destroy (&(**va).next);
578 _mesa_free (*va);
579 *va = NULL;
580 }
581}
582
583static GLvoid
584var_cache_append (struct var_cache **va, struct var_cache *nv)
585{
586 if (*va)
587 var_cache_append (&(**va).next, nv);
588 else
589 *va = nv;
590}
591
592static struct var_cache *
Brian Paula088f162006-09-05 23:08:51 +0000593var_cache_find (struct var_cache *va, const GLubyte * name)
Jouk Jansen40322e12004-04-05 08:50:36 +0000594{
Brian Paul0a360cf2005-01-17 01:21:03 +0000595 /*struct var_cache *first = va;*/
Jouk Jansen40322e12004-04-05 08:50:36 +0000596
597 while (va) {
Brian Paulaa206952005-09-16 18:14:24 +0000598 if (!_mesa_strcmp ( (const char*) name, (const char*) va->name)) {
Jouk Jansen40322e12004-04-05 08:50:36 +0000599 if (va->type == vt_alias)
Michal Krol43343912005-01-11 15:47:16 +0000600 return va->alias_binding;
Jouk Jansen40322e12004-04-05 08:50:36 +0000601 return va;
602 }
603
604 va = va->next;
605 }
606
607 return NULL;
608}
609
Brian Paula088f162006-09-05 23:08:51 +0000610
611
612/**
613 * Called when an error is detected while parsing/compiling a program.
614 * Sets the ctx->Program.ErrorString field to descript and records a
615 * GL_INVALID_OPERATION error.
616 * \param position position of error in program string
617 * \param descrip verbose error description
618 */
619static void
620program_error(GLcontext *ctx, GLint position, const char *descrip)
621{
622 if (descrip) {
623 const char *prefix = "glProgramString(", *suffix = ")";
624 char *str = (char *) _mesa_malloc(_mesa_strlen(descrip) +
625 _mesa_strlen(prefix) +
626 _mesa_strlen(suffix) + 1);
627 if (str) {
628 _mesa_sprintf(str, "%s%s%s", prefix, descrip, suffix);
629 _mesa_error(ctx, GL_INVALID_OPERATION, str);
630 _mesa_free(str);
631 }
632 }
633 _mesa_set_program_error(ctx, position, descrip);
634}
635
636
Brian50a20d42008-03-27 15:51:07 -0600637/**
638 * As above, but with an extra string parameter for more info.
639 */
640static void
641program_error2(GLcontext *ctx, GLint position, const char *descrip,
642 const char *var)
643{
644 if (descrip) {
645 const char *prefix = "glProgramString(", *suffix = ")";
646 char *str = (char *) _mesa_malloc(_mesa_strlen(descrip) +
647 _mesa_strlen(": ") +
648 _mesa_strlen(var) +
649 _mesa_strlen(prefix) +
650 _mesa_strlen(suffix) + 1);
651 if (str) {
652 _mesa_sprintf(str, "%s%s: %s%s", prefix, descrip, var, suffix);
653 _mesa_error(ctx, GL_INVALID_OPERATION, str);
654 _mesa_free(str);
655 }
656 }
657 {
658 char *str = (char *) _mesa_malloc(_mesa_strlen(descrip) +
659 _mesa_strlen(": ") +
660 _mesa_strlen(var) + 1);
661 if (str) {
662 _mesa_sprintf(str, "%s: %s", descrip, var);
663 }
664 _mesa_set_program_error(ctx, position, str);
665 if (str) {
666 _mesa_free(str);
667 }
668 }
669}
670
671
Brian Paula088f162006-09-05 23:08:51 +0000672
Jouk Jansen40322e12004-04-05 08:50:36 +0000673/**
674 * constructs an integer from 4 GLubytes in LE format
675 */
676static GLuint
Brian Paula088f162006-09-05 23:08:51 +0000677parse_position (const GLubyte ** inst)
Jouk Jansen40322e12004-04-05 08:50:36 +0000678{
679 GLuint value;
680
681 value = (GLuint) (*(*inst)++);
682 value += (GLuint) (*(*inst)++) * 0x100;
683 value += (GLuint) (*(*inst)++) * 0x10000;
684 value += (GLuint) (*(*inst)++) * 0x1000000;
685
686 return value;
687}
688
689/**
690 * This will, given a string, lookup the string as a variable name in the
691 * var cache. If the name is found, the var cache node corresponding to the
692 * var name is returned. If it is not found, a new entry is allocated
693 *
694 * \param I Points into the binary array where the string identifier begins
695 * \param found 1 if the string was found in the var_cache, 0 if it was allocated
696 * \return The location on the var_cache corresponding the the string starting at I
697 */
698static struct var_cache *
Brian Paula088f162006-09-05 23:08:51 +0000699parse_string (const GLubyte ** inst, struct var_cache **vc_head,
Jouk Jansen40322e12004-04-05 08:50:36 +0000700 struct arb_program *Program, GLuint * found)
701{
Brian Paula088f162006-09-05 23:08:51 +0000702 const GLubyte *i = *inst;
Jouk Jansen40322e12004-04-05 08:50:36 +0000703 struct var_cache *va = NULL;
Brian Paula6c423d2004-08-25 15:59:48 +0000704 (void) Program;
Jouk Jansen40322e12004-04-05 08:50:36 +0000705
706 *inst += _mesa_strlen ((char *) i) + 1;
707
708 va = var_cache_find (*vc_head, i);
709
710 if (va) {
711 *found = 1;
712 return va;
713 }
714
715 *found = 0;
716 var_cache_create (&va);
Brian Paul6a769d92006-04-28 15:42:15 +0000717 va->name = (const GLubyte *) i;
Jouk Jansen40322e12004-04-05 08:50:36 +0000718
719 var_cache_append (vc_head, va);
720
721 return va;
722}
723
724static char *
Brian Paula088f162006-09-05 23:08:51 +0000725parse_string_without_adding (const GLubyte ** inst, struct arb_program *Program)
Jouk Jansen40322e12004-04-05 08:50:36 +0000726{
Brian Paula088f162006-09-05 23:08:51 +0000727 const GLubyte *i = *inst;
Brian Paula6c423d2004-08-25 15:59:48 +0000728 (void) Program;
729
Jouk Jansen40322e12004-04-05 08:50:36 +0000730 *inst += _mesa_strlen ((char *) i) + 1;
731
732 return (char *) i;
733}
734
735/**
Brian Paul05908952004-06-08 15:20:23 +0000736 * \return -1 if we parse '-', return 1 otherwise
Jouk Jansen40322e12004-04-05 08:50:36 +0000737 */
Brian Paul05908952004-06-08 15:20:23 +0000738static GLint
Brian Paula088f162006-09-05 23:08:51 +0000739parse_sign (const GLubyte ** inst)
Jouk Jansen40322e12004-04-05 08:50:36 +0000740{
741 /*return *(*inst)++ != '+'; */
742
743 if (**inst == '-') {
744 (*inst)++;
Brian Paul05908952004-06-08 15:20:23 +0000745 return -1;
Jouk Jansen40322e12004-04-05 08:50:36 +0000746 }
747 else if (**inst == '+') {
748 (*inst)++;
Brian Paul05908952004-06-08 15:20:23 +0000749 return 1;
Jouk Jansen40322e12004-04-05 08:50:36 +0000750 }
751
Brian Paul05908952004-06-08 15:20:23 +0000752 return 1;
Jouk Jansen40322e12004-04-05 08:50:36 +0000753}
754
755/**
756 * parses and returns signed integer
757 */
758static GLint
Brian Paula088f162006-09-05 23:08:51 +0000759parse_integer (const GLubyte ** inst, struct arb_program *Program)
Jouk Jansen40322e12004-04-05 08:50:36 +0000760{
761 GLint sign;
762 GLint value;
763
764 /* check if *inst points to '+' or '-'
765 * if yes, grab the sign and increment *inst
766 */
767 sign = parse_sign (inst);
768
769 /* now check if *inst points to 0
770 * if yes, increment the *inst and return the default value
771 */
772 if (**inst == 0) {
773 (*inst)++;
774 return 0;
775 }
776
777 /* parse the integer as you normally would do it */
778 value = _mesa_atoi (parse_string_without_adding (inst, Program));
779
780 /* now, after terminating 0 there is a position
781 * to parse it - parse_position()
782 */
783 Program->Position = parse_position (inst);
784
Brian Paul05908952004-06-08 15:20:23 +0000785 return value * sign;
Jouk Jansen40322e12004-04-05 08:50:36 +0000786}
787
788/**
Brian Paul1ff8f502005-02-16 15:08:29 +0000789 Accumulate this string of digits, and return them as
790 a large integer represented in floating point (for range).
791 If scale is not NULL, also accumulates a power-of-ten
792 integer scale factor that represents the number of digits
793 in the string.
794*/
795static GLdouble
Brian Paula088f162006-09-05 23:08:51 +0000796parse_float_string(const GLubyte ** inst, struct arb_program *Program, GLdouble *scale)
Brian Paul1ff8f502005-02-16 15:08:29 +0000797{
798 GLdouble value = 0.0;
799 GLdouble oscale = 1.0;
800
801 if (**inst == 0) { /* this string of digits is empty-- do nothing */
802 (*inst)++;
803 }
804 else { /* nonempty string-- parse out the digits */
Michal Krol98e35022005-04-14 10:19:19 +0000805 while (**inst >= '0' && **inst <= '9') {
Brian Paul1ff8f502005-02-16 15:08:29 +0000806 GLubyte digit = *((*inst)++);
807 value = value * 10.0 + (GLint) (digit - '0');
808 oscale *= 10.0;
809 }
810 assert(**inst == 0); /* integer string should end with 0 */
811 (*inst)++; /* skip over terminating 0 */
812 Program->Position = parse_position(inst); /* skip position (from integer) */
813 }
814 if (scale)
815 *scale = oscale;
816 return value;
817}
818
819/**
820 Parse an unsigned floating-point number from this stream of tokenized
821 characters. Example floating-point formats supported:
822 12.34
823 12
824 0.34
825 .34
826 12.34e-4
Jouk Jansen40322e12004-04-05 08:50:36 +0000827 */
828static GLfloat
Brian Paula088f162006-09-05 23:08:51 +0000829parse_float (const GLubyte ** inst, struct arb_program *Program)
Jouk Jansen40322e12004-04-05 08:50:36 +0000830{
Brian Paul1ff8f502005-02-16 15:08:29 +0000831 GLint exponent;
832 GLdouble whole, fraction, fracScale = 1.0;
Jouk Jansen40322e12004-04-05 08:50:36 +0000833
Brian Paul1ff8f502005-02-16 15:08:29 +0000834 whole = parse_float_string(inst, Program, 0);
835 fraction = parse_float_string(inst, Program, &fracScale);
836
837 /* Parse signed exponent */
838 exponent = parse_integer(inst, Program); /* This is the exponent */
Jouk Jansen40322e12004-04-05 08:50:36 +0000839
Brian Paul1ff8f502005-02-16 15:08:29 +0000840 /* Assemble parts of floating-point number: */
841 return (GLfloat) ((whole + fraction / fracScale) *
842 _mesa_pow(10.0, (GLfloat) exponent));
Jouk Jansen40322e12004-04-05 08:50:36 +0000843}
844
845
846/**
847 */
848static GLfloat
Brian Paula088f162006-09-05 23:08:51 +0000849parse_signed_float (const GLubyte ** inst, struct arb_program *Program)
Jouk Jansen40322e12004-04-05 08:50:36 +0000850{
Brian Paul05908952004-06-08 15:20:23 +0000851 GLint sign = parse_sign (inst);
852 GLfloat value = parse_float (inst, Program);
853 return value * sign;
Jouk Jansen40322e12004-04-05 08:50:36 +0000854}
855
856/**
857 * This picks out a constant value from the parsed array. The constant vector is r
858 * returned in the *values array, which should be of length 4.
859 *
860 * \param values - The 4 component vector with the constant value in it
861 */
862static GLvoid
Brian Paula088f162006-09-05 23:08:51 +0000863parse_constant (const GLubyte ** inst, GLfloat *values, struct arb_program *Program,
Jouk Jansen40322e12004-04-05 08:50:36 +0000864 GLboolean use)
865{
866 GLuint components, i;
867
868
869 switch (*(*inst)++) {
870 case CONSTANT_SCALAR:
871 if (use == GL_TRUE) {
872 values[0] =
873 values[1] =
874 values[2] = values[3] = parse_float (inst, Program);
875 }
876 else {
877 values[0] =
878 values[1] =
879 values[2] = values[3] = parse_signed_float (inst, Program);
880 }
881
882 break;
883 case CONSTANT_VECTOR:
884 values[0] = values[1] = values[2] = 0;
885 values[3] = 1;
886 components = *(*inst)++;
887 for (i = 0; i < components; i++) {
888 values[i] = parse_signed_float (inst, Program);
889 }
890 break;
891 }
892}
893
894/**
895 * \param offset The offset from the address register that we should
896 * address
897 *
898 * \return 0 on sucess, 1 on error
899 */
900static GLuint
Brian Paula088f162006-09-05 23:08:51 +0000901parse_relative_offset(GLcontext *ctx, const GLubyte **inst,
902 struct arb_program *Program, GLint *offset)
Jouk Jansen40322e12004-04-05 08:50:36 +0000903{
Brian Paul6a769d92006-04-28 15:42:15 +0000904 (void) ctx;
Jouk Jansen40322e12004-04-05 08:50:36 +0000905 *offset = parse_integer(inst, Program);
Jouk Jansen40322e12004-04-05 08:50:36 +0000906 return 0;
907}
908
909/**
910 * \param color 0 if color type is primary, 1 if color type is secondary
911 * \return 0 on sucess, 1 on error
912 */
913static GLuint
Brian Paula088f162006-09-05 23:08:51 +0000914parse_color_type (GLcontext * ctx, const GLubyte ** inst, struct arb_program *Program,
Jouk Jansen40322e12004-04-05 08:50:36 +0000915 GLint * color)
916{
Brian Paula6c423d2004-08-25 15:59:48 +0000917 (void) ctx; (void) Program;
Jouk Jansen40322e12004-04-05 08:50:36 +0000918 *color = *(*inst)++ != COLOR_PRIMARY;
919 return 0;
920}
921
922/**
923 * Get an integer corresponding to a generic vertex attribute.
924 *
925 * \return 0 on sucess, 1 on error
926 */
927static GLuint
Brian Paula088f162006-09-05 23:08:51 +0000928parse_generic_attrib_num(GLcontext *ctx, const GLubyte ** inst,
Jouk Jansen40322e12004-04-05 08:50:36 +0000929 struct arb_program *Program, GLuint *attrib)
930{
Brian Paulbd997cd2004-07-20 21:12:56 +0000931 GLint i = parse_integer(inst, Program);
Jouk Jansen40322e12004-04-05 08:50:36 +0000932
Michal Krolbb38cad2006-04-11 11:41:11 +0000933 if ((i < 0) || (i >= MAX_VERTEX_PROGRAM_ATTRIBS))
Jouk Jansen40322e12004-04-05 08:50:36 +0000934 {
Brian Paula088f162006-09-05 23:08:51 +0000935 program_error(ctx, Program->Position,
936 "Invalid generic vertex attribute index");
Jouk Jansen40322e12004-04-05 08:50:36 +0000937 return 1;
938 }
939
Brian Paulbd997cd2004-07-20 21:12:56 +0000940 *attrib = (GLuint) i;
941
Jouk Jansen40322e12004-04-05 08:50:36 +0000942 return 0;
943}
944
945
946/**
Brian Paulbe76b7f2004-10-04 14:40:05 +0000947 * \param color The index of the color buffer to write into
948 * \return 0 on sucess, 1 on error
949 */
950static GLuint
Brian Paula088f162006-09-05 23:08:51 +0000951parse_output_color_num (GLcontext * ctx, const GLubyte ** inst,
Brian Paulbe76b7f2004-10-04 14:40:05 +0000952 struct arb_program *Program, GLuint * color)
953{
954 GLint i = parse_integer (inst, Program);
955
956 if ((i < 0) || (i >= (int)ctx->Const.MaxDrawBuffers)) {
Brian Paula088f162006-09-05 23:08:51 +0000957 program_error(ctx, Program->Position, "Invalid draw buffer index");
Brian Paulbe76b7f2004-10-04 14:40:05 +0000958 return 1;
959 }
960
961 *color = (GLuint) i;
962 return 0;
963}
964
965
966/**
Jouk Jansen40322e12004-04-05 08:50:36 +0000967 * \param coord The texture unit index
968 * \return 0 on sucess, 1 on error
969 */
970static GLuint
Brian Paula088f162006-09-05 23:08:51 +0000971parse_texcoord_num (GLcontext * ctx, const GLubyte ** inst,
Jouk Jansen40322e12004-04-05 08:50:36 +0000972 struct arb_program *Program, GLuint * coord)
973{
Brian Paulbd997cd2004-07-20 21:12:56 +0000974 GLint i = parse_integer (inst, Program);
Jouk Jansen40322e12004-04-05 08:50:36 +0000975
Brian Paula6c423d2004-08-25 15:59:48 +0000976 if ((i < 0) || (i >= (int)ctx->Const.MaxTextureUnits)) {
Brian Paula088f162006-09-05 23:08:51 +0000977 program_error(ctx, Program->Position, "Invalid texture unit index");
Jouk Jansen40322e12004-04-05 08:50:36 +0000978 return 1;
979 }
980
Brian Paulbd997cd2004-07-20 21:12:56 +0000981 *coord = (GLuint) i;
Jouk Jansen40322e12004-04-05 08:50:36 +0000982 return 0;
983}
984
985/**
986 * \param coord The weight index
987 * \return 0 on sucess, 1 on error
988 */
989static GLuint
Brian Paula088f162006-09-05 23:08:51 +0000990parse_weight_num (GLcontext * ctx, const GLubyte ** inst, struct arb_program *Program,
Jouk Jansen40322e12004-04-05 08:50:36 +0000991 GLint * coord)
992{
993 *coord = parse_integer (inst, Program);
994
995 if ((*coord < 0) || (*coord >= 1)) {
Brian Paula088f162006-09-05 23:08:51 +0000996 program_error(ctx, Program->Position, "Invalid weight index");
Jouk Jansen40322e12004-04-05 08:50:36 +0000997 return 1;
998 }
999
1000 return 0;
1001}
1002
1003/**
1004 * \param coord The clip plane index
1005 * \return 0 on sucess, 1 on error
1006 */
1007static GLuint
Brian Paula088f162006-09-05 23:08:51 +00001008parse_clipplane_num (GLcontext * ctx, const GLubyte ** inst,
Jouk Jansen40322e12004-04-05 08:50:36 +00001009 struct arb_program *Program, GLint * coord)
1010{
1011 *coord = parse_integer (inst, Program);
1012
1013 if ((*coord < 0) || (*coord >= (GLint) ctx->Const.MaxClipPlanes)) {
Brian Paula088f162006-09-05 23:08:51 +00001014 program_error(ctx, Program->Position, "Invalid clip plane index");
Jouk Jansen40322e12004-04-05 08:50:36 +00001015 return 1;
1016 }
1017
1018 return 0;
1019}
1020
1021
1022/**
1023 * \return 0 on front face, 1 on back face
1024 */
1025static GLuint
Brian Paula088f162006-09-05 23:08:51 +00001026parse_face_type (const GLubyte ** inst)
Jouk Jansen40322e12004-04-05 08:50:36 +00001027{
1028 switch (*(*inst)++) {
1029 case FACE_FRONT:
1030 return 0;
1031
1032 case FACE_BACK:
1033 return 1;
1034 }
1035 return 0;
1036}
1037
1038
1039/**
1040 * Given a matrix and a modifier token on the binary array, return tokens
1041 * that _mesa_fetch_state() [program.c] can understand.
1042 *
1043 * \param matrix - the matrix we are talking about
1044 * \param matrix_idx - the index of the matrix we have (for texture & program matricies)
1045 * \param matrix_modifier - the matrix modifier (trans, inv, etc)
1046 * \return 0 on sucess, 1 on failure
1047 */
1048static GLuint
Brian Paula088f162006-09-05 23:08:51 +00001049parse_matrix (GLcontext * ctx, const GLubyte ** inst, struct arb_program *Program,
Jouk Jansen40322e12004-04-05 08:50:36 +00001050 GLint * matrix, GLint * matrix_idx, GLint * matrix_modifier)
1051{
1052 GLubyte mat = *(*inst)++;
1053
1054 *matrix_idx = 0;
1055
1056 switch (mat) {
1057 case MATRIX_MODELVIEW:
Brian65319522007-02-21 11:08:21 -07001058 *matrix = STATE_MODELVIEW_MATRIX;
Jouk Jansen40322e12004-04-05 08:50:36 +00001059 *matrix_idx = parse_integer (inst, Program);
1060 if (*matrix_idx > 0) {
Brian Paula088f162006-09-05 23:08:51 +00001061 program_error(ctx, Program->Position,
1062 "ARB_vertex_blend not supported");
Jouk Jansen40322e12004-04-05 08:50:36 +00001063 return 1;
1064 }
1065 break;
1066
1067 case MATRIX_PROJECTION:
Brian65319522007-02-21 11:08:21 -07001068 *matrix = STATE_PROJECTION_MATRIX;
Jouk Jansen40322e12004-04-05 08:50:36 +00001069 break;
1070
1071 case MATRIX_MVP:
Brian65319522007-02-21 11:08:21 -07001072 *matrix = STATE_MVP_MATRIX;
Jouk Jansen40322e12004-04-05 08:50:36 +00001073 break;
1074
1075 case MATRIX_TEXTURE:
Brian65319522007-02-21 11:08:21 -07001076 *matrix = STATE_TEXTURE_MATRIX;
Jouk Jansen40322e12004-04-05 08:50:36 +00001077 *matrix_idx = parse_integer (inst, Program);
1078 if (*matrix_idx >= (GLint) ctx->Const.MaxTextureUnits) {
Brian Paula088f162006-09-05 23:08:51 +00001079 program_error(ctx, Program->Position, "Invalid Texture Unit");
1080 /* bad *matrix_id */
Jouk Jansen40322e12004-04-05 08:50:36 +00001081 return 1;
1082 }
1083 break;
1084
1085 /* This is not currently supported (ARB_matrix_palette) */
1086 case MATRIX_PALETTE:
1087 *matrix_idx = parse_integer (inst, Program);
Brian Paula088f162006-09-05 23:08:51 +00001088 program_error(ctx, Program->Position,
1089 "ARB_matrix_palette not supported");
Jouk Jansen40322e12004-04-05 08:50:36 +00001090 return 1;
1091 break;
1092
1093 case MATRIX_PROGRAM:
Brian65319522007-02-21 11:08:21 -07001094 *matrix = STATE_PROGRAM_MATRIX;
Jouk Jansen40322e12004-04-05 08:50:36 +00001095 *matrix_idx = parse_integer (inst, Program);
1096 if (*matrix_idx >= (GLint) ctx->Const.MaxProgramMatrices) {
Brian Paula088f162006-09-05 23:08:51 +00001097 program_error(ctx, Program->Position, "Invalid Program Matrix");
1098 /* bad *matrix_idx */
Jouk Jansen40322e12004-04-05 08:50:36 +00001099 return 1;
1100 }
1101 break;
1102 }
1103
1104 switch (*(*inst)++) {
1105 case MATRIX_MODIFIER_IDENTITY:
1106 *matrix_modifier = 0;
1107 break;
1108 case MATRIX_MODIFIER_INVERSE:
1109 *matrix_modifier = STATE_MATRIX_INVERSE;
1110 break;
1111 case MATRIX_MODIFIER_TRANSPOSE:
1112 *matrix_modifier = STATE_MATRIX_TRANSPOSE;
1113 break;
1114 case MATRIX_MODIFIER_INVTRANS:
1115 *matrix_modifier = STATE_MATRIX_INVTRANS;
1116 break;
1117 }
1118
1119 return 0;
1120}
1121
1122
1123/**
1124 * This parses a state string (rather, the binary version of it) into
1125 * a 6-token sequence as described in _mesa_fetch_state() [program.c]
1126 *
1127 * \param inst - the start in the binary arry to start working from
1128 * \param state_tokens - the storage for the 6-token state description
1129 * \return - 0 on sucess, 1 on error
1130 */
1131static GLuint
Brian Paula088f162006-09-05 23:08:51 +00001132parse_state_single_item (GLcontext * ctx, const GLubyte ** inst,
Brianaa9d22a2007-02-23 11:21:03 -07001133 struct arb_program *Program,
1134 gl_state_index state_tokens[STATE_LENGTH])
Jouk Jansen40322e12004-04-05 08:50:36 +00001135{
1136 switch (*(*inst)++) {
1137 case STATE_MATERIAL_PARSER:
1138 state_tokens[0] = STATE_MATERIAL;
1139 state_tokens[1] = parse_face_type (inst);
1140 switch (*(*inst)++) {
1141 case MATERIAL_AMBIENT:
1142 state_tokens[2] = STATE_AMBIENT;
1143 break;
1144 case MATERIAL_DIFFUSE:
1145 state_tokens[2] = STATE_DIFFUSE;
1146 break;
1147 case MATERIAL_SPECULAR:
1148 state_tokens[2] = STATE_SPECULAR;
1149 break;
1150 case MATERIAL_EMISSION:
1151 state_tokens[2] = STATE_EMISSION;
1152 break;
1153 case MATERIAL_SHININESS:
1154 state_tokens[2] = STATE_SHININESS;
1155 break;
1156 }
1157 break;
1158
1159 case STATE_LIGHT_PARSER:
1160 state_tokens[0] = STATE_LIGHT;
1161 state_tokens[1] = parse_integer (inst, Program);
1162
1163 /* Check the value of state_tokens[1] against the # of lights */
1164 if (state_tokens[1] >= (GLint) ctx->Const.MaxLights) {
Brian Paula088f162006-09-05 23:08:51 +00001165 program_error(ctx, Program->Position, "Invalid Light Number");
1166 /* bad state_tokens[1] */
Jouk Jansen40322e12004-04-05 08:50:36 +00001167 return 1;
1168 }
1169
1170 switch (*(*inst)++) {
1171 case LIGHT_AMBIENT:
1172 state_tokens[2] = STATE_AMBIENT;
1173 break;
1174 case LIGHT_DIFFUSE:
1175 state_tokens[2] = STATE_DIFFUSE;
1176 break;
1177 case LIGHT_SPECULAR:
1178 state_tokens[2] = STATE_SPECULAR;
1179 break;
1180 case LIGHT_POSITION:
1181 state_tokens[2] = STATE_POSITION;
1182 break;
1183 case LIGHT_ATTENUATION:
1184 state_tokens[2] = STATE_ATTENUATION;
1185 break;
1186 case LIGHT_HALF:
Brianf958aab2007-02-21 15:23:11 -07001187 state_tokens[2] = STATE_HALF_VECTOR;
Jouk Jansen40322e12004-04-05 08:50:36 +00001188 break;
1189 case LIGHT_SPOT_DIRECTION:
1190 state_tokens[2] = STATE_SPOT_DIRECTION;
1191 break;
1192 }
1193 break;
1194
1195 case STATE_LIGHT_MODEL:
1196 switch (*(*inst)++) {
1197 case LIGHT_MODEL_AMBIENT:
1198 state_tokens[0] = STATE_LIGHTMODEL_AMBIENT;
1199 break;
1200 case LIGHT_MODEL_SCENECOLOR:
1201 state_tokens[0] = STATE_LIGHTMODEL_SCENECOLOR;
1202 state_tokens[1] = parse_face_type (inst);
1203 break;
1204 }
1205 break;
1206
1207 case STATE_LIGHT_PROD:
1208 state_tokens[0] = STATE_LIGHTPROD;
1209 state_tokens[1] = parse_integer (inst, Program);
1210
1211 /* Check the value of state_tokens[1] against the # of lights */
1212 if (state_tokens[1] >= (GLint) ctx->Const.MaxLights) {
Brian Paula088f162006-09-05 23:08:51 +00001213 program_error(ctx, Program->Position, "Invalid Light Number");
1214 /* bad state_tokens[1] */
Jouk Jansen40322e12004-04-05 08:50:36 +00001215 return 1;
1216 }
1217
1218 state_tokens[2] = parse_face_type (inst);
1219 switch (*(*inst)++) {
1220 case LIGHT_PROD_AMBIENT:
1221 state_tokens[3] = STATE_AMBIENT;
1222 break;
1223 case LIGHT_PROD_DIFFUSE:
1224 state_tokens[3] = STATE_DIFFUSE;
1225 break;
1226 case LIGHT_PROD_SPECULAR:
1227 state_tokens[3] = STATE_SPECULAR;
1228 break;
1229 }
1230 break;
1231
1232
1233 case STATE_FOG:
1234 switch (*(*inst)++) {
1235 case FOG_COLOR:
Brianf1390a32007-02-23 17:11:01 -07001236 state_tokens[0] = STATE_FOG_COLOR;
Jouk Jansen40322e12004-04-05 08:50:36 +00001237 break;
1238 case FOG_PARAMS:
Brianf1390a32007-02-23 17:11:01 -07001239 state_tokens[0] = STATE_FOG_PARAMS;
Jouk Jansen40322e12004-04-05 08:50:36 +00001240 break;
1241 }
1242 break;
1243
1244 case STATE_TEX_ENV:
1245 state_tokens[1] = parse_integer (inst, Program);
1246 switch (*(*inst)++) {
1247 case TEX_ENV_COLOR:
1248 state_tokens[0] = STATE_TEXENV_COLOR;
1249 break;
1250 }
1251 break;
1252
1253 case STATE_TEX_GEN:
1254 {
1255 GLuint type, coord;
1256
1257 state_tokens[0] = STATE_TEXGEN;
1258 /*state_tokens[1] = parse_integer (inst, Program);*/ /* Texture Unit */
1259
1260 if (parse_texcoord_num (ctx, inst, Program, &coord))
1261 return 1;
1262 state_tokens[1] = coord;
1263
1264 /* EYE or OBJECT */
Brian7b91d872008-03-27 15:48:54 -06001265 type = *(*inst)++;
Jouk Jansen40322e12004-04-05 08:50:36 +00001266
1267 /* 0 - s, 1 - t, 2 - r, 3 - q */
Brian7b91d872008-03-27 15:48:54 -06001268 coord = *(*inst)++;
Jouk Jansen40322e12004-04-05 08:50:36 +00001269
1270 if (type == TEX_GEN_EYE) {
1271 switch (coord) {
1272 case COMPONENT_X:
1273 state_tokens[2] = STATE_TEXGEN_EYE_S;
1274 break;
1275 case COMPONENT_Y:
1276 state_tokens[2] = STATE_TEXGEN_EYE_T;
1277 break;
1278 case COMPONENT_Z:
1279 state_tokens[2] = STATE_TEXGEN_EYE_R;
1280 break;
1281 case COMPONENT_W:
1282 state_tokens[2] = STATE_TEXGEN_EYE_Q;
1283 break;
Brian7b91d872008-03-27 15:48:54 -06001284 default:
1285 _mesa_problem(ctx, "bad texgen component in "
1286 "parse_state_single_item()");
Jouk Jansen40322e12004-04-05 08:50:36 +00001287 }
1288 }
1289 else {
1290 switch (coord) {
1291 case COMPONENT_X:
1292 state_tokens[2] = STATE_TEXGEN_OBJECT_S;
1293 break;
1294 case COMPONENT_Y:
1295 state_tokens[2] = STATE_TEXGEN_OBJECT_T;
1296 break;
1297 case COMPONENT_Z:
1298 state_tokens[2] = STATE_TEXGEN_OBJECT_R;
1299 break;
1300 case COMPONENT_W:
1301 state_tokens[2] = STATE_TEXGEN_OBJECT_Q;
1302 break;
Brian7b91d872008-03-27 15:48:54 -06001303 default:
1304 _mesa_problem(ctx, "bad texgen component in "
1305 "parse_state_single_item()");
Jouk Jansen40322e12004-04-05 08:50:36 +00001306 }
1307 }
1308 }
1309 break;
1310
1311 case STATE_DEPTH:
1312 switch (*(*inst)++) {
1313 case DEPTH_RANGE:
1314 state_tokens[0] = STATE_DEPTH_RANGE;
1315 break;
1316 }
1317 break;
1318
1319 case STATE_CLIP_PLANE:
1320 state_tokens[0] = STATE_CLIPPLANE;
1321 state_tokens[1] = parse_integer (inst, Program);
Brianaa9d22a2007-02-23 11:21:03 -07001322 if (parse_clipplane_num (ctx, inst, Program,
1323 (GLint *) &state_tokens[1]))
Jouk Jansen40322e12004-04-05 08:50:36 +00001324 return 1;
1325 break;
1326
1327 case STATE_POINT:
Brian7b91d872008-03-27 15:48:54 -06001328 switch (*(*inst)++) {
Jouk Jansen40322e12004-04-05 08:50:36 +00001329 case POINT_SIZE:
Brian776bc9c2007-02-22 09:29:46 -07001330 state_tokens[0] = STATE_POINT_SIZE;
Jouk Jansen40322e12004-04-05 08:50:36 +00001331 break;
1332
1333 case POINT_ATTENUATION:
Brian776bc9c2007-02-22 09:29:46 -07001334 state_tokens[0] = STATE_POINT_ATTENUATION;
Jouk Jansen40322e12004-04-05 08:50:36 +00001335 break;
1336 }
1337 break;
1338
1339 /* XXX: I think this is the correct format for a matrix row */
1340 case STATE_MATRIX_ROWS:
Brianaa9d22a2007-02-23 11:21:03 -07001341 if (parse_matrix(ctx, inst, Program,
1342 (GLint *) &state_tokens[0],
1343 (GLint *) &state_tokens[1],
1344 (GLint *) &state_tokens[4]))
Jouk Jansen40322e12004-04-05 08:50:36 +00001345 return 1;
1346
Brian65319522007-02-21 11:08:21 -07001347 state_tokens[2] = parse_integer (inst, Program); /* The first row to grab */
Jouk Jansen40322e12004-04-05 08:50:36 +00001348
1349 if ((**inst) != 0) { /* Either the last row, 0 */
Brian65319522007-02-21 11:08:21 -07001350 state_tokens[3] = parse_integer (inst, Program);
1351 if (state_tokens[3] < state_tokens[2]) {
Brian Paula088f162006-09-05 23:08:51 +00001352 program_error(ctx, Program->Position,
1353 "Second matrix index less than the first");
1354 /* state_tokens[4] vs. state_tokens[3] */
Jouk Jansen40322e12004-04-05 08:50:36 +00001355 return 1;
1356 }
1357 }
1358 else {
Brian65319522007-02-21 11:08:21 -07001359 state_tokens[3] = state_tokens[2];
Jouk Jansen40322e12004-04-05 08:50:36 +00001360 (*inst)++;
1361 }
1362 break;
1363 }
1364
1365 return 0;
1366}
1367
1368/**
1369 * This parses a state string (rather, the binary version of it) into
1370 * a 6-token similar for the state fetching code in program.c
1371 *
1372 * One might ask, why fetch these parameters into just like you fetch
1373 * state when they are already stored in other places?
1374 *
1375 * Because of array offsets -> We can stick env/local parameters in the
1376 * middle of a parameter array and then index someplace into the array
1377 * when we execute.
1378 *
1379 * One optimization might be to only do this for the cases where the
1380 * env/local parameters end up inside of an array, and leave the
1381 * single parameters (or arrays of pure env/local pareameters) in their
1382 * respective register files.
1383 *
1384 * For ENV parameters, the format is:
1385 * state_tokens[0] = STATE_FRAGMENT_PROGRAM / STATE_VERTEX_PROGRAM
1386 * state_tokens[1] = STATE_ENV
1387 * state_tokens[2] = the parameter index
1388 *
1389 * for LOCAL parameters, the format is:
1390 * state_tokens[0] = STATE_FRAGMENT_PROGRAM / STATE_VERTEX_PROGRAM
1391 * state_tokens[1] = STATE_LOCAL
1392 * state_tokens[2] = the parameter index
1393 *
1394 * \param inst - the start in the binary arry to start working from
1395 * \param state_tokens - the storage for the 6-token state description
1396 * \return - 0 on sucess, 1 on failure
1397 */
1398static GLuint
Brian Paula088f162006-09-05 23:08:51 +00001399parse_program_single_item (GLcontext * ctx, const GLubyte ** inst,
Brianaa9d22a2007-02-23 11:21:03 -07001400 struct arb_program *Program,
1401 gl_state_index state_tokens[STATE_LENGTH])
Jouk Jansen40322e12004-04-05 08:50:36 +00001402{
1403 if (Program->Base.Target == GL_FRAGMENT_PROGRAM_ARB)
1404 state_tokens[0] = STATE_FRAGMENT_PROGRAM;
1405 else
1406 state_tokens[0] = STATE_VERTEX_PROGRAM;
1407
1408
1409 switch (*(*inst)++) {
1410 case PROGRAM_PARAM_ENV:
1411 state_tokens[1] = STATE_ENV;
1412 state_tokens[2] = parse_integer (inst, Program);
1413
1414 /* Check state_tokens[2] against the number of ENV parameters available */
1415 if (((Program->Base.Target == GL_FRAGMENT_PROGRAM_ARB) &&
Brian Paul05051032005-11-01 04:36:33 +00001416 (state_tokens[2] >= (GLint) ctx->Const.FragmentProgram.MaxEnvParams))
Jouk Jansen40322e12004-04-05 08:50:36 +00001417 ||
1418 ((Program->Base.Target == GL_VERTEX_PROGRAM_ARB) &&
Brian Paul05051032005-11-01 04:36:33 +00001419 (state_tokens[2] >= (GLint) ctx->Const.VertexProgram.MaxEnvParams))) {
Brian Paula088f162006-09-05 23:08:51 +00001420 program_error(ctx, Program->Position,
1421 "Invalid Program Env Parameter");
1422 /* bad state_tokens[2] */
Jouk Jansen40322e12004-04-05 08:50:36 +00001423 return 1;
1424 }
1425
1426 break;
1427
1428 case PROGRAM_PARAM_LOCAL:
1429 state_tokens[1] = STATE_LOCAL;
1430 state_tokens[2] = parse_integer (inst, Program);
1431
1432 /* Check state_tokens[2] against the number of LOCAL parameters available */
1433 if (((Program->Base.Target == GL_FRAGMENT_PROGRAM_ARB) &&
Brian Paul05051032005-11-01 04:36:33 +00001434 (state_tokens[2] >= (GLint) ctx->Const.FragmentProgram.MaxLocalParams))
Jouk Jansen40322e12004-04-05 08:50:36 +00001435 ||
1436 ((Program->Base.Target == GL_VERTEX_PROGRAM_ARB) &&
Brian Paul05051032005-11-01 04:36:33 +00001437 (state_tokens[2] >= (GLint) ctx->Const.VertexProgram.MaxLocalParams))) {
Brian Paula088f162006-09-05 23:08:51 +00001438 program_error(ctx, Program->Position,
1439 "Invalid Program Local Parameter");
1440 /* bad state_tokens[2] */
Jouk Jansen40322e12004-04-05 08:50:36 +00001441 return 1;
1442 }
1443 break;
1444 }
1445
1446 return 0;
1447}
1448
1449/**
1450 * For ARB_vertex_program, programs are not allowed to use both an explicit
1451 * vertex attribute and a generic vertex attribute corresponding to the same
1452 * state. See section 2.14.3.1 of the GL_ARB_vertex_program spec.
1453 *
1454 * This will walk our var_cache and make sure that nobody does anything fishy.
1455 *
1456 * \return 0 on sucess, 1 on error
1457 */
1458static GLuint
1459generic_attrib_check(struct var_cache *vc_head)
1460{
1461 int a;
1462 struct var_cache *curr;
1463 GLboolean explicitAttrib[MAX_VERTEX_PROGRAM_ATTRIBS],
1464 genericAttrib[MAX_VERTEX_PROGRAM_ATTRIBS];
1465
1466 for (a=0; a<MAX_VERTEX_PROGRAM_ATTRIBS; a++) {
1467 explicitAttrib[a] = GL_FALSE;
1468 genericAttrib[a] = GL_FALSE;
1469 }
1470
1471 curr = vc_head;
1472 while (curr) {
1473 if (curr->type == vt_attrib) {
1474 if (curr->attrib_is_generic)
Brian Paul18e7c5c2005-10-30 21:46:00 +00001475 genericAttrib[ curr->attrib_binding ] = GL_TRUE;
Jouk Jansen40322e12004-04-05 08:50:36 +00001476 else
Brian Paul18e7c5c2005-10-30 21:46:00 +00001477 explicitAttrib[ curr->attrib_binding ] = GL_TRUE;
Jouk Jansen40322e12004-04-05 08:50:36 +00001478 }
1479
1480 curr = curr->next;
1481 }
1482
1483 for (a=0; a<MAX_VERTEX_PROGRAM_ATTRIBS; a++) {
1484 if ((explicitAttrib[a]) && (genericAttrib[a]))
1485 return 1;
1486 }
1487
1488 return 0;
1489}
1490
1491/**
1492 * This will handle the binding side of an ATTRIB var declaration
1493 *
Brian Paul18e7c5c2005-10-30 21:46:00 +00001494 * \param inputReg returns the input register index, one of the
1495 * VERT_ATTRIB_* or FRAG_ATTRIB_* values.
Brian Paula088f162006-09-05 23:08:51 +00001496 * \return returns 0 on success, 1 on error
Jouk Jansen40322e12004-04-05 08:50:36 +00001497 */
1498static GLuint
Brian Paula088f162006-09-05 23:08:51 +00001499parse_attrib_binding(GLcontext * ctx, const GLubyte ** inst,
Brian Paul18e7c5c2005-10-30 21:46:00 +00001500 struct arb_program *Program,
1501 GLuint *inputReg, GLuint *is_generic)
Jouk Jansen40322e12004-04-05 08:50:36 +00001502{
Jouk Jansen40322e12004-04-05 08:50:36 +00001503 GLint err = 0;
1504
1505 *is_generic = 0;
Brian Paul18e7c5c2005-10-30 21:46:00 +00001506
Jouk Jansen40322e12004-04-05 08:50:36 +00001507 if (Program->Base.Target == GL_FRAGMENT_PROGRAM_ARB) {
1508 switch (*(*inst)++) {
1509 case FRAGMENT_ATTRIB_COLOR:
Brian Paul18e7c5c2005-10-30 21:46:00 +00001510 {
1511 GLint coord;
1512 err = parse_color_type (ctx, inst, Program, &coord);
1513 *inputReg = FRAG_ATTRIB_COL0 + coord;
1514 }
Jouk Jansen40322e12004-04-05 08:50:36 +00001515 break;
Jouk Jansen40322e12004-04-05 08:50:36 +00001516 case FRAGMENT_ATTRIB_TEXCOORD:
Brian Paul18e7c5c2005-10-30 21:46:00 +00001517 {
Brian8fa6f732007-02-01 09:24:41 -07001518 GLuint texcoord = 0;
Brian Paul18e7c5c2005-10-30 21:46:00 +00001519 err = parse_texcoord_num (ctx, inst, Program, &texcoord);
1520 *inputReg = FRAG_ATTRIB_TEX0 + texcoord;
1521 }
Jouk Jansen40322e12004-04-05 08:50:36 +00001522 break;
Jouk Jansen40322e12004-04-05 08:50:36 +00001523 case FRAGMENT_ATTRIB_FOGCOORD:
Brian Paul18e7c5c2005-10-30 21:46:00 +00001524 *inputReg = FRAG_ATTRIB_FOGC;
Jouk Jansen40322e12004-04-05 08:50:36 +00001525 break;
Jouk Jansen40322e12004-04-05 08:50:36 +00001526 case FRAGMENT_ATTRIB_POSITION:
Brian Paul18e7c5c2005-10-30 21:46:00 +00001527 *inputReg = FRAG_ATTRIB_WPOS;
Jouk Jansen40322e12004-04-05 08:50:36 +00001528 break;
Jouk Jansen40322e12004-04-05 08:50:36 +00001529 default:
1530 err = 1;
1531 break;
1532 }
1533 }
1534 else {
1535 switch (*(*inst)++) {
1536 case VERTEX_ATTRIB_POSITION:
Brian Paul18e7c5c2005-10-30 21:46:00 +00001537 *inputReg = VERT_ATTRIB_POS;
Jouk Jansen40322e12004-04-05 08:50:36 +00001538 break;
1539
1540 case VERTEX_ATTRIB_WEIGHT:
1541 {
1542 GLint weight;
Jouk Jansen40322e12004-04-05 08:50:36 +00001543 err = parse_weight_num (ctx, inst, Program, &weight);
Brian Paul18e7c5c2005-10-30 21:46:00 +00001544 *inputReg = VERT_ATTRIB_WEIGHT;
Brian Paul3a557502006-09-05 23:15:29 +00001545#if 1
1546 /* hack for Warcraft (see bug 8060) */
1547 _mesa_warning(ctx, "Application error: vertex program uses 'vertex.weight' but GL_ARB_vertex_blend not supported.");
Brian Pauld9aebd82006-09-06 05:03:47 +00001548 break;
Brian Paul3a557502006-09-05 23:15:29 +00001549#else
Brian Paula088f162006-09-05 23:08:51 +00001550 program_error(ctx, Program->Position,
1551 "ARB_vertex_blend not supported");
Brian Pauld9aebd82006-09-06 05:03:47 +00001552 return 1;
Brian Paul3a557502006-09-05 23:15:29 +00001553#endif
Jouk Jansen40322e12004-04-05 08:50:36 +00001554 }
Jouk Jansen40322e12004-04-05 08:50:36 +00001555
1556 case VERTEX_ATTRIB_NORMAL:
Brian Paul18e7c5c2005-10-30 21:46:00 +00001557 *inputReg = VERT_ATTRIB_NORMAL;
Jouk Jansen40322e12004-04-05 08:50:36 +00001558 break;
1559
1560 case VERTEX_ATTRIB_COLOR:
1561 {
1562 GLint color;
Jouk Jansen40322e12004-04-05 08:50:36 +00001563 err = parse_color_type (ctx, inst, Program, &color);
1564 if (color) {
Brian Paul18e7c5c2005-10-30 21:46:00 +00001565 *inputReg = VERT_ATTRIB_COLOR1;
Jouk Jansen40322e12004-04-05 08:50:36 +00001566 }
1567 else {
Brian Paul18e7c5c2005-10-30 21:46:00 +00001568 *inputReg = VERT_ATTRIB_COLOR0;
Jouk Jansen40322e12004-04-05 08:50:36 +00001569 }
1570 }
1571 break;
1572
1573 case VERTEX_ATTRIB_FOGCOORD:
Brian Paul18e7c5c2005-10-30 21:46:00 +00001574 *inputReg = VERT_ATTRIB_FOG;
Jouk Jansen40322e12004-04-05 08:50:36 +00001575 break;
1576
1577 case VERTEX_ATTRIB_TEXCOORD:
1578 {
Brian8fa6f732007-02-01 09:24:41 -07001579 GLuint unit = 0;
Jouk Jansen40322e12004-04-05 08:50:36 +00001580 err = parse_texcoord_num (ctx, inst, Program, &unit);
Brian Paul18e7c5c2005-10-30 21:46:00 +00001581 *inputReg = VERT_ATTRIB_TEX0 + unit;
Jouk Jansen40322e12004-04-05 08:50:36 +00001582 }
1583 break;
1584
Jouk Jansen40322e12004-04-05 08:50:36 +00001585 case VERTEX_ATTRIB_MATRIXINDEX:
Brian Paul18e7c5c2005-10-30 21:46:00 +00001586 /* Not supported at this time */
1587 {
1588 const char *msg = "ARB_palette_matrix not supported";
1589 parse_integer (inst, Program);
Brian Paula088f162006-09-05 23:08:51 +00001590 program_error(ctx, Program->Position, msg);
Brian Paul18e7c5c2005-10-30 21:46:00 +00001591 }
Jouk Jansen40322e12004-04-05 08:50:36 +00001592 return 1;
Jouk Jansen40322e12004-04-05 08:50:36 +00001593
1594 case VERTEX_ATTRIB_GENERIC:
1595 {
1596 GLuint attrib;
Tilman Sauerbeck6c334752006-06-28 16:26:20 +00001597 err = parse_generic_attrib_num(ctx, inst, Program, &attrib);
Brian Paula088f162006-09-05 23:08:51 +00001598 if (!err) {
Jouk Jansen40322e12004-04-05 08:50:36 +00001599 *is_generic = 1;
Brian Paul095c6692006-04-25 00:21:32 +00001600 /* Add VERT_ATTRIB_GENERIC0 here because ARB_vertex_program's
1601 * attributes do not alias the conventional vertex
1602 * attributes.
1603 */
1604 if (attrib > 0)
1605 *inputReg = attrib + VERT_ATTRIB_GENERIC0;
Brian Paul919f6a02006-05-29 14:37:56 +00001606 else
1607 *inputReg = 0;
Jouk Jansen40322e12004-04-05 08:50:36 +00001608 }
1609 }
1610 break;
1611
1612 default:
1613 err = 1;
1614 break;
1615 }
1616 }
1617
Jouk Jansen40322e12004-04-05 08:50:36 +00001618 if (err) {
Brian Paula088f162006-09-05 23:08:51 +00001619 program_error(ctx, Program->Position, "Bad attribute binding");
Jouk Jansen40322e12004-04-05 08:50:36 +00001620 }
Jouk Jansen40322e12004-04-05 08:50:36 +00001621
1622 return err;
1623}
1624
Brian Paul7aebaf32005-10-30 21:23:23 +00001625
Jouk Jansen40322e12004-04-05 08:50:36 +00001626/**
1627 * This translates between a binary token for an output variable type
1628 * and the mesa token for the same thing.
1629 *
Brian Paul7aebaf32005-10-30 21:23:23 +00001630 * \param inst The parsed tokens
1631 * \param outputReg Returned index/number of the output register,
Brian Paul90ebb582005-11-02 18:06:12 +00001632 * one of the VERT_RESULT_* or FRAG_RESULT_* values.
Jouk Jansen40322e12004-04-05 08:50:36 +00001633 */
1634static GLuint
Brian Paula088f162006-09-05 23:08:51 +00001635parse_result_binding(GLcontext *ctx, const GLubyte **inst,
Brian Paul7aebaf32005-10-30 21:23:23 +00001636 GLuint *outputReg, struct arb_program *Program)
Jouk Jansen40322e12004-04-05 08:50:36 +00001637{
Brian Paul7aebaf32005-10-30 21:23:23 +00001638 const GLubyte token = *(*inst)++;
Jouk Jansen40322e12004-04-05 08:50:36 +00001639
Brian Paul7aebaf32005-10-30 21:23:23 +00001640 switch (token) {
Jouk Jansen40322e12004-04-05 08:50:36 +00001641 case FRAGMENT_RESULT_COLOR:
Jouk Jansen40322e12004-04-05 08:50:36 +00001642 if (Program->Base.Target == GL_FRAGMENT_PROGRAM_ARB) {
Brian Paul7aebaf32005-10-30 21:23:23 +00001643 GLuint out_color;
1644
Brian Paulbe76b7f2004-10-04 14:40:05 +00001645 /* This gets result of the color buffer we're supposed to
Brian Paul7aebaf32005-10-30 21:23:23 +00001646 * draw into. This pertains to GL_ARB_draw_buffers.
Brian Paulbe76b7f2004-10-04 14:40:05 +00001647 */
1648 parse_output_color_num(ctx, inst, Program, &out_color);
Brian Paul7aebaf32005-10-30 21:23:23 +00001649 ASSERT(out_color < MAX_DRAW_BUFFERS);
Brian Paul90ebb582005-11-02 18:06:12 +00001650 *outputReg = FRAG_RESULT_COLR;
Jouk Jansen40322e12004-04-05 08:50:36 +00001651 }
Jouk Jansen40322e12004-04-05 08:50:36 +00001652 else {
Brian Paul7aebaf32005-10-30 21:23:23 +00001653 /* for vtx programs, this is VERTEX_RESULT_POSITION */
1654 *outputReg = VERT_RESULT_HPOS;
Jouk Jansen40322e12004-04-05 08:50:36 +00001655 }
1656 break;
1657
1658 case FRAGMENT_RESULT_DEPTH:
Jouk Jansen40322e12004-04-05 08:50:36 +00001659 if (Program->Base.Target == GL_FRAGMENT_PROGRAM_ARB) {
Brian Paul7aebaf32005-10-30 21:23:23 +00001660 /* for frag programs, this is FRAGMENT_RESULT_DEPTH */
Brian Paul90ebb582005-11-02 18:06:12 +00001661 *outputReg = FRAG_RESULT_DEPR;
Jouk Jansen40322e12004-04-05 08:50:36 +00001662 }
Jouk Jansen40322e12004-04-05 08:50:36 +00001663 else {
Brian Paul7aebaf32005-10-30 21:23:23 +00001664 /* for vtx programs, this is VERTEX_RESULT_COLOR */
Jouk Jansen40322e12004-04-05 08:50:36 +00001665 GLint color_type;
1666 GLuint face_type = parse_face_type(inst);
Brian Paul7aebaf32005-10-30 21:23:23 +00001667 GLint err = parse_color_type(ctx, inst, Program, &color_type);
1668 if (err)
1669 return 1;
Jouk Jansen40322e12004-04-05 08:50:36 +00001670
Jouk Jansen40322e12004-04-05 08:50:36 +00001671 if (face_type) {
Brian Paul7aebaf32005-10-30 21:23:23 +00001672 /* back face */
Jouk Jansen40322e12004-04-05 08:50:36 +00001673 if (color_type) {
Brian Paul7aebaf32005-10-30 21:23:23 +00001674 *outputReg = VERT_RESULT_BFC1; /* secondary color */
Jouk Jansen40322e12004-04-05 08:50:36 +00001675 }
Jouk Jansen40322e12004-04-05 08:50:36 +00001676 else {
Brian Paul7aebaf32005-10-30 21:23:23 +00001677 *outputReg = VERT_RESULT_BFC0; /* primary color */
Jouk Jansen40322e12004-04-05 08:50:36 +00001678 }
1679 }
Jouk Jansen40322e12004-04-05 08:50:36 +00001680 else {
Brian Paul7aebaf32005-10-30 21:23:23 +00001681 /* front face */
Jouk Jansen40322e12004-04-05 08:50:36 +00001682 if (color_type) {
Brian Paul7aebaf32005-10-30 21:23:23 +00001683 *outputReg = VERT_RESULT_COL1; /* secondary color */
Jouk Jansen40322e12004-04-05 08:50:36 +00001684 }
1685 /* primary color */
1686 else {
Brian Paul7aebaf32005-10-30 21:23:23 +00001687 *outputReg = VERT_RESULT_COL0; /* primary color */
Jouk Jansen40322e12004-04-05 08:50:36 +00001688 }
1689 }
1690 }
1691 break;
1692
1693 case VERTEX_RESULT_FOGCOORD:
Brian Paul7aebaf32005-10-30 21:23:23 +00001694 *outputReg = VERT_RESULT_FOGC;
Jouk Jansen40322e12004-04-05 08:50:36 +00001695 break;
1696
1697 case VERTEX_RESULT_POINTSIZE:
Brian Paul7aebaf32005-10-30 21:23:23 +00001698 *outputReg = VERT_RESULT_PSIZ;
Jouk Jansen40322e12004-04-05 08:50:36 +00001699 break;
1700
1701 case VERTEX_RESULT_TEXCOORD:
Brian Paul7aebaf32005-10-30 21:23:23 +00001702 {
1703 GLuint unit;
1704 if (parse_texcoord_num (ctx, inst, Program, &unit))
1705 return 1;
1706 *outputReg = VERT_RESULT_TEX0 + unit;
1707 }
Jouk Jansen40322e12004-04-05 08:50:36 +00001708 break;
1709 }
1710
Brian Paulde997602005-11-12 17:53:14 +00001711 Program->Base.OutputsWritten |= (1 << *outputReg);
Jouk Jansen40322e12004-04-05 08:50:36 +00001712
1713 return 0;
1714}
1715
Brian Paul7aebaf32005-10-30 21:23:23 +00001716
Jouk Jansen40322e12004-04-05 08:50:36 +00001717/**
1718 * This handles the declaration of ATTRIB variables
1719 *
1720 * XXX: Still needs
1721 * parse_vert_attrib_binding(), or something like that
1722 *
1723 * \return 0 on sucess, 1 on error
1724 */
1725static GLint
Brian Paula088f162006-09-05 23:08:51 +00001726parse_attrib (GLcontext * ctx, const GLubyte ** inst, struct var_cache **vc_head,
Jouk Jansen40322e12004-04-05 08:50:36 +00001727 struct arb_program *Program)
1728{
1729 GLuint found;
Jouk Jansen40322e12004-04-05 08:50:36 +00001730 struct var_cache *attrib_var;
1731
1732 attrib_var = parse_string (inst, vc_head, Program, &found);
1733 Program->Position = parse_position (inst);
1734 if (found) {
Brian50a20d42008-03-27 15:51:07 -06001735 program_error2(ctx, Program->Position,
1736 "Duplicate variable declaration",
1737 (char *) attrib_var->name);
Jouk Jansen40322e12004-04-05 08:50:36 +00001738 return 1;
1739 }
1740
1741 attrib_var->type = vt_attrib;
1742
Brian Paul7aebaf32005-10-30 21:23:23 +00001743 if (parse_attrib_binding(ctx, inst, Program, &attrib_var->attrib_binding,
Brian Paul7aebaf32005-10-30 21:23:23 +00001744 &attrib_var->attrib_is_generic))
1745 return 1;
Jouk Jansen40322e12004-04-05 08:50:36 +00001746
Brian Paul7aebaf32005-10-30 21:23:23 +00001747 if (generic_attrib_check(*vc_head)) {
Brian Paula088f162006-09-05 23:08:51 +00001748 program_error(ctx, Program->Position,
1749 "Cannot use both a generic vertex attribute "
1750 "and a specific attribute of the same type");
Brian Paul7aebaf32005-10-30 21:23:23 +00001751 return 1;
Jouk Jansen40322e12004-04-05 08:50:36 +00001752 }
1753
1754 Program->Base.NumAttributes++;
1755 return 0;
1756}
1757
1758/**
1759 * \param use -- TRUE if we're called when declaring implicit parameters,
1760 * FALSE if we're declaraing variables. This has to do with
1761 * if we get a signed or unsigned float for scalar constants
1762 */
1763static GLuint
Brian Paula088f162006-09-05 23:08:51 +00001764parse_param_elements (GLcontext * ctx, const GLubyte ** inst,
Jouk Jansen40322e12004-04-05 08:50:36 +00001765 struct var_cache *param_var,
1766 struct arb_program *Program, GLboolean use)
1767{
1768 GLint idx;
Brian Paul7aebaf32005-10-30 21:23:23 +00001769 GLuint err = 0;
Briana0720942008-03-27 15:52:00 -06001770 gl_state_index state_tokens[STATE_LENGTH] = {0, 0, 0, 0, 0};
Jouk Jansen40322e12004-04-05 08:50:36 +00001771 GLfloat const_values[4];
1772
Jouk Jansen40322e12004-04-05 08:50:36 +00001773 switch (*(*inst)++) {
1774 case PARAM_STATE_ELEMENT:
Jouk Jansen40322e12004-04-05 08:50:36 +00001775 if (parse_state_single_item (ctx, inst, Program, state_tokens))
1776 return 1;
1777
1778 /* If we adding STATE_MATRIX that has multiple rows, we need to
1779 * unroll it and call _mesa_add_state_reference() for each row
1780 */
Brian65319522007-02-21 11:08:21 -07001781 if ((state_tokens[0] == STATE_MODELVIEW_MATRIX ||
1782 state_tokens[0] == STATE_PROJECTION_MATRIX ||
1783 state_tokens[0] == STATE_MVP_MATRIX ||
1784 state_tokens[0] == STATE_TEXTURE_MATRIX ||
1785 state_tokens[0] == STATE_PROGRAM_MATRIX)
1786 && (state_tokens[2] != state_tokens[3])) {
Jouk Jansen40322e12004-04-05 08:50:36 +00001787 GLint row;
Brian65319522007-02-21 11:08:21 -07001788 const GLint first_row = state_tokens[2];
1789 const GLint last_row = state_tokens[3];
Jouk Jansen40322e12004-04-05 08:50:36 +00001790
1791 for (row = first_row; row <= last_row; row++) {
Brian65319522007-02-21 11:08:21 -07001792 state_tokens[2] = state_tokens[3] = row;
Jouk Jansen40322e12004-04-05 08:50:36 +00001793
Brian Paulde997602005-11-12 17:53:14 +00001794 idx = _mesa_add_state_reference(Program->Base.Parameters,
1795 state_tokens);
Jouk Jansen40322e12004-04-05 08:50:36 +00001796 if (param_var->param_binding_begin == ~0U)
1797 param_var->param_binding_begin = idx;
1798 param_var->param_binding_length++;
1799 Program->Base.NumParameters++;
1800 }
1801 }
1802 else {
Brian Paulde997602005-11-12 17:53:14 +00001803 idx = _mesa_add_state_reference(Program->Base.Parameters,
1804 state_tokens);
Jouk Jansen40322e12004-04-05 08:50:36 +00001805 if (param_var->param_binding_begin == ~0U)
1806 param_var->param_binding_begin = idx;
1807 param_var->param_binding_length++;
1808 Program->Base.NumParameters++;
1809 }
1810 break;
1811
1812 case PARAM_PROGRAM_ELEMENT:
Jouk Jansen40322e12004-04-05 08:50:36 +00001813 if (parse_program_single_item (ctx, inst, Program, state_tokens))
1814 return 1;
Brian Paulde997602005-11-12 17:53:14 +00001815 idx = _mesa_add_state_reference (Program->Base.Parameters, state_tokens);
Jouk Jansen40322e12004-04-05 08:50:36 +00001816 if (param_var->param_binding_begin == ~0U)
1817 param_var->param_binding_begin = idx;
1818 param_var->param_binding_length++;
1819 Program->Base.NumParameters++;
1820
1821 /* Check if there is more: 0 -> we're done, else its an integer */
1822 if (**inst) {
1823 GLuint out_of_range, new_idx;
1824 GLuint start_idx = state_tokens[2] + 1;
1825 GLuint end_idx = parse_integer (inst, Program);
1826
1827 out_of_range = 0;
1828 if (Program->Base.Target == GL_FRAGMENT_PROGRAM_ARB) {
1829 if (((state_tokens[1] == STATE_ENV)
Brian Paul05051032005-11-01 04:36:33 +00001830 && (end_idx >= ctx->Const.FragmentProgram.MaxEnvParams))
Jouk Jansen40322e12004-04-05 08:50:36 +00001831 || ((state_tokens[1] == STATE_LOCAL)
1832 && (end_idx >=
Brian Paul05051032005-11-01 04:36:33 +00001833 ctx->Const.FragmentProgram.MaxLocalParams)))
Jouk Jansen40322e12004-04-05 08:50:36 +00001834 out_of_range = 1;
1835 }
1836 else {
1837 if (((state_tokens[1] == STATE_ENV)
Brian Paul05051032005-11-01 04:36:33 +00001838 && (end_idx >= ctx->Const.VertexProgram.MaxEnvParams))
Jouk Jansen40322e12004-04-05 08:50:36 +00001839 || ((state_tokens[1] == STATE_LOCAL)
1840 && (end_idx >=
Brian Paul05051032005-11-01 04:36:33 +00001841 ctx->Const.VertexProgram.MaxLocalParams)))
Jouk Jansen40322e12004-04-05 08:50:36 +00001842 out_of_range = 1;
1843 }
1844 if (out_of_range) {
Brian Paula088f162006-09-05 23:08:51 +00001845 program_error(ctx, Program->Position,
1846 "Invalid Program Parameter"); /*end_idx*/
Jouk Jansen40322e12004-04-05 08:50:36 +00001847 return 1;
1848 }
1849
1850 for (new_idx = start_idx; new_idx <= end_idx; new_idx++) {
1851 state_tokens[2] = new_idx;
Brian Paulde997602005-11-12 17:53:14 +00001852 idx = _mesa_add_state_reference(Program->Base.Parameters,
1853 state_tokens);
Jouk Jansen40322e12004-04-05 08:50:36 +00001854 param_var->param_binding_length++;
1855 Program->Base.NumParameters++;
1856 }
1857 }
Brian Paul7aebaf32005-10-30 21:23:23 +00001858 else {
1859 (*inst)++;
1860 }
Jouk Jansen40322e12004-04-05 08:50:36 +00001861 break;
1862
1863 case PARAM_CONSTANT:
Brian7cbfe8c2008-01-18 12:45:55 -07001864 /* parsing something like {1.0, 2.0, 3.0, 4.0} */
Jouk Jansen40322e12004-04-05 08:50:36 +00001865 parse_constant (inst, const_values, Program, use);
Brian Paulde997602005-11-12 17:53:14 +00001866 idx = _mesa_add_named_constant(Program->Base.Parameters,
1867 (char *) param_var->name,
Brian Paul0c6723a2006-11-15 23:38:02 +00001868 const_values, 4);
Jouk Jansen40322e12004-04-05 08:50:36 +00001869 if (param_var->param_binding_begin == ~0U)
1870 param_var->param_binding_begin = idx;
Brian7cbfe8c2008-01-18 12:45:55 -07001871 param_var->param_binding_type = PROGRAM_CONSTANT;
Jouk Jansen40322e12004-04-05 08:50:36 +00001872 param_var->param_binding_length++;
1873 Program->Base.NumParameters++;
1874 break;
1875
1876 default:
Brian Paula088f162006-09-05 23:08:51 +00001877 program_error(ctx, Program->Position,
1878 "Unexpected token (in parse_param_elements())");
Jouk Jansen40322e12004-04-05 08:50:36 +00001879 return 1;
1880 }
1881
1882 /* Make sure we haven't blown past our parameter limits */
1883 if (((Program->Base.Target == GL_VERTEX_PROGRAM_ARB) &&
1884 (Program->Base.NumParameters >=
Brian Paul05051032005-11-01 04:36:33 +00001885 ctx->Const.VertexProgram.MaxLocalParams))
Jouk Jansen40322e12004-04-05 08:50:36 +00001886 || ((Program->Base.Target == GL_FRAGMENT_PROGRAM_ARB)
1887 && (Program->Base.NumParameters >=
Brian Paul05051032005-11-01 04:36:33 +00001888 ctx->Const.FragmentProgram.MaxLocalParams))) {
Brian Paula088f162006-09-05 23:08:51 +00001889 program_error(ctx, Program->Position, "Too many parameter variables");
Jouk Jansen40322e12004-04-05 08:50:36 +00001890 return 1;
1891 }
1892
1893 return err;
1894}
1895
Brian Paul7aebaf32005-10-30 21:23:23 +00001896
Jouk Jansen40322e12004-04-05 08:50:36 +00001897/**
1898 * This picks out PARAM program parameter bindings.
1899 *
1900 * XXX: This needs to be stressed & tested
1901 *
1902 * \return 0 on sucess, 1 on error
1903 */
1904static GLuint
Brian Paula088f162006-09-05 23:08:51 +00001905parse_param (GLcontext * ctx, const GLubyte ** inst, struct var_cache **vc_head,
Jouk Jansen40322e12004-04-05 08:50:36 +00001906 struct arb_program *Program)
1907{
Brian Paulbd997cd2004-07-20 21:12:56 +00001908 GLuint found, err;
1909 GLint specified_length;
Jouk Jansen40322e12004-04-05 08:50:36 +00001910 struct var_cache *param_var;
1911
1912 err = 0;
1913 param_var = parse_string (inst, vc_head, Program, &found);
1914 Program->Position = parse_position (inst);
1915
1916 if (found) {
Brian50a20d42008-03-27 15:51:07 -06001917 program_error2(ctx, Program->Position,
1918 "Duplicate variable declaration",
1919 (char *) param_var->name);
Jouk Jansen40322e12004-04-05 08:50:36 +00001920 return 1;
1921 }
1922
1923 specified_length = parse_integer (inst, Program);
1924
1925 if (specified_length < 0) {
Brian Paula088f162006-09-05 23:08:51 +00001926 program_error(ctx, Program->Position, "Negative parameter array length");
Jouk Jansen40322e12004-04-05 08:50:36 +00001927 return 1;
1928 }
1929
1930 param_var->type = vt_param;
1931 param_var->param_binding_length = 0;
1932
1933 /* Right now, everything is shoved into the main state register file.
1934 *
1935 * In the future, it would be nice to leave things ENV/LOCAL params
1936 * in their respective register files, if possible
1937 */
1938 param_var->param_binding_type = PROGRAM_STATE_VAR;
1939
1940 /* Remember to:
1941 * * - add each guy to the parameter list
1942 * * - increment the param_var->param_binding_len
1943 * * - store the param_var->param_binding_begin for the first one
1944 * * - compare the actual len to the specified len at the end
1945 */
1946 while (**inst != PARAM_NULL) {
1947 if (parse_param_elements (ctx, inst, param_var, Program, GL_FALSE))
1948 return 1;
1949 }
1950
1951 /* Test array length here! */
1952 if (specified_length) {
Brian Paula6c423d2004-08-25 15:59:48 +00001953 if (specified_length != (int)param_var->param_binding_length) {
Brian Paula088f162006-09-05 23:08:51 +00001954 program_error(ctx, Program->Position,
1955 "Declared parameter array length does not match parameter list");
Jouk Jansen40322e12004-04-05 08:50:36 +00001956 }
1957 }
1958
1959 (*inst)++;
1960
1961 return 0;
1962}
1963
1964/**
1965 *
1966 */
1967static GLuint
Brian Paula088f162006-09-05 23:08:51 +00001968parse_param_use (GLcontext * ctx, const GLubyte ** inst, struct var_cache **vc_head,
Jouk Jansen40322e12004-04-05 08:50:36 +00001969 struct arb_program *Program, struct var_cache **new_var)
1970{
1971 struct var_cache *param_var;
1972
1973 /* First, insert a dummy entry into the var_cache */
1974 var_cache_create (&param_var);
Brian Paul6a769d92006-04-28 15:42:15 +00001975 param_var->name = (const GLubyte *) " ";
Jouk Jansen40322e12004-04-05 08:50:36 +00001976 param_var->type = vt_param;
1977
1978 param_var->param_binding_length = 0;
1979 /* Don't fill in binding_begin; We use the default value of -1
1980 * to tell if its already initialized, elsewhere.
1981 *
1982 * param_var->param_binding_begin = 0;
1983 */
1984 param_var->param_binding_type = PROGRAM_STATE_VAR;
1985
1986 var_cache_append (vc_head, param_var);
1987
1988 /* Then fill it with juicy parameter goodness */
1989 if (parse_param_elements (ctx, inst, param_var, Program, GL_TRUE))
1990 return 1;
1991
1992 *new_var = param_var;
1993
1994 return 0;
1995}
1996
1997
1998/**
1999 * This handles the declaration of TEMP variables
2000 *
2001 * \return 0 on sucess, 1 on error
2002 */
2003static GLuint
Brian Paula088f162006-09-05 23:08:51 +00002004parse_temp (GLcontext * ctx, const GLubyte ** inst, struct var_cache **vc_head,
Jouk Jansen40322e12004-04-05 08:50:36 +00002005 struct arb_program *Program)
2006{
2007 GLuint found;
2008 struct var_cache *temp_var;
Jouk Jansen40322e12004-04-05 08:50:36 +00002009
2010 while (**inst != 0) {
2011 temp_var = parse_string (inst, vc_head, Program, &found);
2012 Program->Position = parse_position (inst);
2013 if (found) {
Brian50a20d42008-03-27 15:51:07 -06002014 program_error2(ctx, Program->Position,
2015 "Duplicate variable declaration",
2016 (char *) temp_var->name);
Jouk Jansen40322e12004-04-05 08:50:36 +00002017 return 1;
2018 }
2019
2020 temp_var->type = vt_temp;
2021
2022 if (((Program->Base.Target == GL_FRAGMENT_PROGRAM_ARB) &&
2023 (Program->Base.NumTemporaries >=
Brian Paul05051032005-11-01 04:36:33 +00002024 ctx->Const.FragmentProgram.MaxTemps))
Jouk Jansen40322e12004-04-05 08:50:36 +00002025 || ((Program->Base.Target == GL_VERTEX_PROGRAM_ARB)
2026 && (Program->Base.NumTemporaries >=
Brian Paul05051032005-11-01 04:36:33 +00002027 ctx->Const.VertexProgram.MaxTemps))) {
Brian Paula088f162006-09-05 23:08:51 +00002028 program_error(ctx, Program->Position,
2029 "Too many TEMP variables declared");
Jouk Jansen40322e12004-04-05 08:50:36 +00002030 return 1;
2031 }
2032
2033 temp_var->temp_binding = Program->Base.NumTemporaries;
2034 Program->Base.NumTemporaries++;
2035 }
2036 (*inst)++;
2037
2038 return 0;
2039}
2040
2041/**
2042 * This handles variables of the OUTPUT variety
2043 *
2044 * \return 0 on sucess, 1 on error
2045 */
2046static GLuint
Brian Paula088f162006-09-05 23:08:51 +00002047parse_output (GLcontext * ctx, const GLubyte ** inst, struct var_cache **vc_head,
Jouk Jansen40322e12004-04-05 08:50:36 +00002048 struct arb_program *Program)
2049{
2050 GLuint found;
2051 struct var_cache *output_var;
Brian Paul7aebaf32005-10-30 21:23:23 +00002052 GLuint err;
Jouk Jansen40322e12004-04-05 08:50:36 +00002053
2054 output_var = parse_string (inst, vc_head, Program, &found);
2055 Program->Position = parse_position (inst);
2056 if (found) {
Brian50a20d42008-03-27 15:51:07 -06002057 program_error2(ctx, Program->Position,
2058 "Duplicate variable declaration",
2059 (char *) output_var->name);
Jouk Jansen40322e12004-04-05 08:50:36 +00002060 return 1;
2061 }
2062
2063 output_var->type = vt_output;
Brian Paul7aebaf32005-10-30 21:23:23 +00002064
2065 err = parse_result_binding(ctx, inst, &output_var->output_binding, Program);
2066 return err;
Jouk Jansen40322e12004-04-05 08:50:36 +00002067}
2068
2069/**
2070 * This handles variables of the ALIAS kind
2071 *
2072 * \return 0 on sucess, 1 on error
2073 */
2074static GLuint
Brian Paula088f162006-09-05 23:08:51 +00002075parse_alias (GLcontext * ctx, const GLubyte ** inst, struct var_cache **vc_head,
Jouk Jansen40322e12004-04-05 08:50:36 +00002076 struct arb_program *Program)
2077{
2078 GLuint found;
2079 struct var_cache *temp_var;
Jouk Jansen40322e12004-04-05 08:50:36 +00002080
2081 temp_var = parse_string (inst, vc_head, Program, &found);
2082 Program->Position = parse_position (inst);
2083
2084 if (found) {
Brian50a20d42008-03-27 15:51:07 -06002085 program_error2(ctx, Program->Position,
2086 "Duplicate variable declaration",
2087 (char *) temp_var->name);
Jouk Jansen40322e12004-04-05 08:50:36 +00002088 return 1;
2089 }
2090
2091 temp_var->type = vt_alias;
2092 temp_var->alias_binding = parse_string (inst, vc_head, Program, &found);
2093 Program->Position = parse_position (inst);
2094
2095 if (!found)
2096 {
Brian50a20d42008-03-27 15:51:07 -06002097 program_error2(ctx, Program->Position,
2098 "Undefined alias value",
2099 (char *) temp_var->alias_binding->name);
Jouk Jansen40322e12004-04-05 08:50:36 +00002100 return 1;
2101 }
2102
2103 return 0;
2104}
2105
2106/**
2107 * This handles variables of the ADDRESS kind
2108 *
2109 * \return 0 on sucess, 1 on error
2110 */
2111static GLuint
Brian Paula088f162006-09-05 23:08:51 +00002112parse_address (GLcontext * ctx, const GLubyte ** inst, struct var_cache **vc_head,
Jouk Jansen40322e12004-04-05 08:50:36 +00002113 struct arb_program *Program)
2114{
2115 GLuint found;
2116 struct var_cache *temp_var;
Jouk Jansen40322e12004-04-05 08:50:36 +00002117
2118 while (**inst != 0) {
2119 temp_var = parse_string (inst, vc_head, Program, &found);
2120 Program->Position = parse_position (inst);
2121 if (found) {
Brian50a20d42008-03-27 15:51:07 -06002122 program_error2(ctx, Program->Position,
2123 "Duplicate variable declaration",
2124 (char *) temp_var->name);
Jouk Jansen40322e12004-04-05 08:50:36 +00002125 return 1;
2126 }
2127
2128 temp_var->type = vt_address;
2129
2130 if (Program->Base.NumAddressRegs >=
Brian Paul05051032005-11-01 04:36:33 +00002131 ctx->Const.VertexProgram.MaxAddressRegs) {
Brian Paul7aebaf32005-10-30 21:23:23 +00002132 const char *msg = "Too many ADDRESS variables declared";
Brian Paula088f162006-09-05 23:08:51 +00002133 program_error(ctx, Program->Position, msg);
Jouk Jansen40322e12004-04-05 08:50:36 +00002134 return 1;
2135 }
2136
2137 temp_var->address_binding = Program->Base.NumAddressRegs;
2138 Program->Base.NumAddressRegs++;
2139 }
2140 (*inst)++;
2141
2142 return 0;
2143}
2144
2145/**
2146 * Parse a program declaration
2147 *
2148 * \return 0 on sucess, 1 on error
2149 */
2150static GLint
Brian Paula088f162006-09-05 23:08:51 +00002151parse_declaration (GLcontext * ctx, const GLubyte ** inst, struct var_cache **vc_head,
Jouk Jansen40322e12004-04-05 08:50:36 +00002152 struct arb_program *Program)
2153{
2154 GLint err = 0;
2155
2156 switch (*(*inst)++) {
2157 case ADDRESS:
2158 err = parse_address (ctx, inst, vc_head, Program);
2159 break;
2160
2161 case ALIAS:
2162 err = parse_alias (ctx, inst, vc_head, Program);
2163 break;
2164
2165 case ATTRIB:
2166 err = parse_attrib (ctx, inst, vc_head, Program);
2167 break;
2168
2169 case OUTPUT:
2170 err = parse_output (ctx, inst, vc_head, Program);
2171 break;
2172
2173 case PARAM:
2174 err = parse_param (ctx, inst, vc_head, Program);
2175 break;
2176
2177 case TEMP:
2178 err = parse_temp (ctx, inst, vc_head, Program);
2179 break;
2180 }
2181
2182 return err;
2183}
2184
2185/**
Brian Paul7aebaf32005-10-30 21:23:23 +00002186 * Handle the parsing out of a masked destination register, either for a
2187 * vertex or fragment program.
Jouk Jansen40322e12004-04-05 08:50:36 +00002188 *
2189 * If we are a vertex program, make sure we don't write to
Brian Paul7aebaf32005-10-30 21:23:23 +00002190 * result.position if we have specified that the program is
Jouk Jansen40322e12004-04-05 08:50:36 +00002191 * position invariant
2192 *
2193 * \param File - The register file we write to
2194 * \param Index - The register index we write to
2195 * \param WriteMask - The mask controlling which components we write (1->write)
2196 *
2197 * \return 0 on sucess, 1 on error
2198 */
2199static GLuint
Brian Paula088f162006-09-05 23:08:51 +00002200parse_masked_dst_reg (GLcontext * ctx, const GLubyte ** inst,
Jouk Jansen40322e12004-04-05 08:50:36 +00002201 struct var_cache **vc_head, struct arb_program *Program,
Brian Paul7aebaf32005-10-30 21:23:23 +00002202 enum register_file *File, GLuint *Index, GLint *WriteMask)
Jouk Jansen40322e12004-04-05 08:50:36 +00002203{
Brian Paul7aebaf32005-10-30 21:23:23 +00002204 GLuint tmp, result;
Jouk Jansen40322e12004-04-05 08:50:36 +00002205 struct var_cache *dst;
2206
2207 /* We either have a result register specified, or a
2208 * variable that may or may not be writable
2209 */
2210 switch (*(*inst)++) {
2211 case REGISTER_RESULT:
Brian Paul7aebaf32005-10-30 21:23:23 +00002212 if (parse_result_binding(ctx, inst, Index, Program))
Jouk Jansen40322e12004-04-05 08:50:36 +00002213 return 1;
2214 *File = PROGRAM_OUTPUT;
2215 break;
2216
2217 case REGISTER_ESTABLISHED_NAME:
2218 dst = parse_string (inst, vc_head, Program, &result);
2219 Program->Position = parse_position (inst);
2220
2221 /* If the name has never been added to our symbol table, we're hosed */
2222 if (!result) {
Brian Paula088f162006-09-05 23:08:51 +00002223 program_error(ctx, Program->Position, "0: Undefined variable");
Jouk Jansen40322e12004-04-05 08:50:36 +00002224 return 1;
2225 }
2226
2227 switch (dst->type) {
2228 case vt_output:
2229 *File = PROGRAM_OUTPUT;
Brian Paul7aebaf32005-10-30 21:23:23 +00002230 *Index = dst->output_binding;
Jouk Jansen40322e12004-04-05 08:50:36 +00002231 break;
2232
2233 case vt_temp:
2234 *File = PROGRAM_TEMPORARY;
2235 *Index = dst->temp_binding;
2236 break;
2237
2238 /* If the var type is not vt_output or vt_temp, no go */
2239 default:
Brian Paula088f162006-09-05 23:08:51 +00002240 program_error(ctx, Program->Position,
2241 "Destination register is read only");
Jouk Jansen40322e12004-04-05 08:50:36 +00002242 return 1;
2243 }
2244 break;
2245
2246 default:
Brian Paula088f162006-09-05 23:08:51 +00002247 program_error(ctx, Program->Position,
2248 "Unexpected opcode in parse_masked_dst_reg()");
Jouk Jansen40322e12004-04-05 08:50:36 +00002249 return 1;
2250 }
2251
2252
2253 /* Position invariance test */
2254 /* This test is done now in syntax portion - when position invariance OPTION
2255 is specified, "result.position" rule is disabled so there is no way
2256 to write the position
2257 */
2258 /*if ((Program->HintPositionInvariant) && (*File == PROGRAM_OUTPUT) &&
2259 (*Index == 0)) {
Brian Paula088f162006-09-05 23:08:51 +00002260 program_error(ctx, Program->Position,
Jouk Jansen40322e12004-04-05 08:50:36 +00002261 "Vertex program specified position invariance and wrote vertex position");
2262 }*/
2263
2264 /* And then the mask.
2265 * w,a -> bit 0
2266 * z,b -> bit 1
2267 * y,g -> bit 2
2268 * x,r -> bit 3
Keith Whitwell7c26b612005-04-21 14:46:57 +00002269 *
2270 * ==> Need to reverse the order of bits for this!
Jouk Jansen40322e12004-04-05 08:50:36 +00002271 */
Keith Whitwell7c26b612005-04-21 14:46:57 +00002272 tmp = (GLint) *(*inst)++;
2273 *WriteMask = (((tmp>>3) & 0x1) |
2274 ((tmp>>1) & 0x2) |
2275 ((tmp<<1) & 0x4) |
2276 ((tmp<<3) & 0x8));
Jouk Jansen40322e12004-04-05 08:50:36 +00002277
2278 return 0;
2279}
2280
2281
2282/**
2283 * Handle the parsing of a address register
2284 *
2285 * \param Index - The register index we write to
2286 *
2287 * \return 0 on sucess, 1 on error
2288 */
2289static GLuint
Brian Paula088f162006-09-05 23:08:51 +00002290parse_address_reg (GLcontext * ctx, const GLubyte ** inst,
Jouk Jansen40322e12004-04-05 08:50:36 +00002291 struct var_cache **vc_head,
2292 struct arb_program *Program, GLint * Index)
2293{
2294 struct var_cache *dst;
2295 GLuint result;
Aapo Tahkola6fc864b2006-03-22 21:29:15 +00002296
2297 *Index = 0; /* XXX */
Jouk Jansen40322e12004-04-05 08:50:36 +00002298
2299 dst = parse_string (inst, vc_head, Program, &result);
2300 Program->Position = parse_position (inst);
2301
2302 /* If the name has never been added to our symbol table, we're hosed */
2303 if (!result) {
Brian Paula088f162006-09-05 23:08:51 +00002304 program_error(ctx, Program->Position, "Undefined variable");
Jouk Jansen40322e12004-04-05 08:50:36 +00002305 return 1;
2306 }
2307
2308 if (dst->type != vt_address) {
Brian Paula088f162006-09-05 23:08:51 +00002309 program_error(ctx, Program->Position, "Variable is not of type ADDRESS");
Jouk Jansen40322e12004-04-05 08:50:36 +00002310 return 1;
2311 }
2312
2313 return 0;
2314}
2315
Brian Paul8e8fa632005-07-01 02:03:33 +00002316#if 0 /* unused */
Jouk Jansen40322e12004-04-05 08:50:36 +00002317/**
2318 * Handle the parsing out of a masked address register
2319 *
2320 * \param Index - The register index we write to
2321 * \param WriteMask - The mask controlling which components we write (1->write)
2322 *
2323 * \return 0 on sucess, 1 on error
2324 */
2325static GLuint
Brian Paula088f162006-09-05 23:08:51 +00002326parse_masked_address_reg (GLcontext * ctx, const GLubyte ** inst,
Jouk Jansen40322e12004-04-05 08:50:36 +00002327 struct var_cache **vc_head,
2328 struct arb_program *Program, GLint * Index,
2329 GLboolean * WriteMask)
2330{
2331 if (parse_address_reg (ctx, inst, vc_head, Program, Index))
2332 return 1;
2333
2334 /* This should be 0x8 */
2335 (*inst)++;
2336
2337 /* Writemask of .x is implied */
2338 WriteMask[0] = 1;
2339 WriteMask[1] = WriteMask[2] = WriteMask[3] = 0;
2340
2341 return 0;
2342}
Brian Paul8e8fa632005-07-01 02:03:33 +00002343#endif
Jouk Jansen40322e12004-04-05 08:50:36 +00002344
2345/**
2346 * Parse out a swizzle mask.
2347 *
Brian Paul32df89e2005-10-29 18:26:43 +00002348 * Basically convert COMPONENT_X/Y/Z/W to SWIZZLE_X/Y/Z/W
Jouk Jansen40322e12004-04-05 08:50:36 +00002349 *
2350 * The len parameter allows us to grab 4 components for a vector
2351 * swizzle, or just 1 component for a scalar src register selection
2352 */
Brian Paul32df89e2005-10-29 18:26:43 +00002353static void
Brian Paula088f162006-09-05 23:08:51 +00002354parse_swizzle_mask(const GLubyte ** inst, GLubyte *swizzle, GLint len)
Jouk Jansen40322e12004-04-05 08:50:36 +00002355{
Brian Paul32df89e2005-10-29 18:26:43 +00002356 GLint i;
Jouk Jansen40322e12004-04-05 08:50:36 +00002357
Brian Paul32df89e2005-10-29 18:26:43 +00002358 for (i = 0; i < 4; i++)
2359 swizzle[i] = i;
Jouk Jansen40322e12004-04-05 08:50:36 +00002360
Brian Paul32df89e2005-10-29 18:26:43 +00002361 for (i = 0; i < len; i++) {
Jouk Jansen40322e12004-04-05 08:50:36 +00002362 switch (*(*inst)++) {
2363 case COMPONENT_X:
Brian Paul32df89e2005-10-29 18:26:43 +00002364 swizzle[i] = SWIZZLE_X;
Jouk Jansen40322e12004-04-05 08:50:36 +00002365 break;
Jouk Jansen40322e12004-04-05 08:50:36 +00002366 case COMPONENT_Y:
Brian Paul32df89e2005-10-29 18:26:43 +00002367 swizzle[i] = SWIZZLE_Y;
Jouk Jansen40322e12004-04-05 08:50:36 +00002368 break;
Jouk Jansen40322e12004-04-05 08:50:36 +00002369 case COMPONENT_Z:
Brian Paul32df89e2005-10-29 18:26:43 +00002370 swizzle[i] = SWIZZLE_Z;
Jouk Jansen40322e12004-04-05 08:50:36 +00002371 break;
Jouk Jansen40322e12004-04-05 08:50:36 +00002372 case COMPONENT_W:
Brian Paul32df89e2005-10-29 18:26:43 +00002373 swizzle[i] = SWIZZLE_W;
Jouk Jansen40322e12004-04-05 08:50:36 +00002374 break;
Brian Paul32df89e2005-10-29 18:26:43 +00002375 default:
2376 _mesa_problem(NULL, "bad component in parse_swizzle_mask()");
2377 return;
Jouk Jansen40322e12004-04-05 08:50:36 +00002378 }
2379 }
Jouk Jansen40322e12004-04-05 08:50:36 +00002380}
2381
Jouk Jansen40322e12004-04-05 08:50:36 +00002382
Brian Paul32df89e2005-10-29 18:26:43 +00002383/**
2384 * Parse an extended swizzle mask which is a sequence of
2385 * four x/y/z/w/0/1 tokens.
2386 * \return swizzle four swizzle values
2387 * \return negateMask four element bitfield
2388 */
2389static void
Brian Paula088f162006-09-05 23:08:51 +00002390parse_extended_swizzle_mask(const GLubyte **inst, GLubyte swizzle[4],
Brian Paul32df89e2005-10-29 18:26:43 +00002391 GLubyte *negateMask)
2392{
2393 GLint i;
2394
2395 *negateMask = 0x0;
2396 for (i = 0; i < 4; i++) {
2397 GLubyte swz;
2398 if (parse_sign(inst) == -1)
2399 *negateMask |= (1 << i);
Jouk Jansen40322e12004-04-05 08:50:36 +00002400
2401 swz = *(*inst)++;
2402
2403 switch (swz) {
2404 case COMPONENT_0:
Brian Paul32df89e2005-10-29 18:26:43 +00002405 swizzle[i] = SWIZZLE_ZERO;
Jouk Jansen40322e12004-04-05 08:50:36 +00002406 break;
2407 case COMPONENT_1:
Brian Paul32df89e2005-10-29 18:26:43 +00002408 swizzle[i] = SWIZZLE_ONE;
Jouk Jansen40322e12004-04-05 08:50:36 +00002409 break;
2410 case COMPONENT_X:
Brian Paul32df89e2005-10-29 18:26:43 +00002411 swizzle[i] = SWIZZLE_X;
Jouk Jansen40322e12004-04-05 08:50:36 +00002412 break;
2413 case COMPONENT_Y:
Brian Paul32df89e2005-10-29 18:26:43 +00002414 swizzle[i] = SWIZZLE_Y;
Jouk Jansen40322e12004-04-05 08:50:36 +00002415 break;
2416 case COMPONENT_Z:
Brian Paul32df89e2005-10-29 18:26:43 +00002417 swizzle[i] = SWIZZLE_Z;
Jouk Jansen40322e12004-04-05 08:50:36 +00002418 break;
2419 case COMPONENT_W:
Brian Paul32df89e2005-10-29 18:26:43 +00002420 swizzle[i] = SWIZZLE_W;
Jouk Jansen40322e12004-04-05 08:50:36 +00002421 break;
Brian Paul32df89e2005-10-29 18:26:43 +00002422 default:
2423 _mesa_problem(NULL, "bad case in parse_extended_swizzle_mask()");
2424 return;
Jouk Jansen40322e12004-04-05 08:50:36 +00002425 }
Jouk Jansen40322e12004-04-05 08:50:36 +00002426 }
Jouk Jansen40322e12004-04-05 08:50:36 +00002427}
2428
2429
2430static GLuint
Brian Paula088f162006-09-05 23:08:51 +00002431parse_src_reg (GLcontext * ctx, const GLubyte ** inst,
2432 struct var_cache **vc_head,
Brian Paul7aebaf32005-10-30 21:23:23 +00002433 struct arb_program *Program,
2434 enum register_file * File, GLint * Index,
Jouk Jansen40322e12004-04-05 08:50:36 +00002435 GLboolean *IsRelOffset )
2436{
2437 struct var_cache *src;
Brian Paul18e7c5c2005-10-30 21:46:00 +00002438 GLuint binding, is_generic, found;
Brian Paulbd997cd2004-07-20 21:12:56 +00002439 GLint offset;
Jouk Jansen40322e12004-04-05 08:50:36 +00002440
Keith Whitwell7c26b612005-04-21 14:46:57 +00002441 *IsRelOffset = 0;
2442
Jouk Jansen40322e12004-04-05 08:50:36 +00002443 /* And the binding for the src */
2444 switch (*(*inst)++) {
2445 case REGISTER_ATTRIB:
2446 if (parse_attrib_binding
Brian Paul18e7c5c2005-10-30 21:46:00 +00002447 (ctx, inst, Program, &binding, &is_generic))
Jouk Jansen40322e12004-04-05 08:50:36 +00002448 return 1;
2449 *File = PROGRAM_INPUT;
Brian Paul18e7c5c2005-10-30 21:46:00 +00002450 *Index = binding;
Jouk Jansen40322e12004-04-05 08:50:36 +00002451
2452 /* We need to insert a dummy variable into the var_cache so we can
2453 * catch generic vertex attrib aliasing errors
2454 */
2455 var_cache_create(&src);
2456 src->type = vt_attrib;
Brian Paul6a769d92006-04-28 15:42:15 +00002457 src->name = (const GLubyte *) "Dummy Attrib Variable";
Brian Paul18e7c5c2005-10-30 21:46:00 +00002458 src->attrib_binding = binding;
2459 src->attrib_is_generic = is_generic;
Jouk Jansen40322e12004-04-05 08:50:36 +00002460 var_cache_append(vc_head, src);
2461 if (generic_attrib_check(*vc_head)) {
Brian Paula088f162006-09-05 23:08:51 +00002462 program_error(ctx, Program->Position,
2463 "Cannot use both a generic vertex attribute "
2464 "and a specific attribute of the same type");
Jouk Jansen40322e12004-04-05 08:50:36 +00002465 return 1;
2466 }
2467 break;
2468
2469 case REGISTER_PARAM:
2470 switch (**inst) {
2471 case PARAM_ARRAY_ELEMENT:
2472 (*inst)++;
2473 src = parse_string (inst, vc_head, Program, &found);
2474 Program->Position = parse_position (inst);
2475
2476 if (!found) {
Brian50a20d42008-03-27 15:51:07 -06002477 program_error2(ctx, Program->Position,
2478 "Undefined variable",
2479 (char *) src->name);
Jouk Jansen40322e12004-04-05 08:50:36 +00002480 return 1;
2481 }
2482
Brian Paul95801792005-12-06 15:41:43 +00002483 *File = (enum register_file) src->param_binding_type;
Jouk Jansen40322e12004-04-05 08:50:36 +00002484
2485 switch (*(*inst)++) {
2486 case ARRAY_INDEX_ABSOLUTE:
2487 offset = parse_integer (inst, Program);
2488
2489 if ((offset < 0)
Brian Paula6c423d2004-08-25 15:59:48 +00002490 || (offset >= (int)src->param_binding_length)) {
Brian Paula088f162006-09-05 23:08:51 +00002491 program_error(ctx, Program->Position,
2492 "Index out of range");
2493 /* offset, src->name */
Jouk Jansen40322e12004-04-05 08:50:36 +00002494 return 1;
2495 }
2496
2497 *Index = src->param_binding_begin + offset;
2498 break;
2499
2500 case ARRAY_INDEX_RELATIVE:
2501 {
2502 GLint addr_reg_idx, rel_off;
2503
2504 /* First, grab the address regiseter */
2505 if (parse_address_reg (ctx, inst, vc_head, Program, &addr_reg_idx))
2506 return 1;
2507
2508 /* And the .x */
2509 ((*inst)++);
2510 ((*inst)++);
2511 ((*inst)++);
2512 ((*inst)++);
2513
2514 /* Then the relative offset */
2515 if (parse_relative_offset(ctx, inst, Program, &rel_off)) return 1;
2516
2517 /* And store it properly */
2518 *Index = src->param_binding_begin + rel_off;
2519 *IsRelOffset = 1;
2520 }
2521 break;
2522 }
2523 break;
2524
2525 default:
Jouk Jansen40322e12004-04-05 08:50:36 +00002526 if (parse_param_use (ctx, inst, vc_head, Program, &src))
2527 return 1;
2528
Brian Paul95801792005-12-06 15:41:43 +00002529 *File = (enum register_file) src->param_binding_type;
Jouk Jansen40322e12004-04-05 08:50:36 +00002530 *Index = src->param_binding_begin;
2531 break;
2532 }
2533 break;
2534
2535 case REGISTER_ESTABLISHED_NAME:
Jouk Jansen40322e12004-04-05 08:50:36 +00002536 src = parse_string (inst, vc_head, Program, &found);
2537 Program->Position = parse_position (inst);
2538
2539 /* If the name has never been added to our symbol table, we're hosed */
2540 if (!found) {
Brian Paula088f162006-09-05 23:08:51 +00002541 program_error(ctx, Program->Position,
2542 "3: Undefined variable"); /* src->name */
Jouk Jansen40322e12004-04-05 08:50:36 +00002543 return 1;
2544 }
2545
2546 switch (src->type) {
2547 case vt_attrib:
2548 *File = PROGRAM_INPUT;
Brian Paul18e7c5c2005-10-30 21:46:00 +00002549 *Index = src->attrib_binding;
Jouk Jansen40322e12004-04-05 08:50:36 +00002550 break;
2551
2552 /* XXX: We have to handle offsets someplace in here! -- or are those above? */
2553 case vt_param:
Brian Paul95801792005-12-06 15:41:43 +00002554 *File = (enum register_file) src->param_binding_type;
Jouk Jansen40322e12004-04-05 08:50:36 +00002555 *Index = src->param_binding_begin;
2556 break;
2557
2558 case vt_temp:
2559 *File = PROGRAM_TEMPORARY;
2560 *Index = src->temp_binding;
2561 break;
2562
2563 /* If the var type is vt_output no go */
2564 default:
Brian Paula088f162006-09-05 23:08:51 +00002565 program_error(ctx, Program->Position,
2566 "destination register is read only");
2567 /* bad src->name */
Jouk Jansen40322e12004-04-05 08:50:36 +00002568 return 1;
2569 }
2570 break;
2571
2572 default:
Brian Paula088f162006-09-05 23:08:51 +00002573 program_error(ctx, Program->Position,
2574 "Unknown token in parse_src_reg");
Jouk Jansen40322e12004-04-05 08:50:36 +00002575 return 1;
2576 }
2577
Markus Amslerf3c49062008-03-17 08:35:37 -06002578 /* Add attributes to InputsRead only if they are used the program.
2579 * This avoids the handling of unused ATTRIB declarations in the drivers. */
2580 if (*File == PROGRAM_INPUT)
2581 Program->Base.InputsRead |= (1 << *Index);
2582
Jouk Jansen40322e12004-04-05 08:50:36 +00002583 return 0;
2584}
2585
Brianbdf279b2008-03-27 16:19:46 -06002586
Jouk Jansen40322e12004-04-05 08:50:36 +00002587/**
Brianbdf279b2008-03-27 16:19:46 -06002588 * Parse vertex/fragment program vector source register.
Jouk Jansen40322e12004-04-05 08:50:36 +00002589 */
2590static GLuint
Brianbdf279b2008-03-27 16:19:46 -06002591parse_vector_src_reg(GLcontext *ctx, const GLubyte **inst,
2592 struct var_cache **vc_head,
2593 struct arb_program *program,
2594 struct prog_src_register *reg)
Jouk Jansen40322e12004-04-05 08:50:36 +00002595{
Brian Paul7aebaf32005-10-30 21:23:23 +00002596 enum register_file file;
Brian Paul32df89e2005-10-29 18:26:43 +00002597 GLint index;
Brianbdf279b2008-03-27 16:19:46 -06002598 GLubyte negateMask;
Brian Paul32df89e2005-10-29 18:26:43 +00002599 GLubyte swizzle[4];
2600 GLboolean isRelOffset;
Keith Whitwell7c26b612005-04-21 14:46:57 +00002601
Jouk Jansen40322e12004-04-05 08:50:36 +00002602 /* Grab the sign */
Brianbdf279b2008-03-27 16:19:46 -06002603 negateMask = (parse_sign (inst) == -1) ? NEGATE_XYZW : NEGATE_NONE;
Jouk Jansen40322e12004-04-05 08:50:36 +00002604
2605 /* And the src reg */
Brian Paul32df89e2005-10-29 18:26:43 +00002606 if (parse_src_reg(ctx, inst, vc_head, program, &file, &index, &isRelOffset))
Jouk Jansen40322e12004-04-05 08:50:36 +00002607 return 1;
2608
2609 /* finally, the swizzle */
Brian Paul32df89e2005-10-29 18:26:43 +00002610 parse_swizzle_mask(inst, swizzle, 4);
Jouk Jansen40322e12004-04-05 08:50:36 +00002611
Brian Paul32df89e2005-10-29 18:26:43 +00002612 reg->File = file;
2613 reg->Index = index;
Brian Paul32df89e2005-10-29 18:26:43 +00002614 reg->Swizzle = MAKE_SWIZZLE4(swizzle[0], swizzle[1], swizzle[2], swizzle[3]);
Brianbdf279b2008-03-27 16:19:46 -06002615 reg->NegateBase = negateMask;
2616 reg->RelAddr = isRelOffset;
Jouk Jansen40322e12004-04-05 08:50:36 +00002617 return 0;
2618}
2619
Jouk Jansen40322e12004-04-05 08:50:36 +00002620
Brian Paulb7fc1c32006-08-30 23:38:03 +00002621/**
Brianbdf279b2008-03-27 16:19:46 -06002622 * Parse vertex/fragment program scalar source register.
2623 */
2624static GLuint
2625parse_scalar_src_reg(GLcontext *ctx, const GLubyte **inst,
2626 struct var_cache **vc_head,
2627 struct arb_program *program,
2628 struct prog_src_register *reg)
2629{
2630 enum register_file file;
2631 GLint index;
2632 GLubyte negateMask;
2633 GLubyte swizzle[4];
2634 GLboolean isRelOffset;
2635
2636 /* Grab the sign */
2637 negateMask = (parse_sign (inst) == -1) ? NEGATE_XYZW : NEGATE_NONE;
2638
2639 /* And the src reg */
2640 if (parse_src_reg(ctx, inst, vc_head, program, &file, &index, &isRelOffset))
2641 return 1;
2642
2643 /* finally, the swizzle */
2644 parse_swizzle_mask(inst, swizzle, 1);
2645
2646 reg->File = file;
2647 reg->Index = index;
2648 reg->Swizzle = (swizzle[0] << 0);
2649 reg->NegateBase = negateMask;
2650 reg->RelAddr = isRelOffset;
2651 return 0;
2652}
2653
2654
2655/**
2656 * Parse vertex/fragment program destination register.
Brian Paulb7fc1c32006-08-30 23:38:03 +00002657 * \return 1 if error, 0 if no error.
2658 */
Keith Whitwell7c26b612005-04-21 14:46:57 +00002659static GLuint
Brianbdf279b2008-03-27 16:19:46 -06002660parse_dst_reg(GLcontext * ctx, const GLubyte ** inst,
2661 struct var_cache **vc_head, struct arb_program *program,
2662 struct prog_dst_register *reg )
Keith Whitwell7c26b612005-04-21 14:46:57 +00002663{
Brian Paul7aebaf32005-10-30 21:23:23 +00002664 GLint mask;
2665 GLuint idx;
2666 enum register_file file;
2667
Brianbdf279b2008-03-27 16:19:46 -06002668 if (parse_masked_dst_reg (ctx, inst, vc_head, program, &file, &idx, &mask))
Jouk Jansen40322e12004-04-05 08:50:36 +00002669 return 1;
2670
Keith Whitwell7c26b612005-04-21 14:46:57 +00002671 reg->File = file;
2672 reg->Index = idx;
2673 reg->WriteMask = mask;
2674 return 0;
2675}
2676
2677
Brian Paul7aebaf32005-10-30 21:23:23 +00002678/**
Jouk Jansen40322e12004-04-05 08:50:36 +00002679 * This is a big mother that handles getting opcodes into the instruction
2680 * and handling the src & dst registers for fragment program instructions
Brian Paulb7fc1c32006-08-30 23:38:03 +00002681 * \return 1 if error, 0 if no error
Jouk Jansen40322e12004-04-05 08:50:36 +00002682 */
2683static GLuint
Brian Paula088f162006-09-05 23:08:51 +00002684parse_fp_instruction (GLcontext * ctx, const GLubyte ** inst,
Jouk Jansen40322e12004-04-05 08:50:36 +00002685 struct var_cache **vc_head, struct arb_program *Program,
Brian Paul7e807512005-11-05 17:10:45 +00002686 struct prog_instruction *fp)
Jouk Jansen40322e12004-04-05 08:50:36 +00002687{
Keith Whitwell7c26b612005-04-21 14:46:57 +00002688 GLint a;
Jouk Jansen40322e12004-04-05 08:50:36 +00002689 GLuint texcoord;
2690 GLubyte instClass, type, code;
2691 GLboolean rel;
Ian Romanick7b559a92007-06-07 13:58:50 -07002692 GLuint shadow_tex = 0;
Jouk Jansen40322e12004-04-05 08:50:36 +00002693
Brian Pauld6272e02006-10-29 18:03:16 +00002694 _mesa_init_instructions(fp, 1);
Jouk Jansen40322e12004-04-05 08:50:36 +00002695
2696 /* Record the position in the program string for debugging */
2697 fp->StringPos = Program->Position;
2698
2699 /* OP_ALU_INST or OP_TEX_INST */
2700 instClass = *(*inst)++;
2701
2702 /* OP_ALU_{VECTOR, SCALAR, BINSC, BIN, TRI, SWZ},
2703 * OP_TEX_{SAMPLE, KIL}
2704 */
2705 type = *(*inst)++;
2706
2707 /* The actual opcode name */
2708 code = *(*inst)++;
2709
2710 /* Increment the correct count */
2711 switch (instClass) {
2712 case OP_ALU_INST:
2713 Program->NumAluInstructions++;
2714 break;
2715 case OP_TEX_INST:
2716 Program->NumTexInstructions++;
2717 break;
2718 }
2719
Jouk Jansen40322e12004-04-05 08:50:36 +00002720 switch (type) {
2721 case OP_ALU_VECTOR:
2722 switch (code) {
2723 case OP_ABS_SAT:
Brian Paule31ac052005-11-20 17:52:40 +00002724 fp->SaturateMode = SATURATE_ZERO_ONE;
Jouk Jansen40322e12004-04-05 08:50:36 +00002725 case OP_ABS:
Brian Paul7e807512005-11-05 17:10:45 +00002726 fp->Opcode = OPCODE_ABS;
Jouk Jansen40322e12004-04-05 08:50:36 +00002727 break;
2728
2729 case OP_FLR_SAT:
Brian Paule31ac052005-11-20 17:52:40 +00002730 fp->SaturateMode = SATURATE_ZERO_ONE;
Jouk Jansen40322e12004-04-05 08:50:36 +00002731 case OP_FLR:
Brian Paul7e807512005-11-05 17:10:45 +00002732 fp->Opcode = OPCODE_FLR;
Jouk Jansen40322e12004-04-05 08:50:36 +00002733 break;
2734
2735 case OP_FRC_SAT:
Brian Paule31ac052005-11-20 17:52:40 +00002736 fp->SaturateMode = SATURATE_ZERO_ONE;
Jouk Jansen40322e12004-04-05 08:50:36 +00002737 case OP_FRC:
Brian Paul7e807512005-11-05 17:10:45 +00002738 fp->Opcode = OPCODE_FRC;
Jouk Jansen40322e12004-04-05 08:50:36 +00002739 break;
2740
2741 case OP_LIT_SAT:
Brian Paule31ac052005-11-20 17:52:40 +00002742 fp->SaturateMode = SATURATE_ZERO_ONE;
Jouk Jansen40322e12004-04-05 08:50:36 +00002743 case OP_LIT:
Brian Paul7e807512005-11-05 17:10:45 +00002744 fp->Opcode = OPCODE_LIT;
Jouk Jansen40322e12004-04-05 08:50:36 +00002745 break;
2746
2747 case OP_MOV_SAT:
Brian Paule31ac052005-11-20 17:52:40 +00002748 fp->SaturateMode = SATURATE_ZERO_ONE;
Jouk Jansen40322e12004-04-05 08:50:36 +00002749 case OP_MOV:
Brian Paul7e807512005-11-05 17:10:45 +00002750 fp->Opcode = OPCODE_MOV;
Jouk Jansen40322e12004-04-05 08:50:36 +00002751 break;
2752 }
2753
Brianbdf279b2008-03-27 16:19:46 -06002754 if (parse_dst_reg (ctx, inst, vc_head, Program, &fp->DstReg))
Jouk Jansen40322e12004-04-05 08:50:36 +00002755 return 1;
2756
Brianbdf279b2008-03-27 16:19:46 -06002757 if (parse_vector_src_reg(ctx, inst, vc_head, Program, &fp->SrcReg[0]))
Jouk Jansen40322e12004-04-05 08:50:36 +00002758 return 1;
Jouk Jansen40322e12004-04-05 08:50:36 +00002759 break;
2760
2761 case OP_ALU_SCALAR:
2762 switch (code) {
2763 case OP_COS_SAT:
Brian Paule31ac052005-11-20 17:52:40 +00002764 fp->SaturateMode = SATURATE_ZERO_ONE;
Jouk Jansen40322e12004-04-05 08:50:36 +00002765 case OP_COS:
Brian Paul7e807512005-11-05 17:10:45 +00002766 fp->Opcode = OPCODE_COS;
Jouk Jansen40322e12004-04-05 08:50:36 +00002767 break;
2768
2769 case OP_EX2_SAT:
Brian Paule31ac052005-11-20 17:52:40 +00002770 fp->SaturateMode = SATURATE_ZERO_ONE;
Jouk Jansen40322e12004-04-05 08:50:36 +00002771 case OP_EX2:
Brian Paul7e807512005-11-05 17:10:45 +00002772 fp->Opcode = OPCODE_EX2;
Jouk Jansen40322e12004-04-05 08:50:36 +00002773 break;
2774
2775 case OP_LG2_SAT:
Brian Paule31ac052005-11-20 17:52:40 +00002776 fp->SaturateMode = SATURATE_ZERO_ONE;
Jouk Jansen40322e12004-04-05 08:50:36 +00002777 case OP_LG2:
Brian Paul7e807512005-11-05 17:10:45 +00002778 fp->Opcode = OPCODE_LG2;
Jouk Jansen40322e12004-04-05 08:50:36 +00002779 break;
2780
2781 case OP_RCP_SAT:
Brian Paule31ac052005-11-20 17:52:40 +00002782 fp->SaturateMode = SATURATE_ZERO_ONE;
Jouk Jansen40322e12004-04-05 08:50:36 +00002783 case OP_RCP:
Brian Paul7e807512005-11-05 17:10:45 +00002784 fp->Opcode = OPCODE_RCP;
Jouk Jansen40322e12004-04-05 08:50:36 +00002785 break;
2786
2787 case OP_RSQ_SAT:
Brian Paule31ac052005-11-20 17:52:40 +00002788 fp->SaturateMode = SATURATE_ZERO_ONE;
Jouk Jansen40322e12004-04-05 08:50:36 +00002789 case OP_RSQ:
Brian Paul7e807512005-11-05 17:10:45 +00002790 fp->Opcode = OPCODE_RSQ;
Jouk Jansen40322e12004-04-05 08:50:36 +00002791 break;
2792
2793 case OP_SIN_SAT:
Brian Paule31ac052005-11-20 17:52:40 +00002794 fp->SaturateMode = SATURATE_ZERO_ONE;
Jouk Jansen40322e12004-04-05 08:50:36 +00002795 case OP_SIN:
Brian Paul7e807512005-11-05 17:10:45 +00002796 fp->Opcode = OPCODE_SIN;
Jouk Jansen40322e12004-04-05 08:50:36 +00002797 break;
2798
2799 case OP_SCS_SAT:
Brian Paule31ac052005-11-20 17:52:40 +00002800 fp->SaturateMode = SATURATE_ZERO_ONE;
Jouk Jansen40322e12004-04-05 08:50:36 +00002801 case OP_SCS:
2802
Brian Paul7e807512005-11-05 17:10:45 +00002803 fp->Opcode = OPCODE_SCS;
Jouk Jansen40322e12004-04-05 08:50:36 +00002804 break;
2805 }
2806
Brianbdf279b2008-03-27 16:19:46 -06002807 if (parse_dst_reg (ctx, inst, vc_head, Program, &fp->DstReg))
Jouk Jansen40322e12004-04-05 08:50:36 +00002808 return 1;
Keith Whitwell7c26b612005-04-21 14:46:57 +00002809
Brianbdf279b2008-03-27 16:19:46 -06002810 if (parse_scalar_src_reg(ctx, inst, vc_head, Program, &fp->SrcReg[0]))
Jouk Jansen40322e12004-04-05 08:50:36 +00002811 return 1;
Jouk Jansen40322e12004-04-05 08:50:36 +00002812 break;
2813
2814 case OP_ALU_BINSC:
2815 switch (code) {
2816 case OP_POW_SAT:
Brian Paule31ac052005-11-20 17:52:40 +00002817 fp->SaturateMode = SATURATE_ZERO_ONE;
Jouk Jansen40322e12004-04-05 08:50:36 +00002818 case OP_POW:
Brian Paul7e807512005-11-05 17:10:45 +00002819 fp->Opcode = OPCODE_POW;
Jouk Jansen40322e12004-04-05 08:50:36 +00002820 break;
2821 }
2822
Brianbdf279b2008-03-27 16:19:46 -06002823 if (parse_dst_reg(ctx, inst, vc_head, Program, &fp->DstReg))
Jouk Jansen40322e12004-04-05 08:50:36 +00002824 return 1;
Keith Whitwell7c26b612005-04-21 14:46:57 +00002825
Jouk Jansen40322e12004-04-05 08:50:36 +00002826 for (a = 0; a < 2; a++) {
Brianbdf279b2008-03-27 16:19:46 -06002827 if (parse_scalar_src_reg(ctx, inst, vc_head, Program, &fp->SrcReg[a]))
Jouk Jansen40322e12004-04-05 08:50:36 +00002828 return 1;
Jouk Jansen40322e12004-04-05 08:50:36 +00002829 }
2830 break;
2831
2832
2833 case OP_ALU_BIN:
2834 switch (code) {
2835 case OP_ADD_SAT:
Brian Paule31ac052005-11-20 17:52:40 +00002836 fp->SaturateMode = SATURATE_ZERO_ONE;
Jouk Jansen40322e12004-04-05 08:50:36 +00002837 case OP_ADD:
Brian Paul7e807512005-11-05 17:10:45 +00002838 fp->Opcode = OPCODE_ADD;
Jouk Jansen40322e12004-04-05 08:50:36 +00002839 break;
2840
2841 case OP_DP3_SAT:
Brian Paule31ac052005-11-20 17:52:40 +00002842 fp->SaturateMode = SATURATE_ZERO_ONE;
Jouk Jansen40322e12004-04-05 08:50:36 +00002843 case OP_DP3:
Brian Paul7e807512005-11-05 17:10:45 +00002844 fp->Opcode = OPCODE_DP3;
Jouk Jansen40322e12004-04-05 08:50:36 +00002845 break;
2846
2847 case OP_DP4_SAT:
Brian Paule31ac052005-11-20 17:52:40 +00002848 fp->SaturateMode = SATURATE_ZERO_ONE;
Jouk Jansen40322e12004-04-05 08:50:36 +00002849 case OP_DP4:
Brian Paul7e807512005-11-05 17:10:45 +00002850 fp->Opcode = OPCODE_DP4;
Jouk Jansen40322e12004-04-05 08:50:36 +00002851 break;
2852
2853 case OP_DPH_SAT:
Brian Paule31ac052005-11-20 17:52:40 +00002854 fp->SaturateMode = SATURATE_ZERO_ONE;
Jouk Jansen40322e12004-04-05 08:50:36 +00002855 case OP_DPH:
Brian Paul7e807512005-11-05 17:10:45 +00002856 fp->Opcode = OPCODE_DPH;
Jouk Jansen40322e12004-04-05 08:50:36 +00002857 break;
2858
2859 case OP_DST_SAT:
Brian Paule31ac052005-11-20 17:52:40 +00002860 fp->SaturateMode = SATURATE_ZERO_ONE;
Jouk Jansen40322e12004-04-05 08:50:36 +00002861 case OP_DST:
Brian Paul7e807512005-11-05 17:10:45 +00002862 fp->Opcode = OPCODE_DST;
Jouk Jansen40322e12004-04-05 08:50:36 +00002863 break;
2864
2865 case OP_MAX_SAT:
Brian Paule31ac052005-11-20 17:52:40 +00002866 fp->SaturateMode = SATURATE_ZERO_ONE;
Jouk Jansen40322e12004-04-05 08:50:36 +00002867 case OP_MAX:
Brian Paul7e807512005-11-05 17:10:45 +00002868 fp->Opcode = OPCODE_MAX;
Jouk Jansen40322e12004-04-05 08:50:36 +00002869 break;
2870
2871 case OP_MIN_SAT:
Brian Paule31ac052005-11-20 17:52:40 +00002872 fp->SaturateMode = SATURATE_ZERO_ONE;
Jouk Jansen40322e12004-04-05 08:50:36 +00002873 case OP_MIN:
Brian Paul7e807512005-11-05 17:10:45 +00002874 fp->Opcode = OPCODE_MIN;
Jouk Jansen40322e12004-04-05 08:50:36 +00002875 break;
2876
2877 case OP_MUL_SAT:
Brian Paule31ac052005-11-20 17:52:40 +00002878 fp->SaturateMode = SATURATE_ZERO_ONE;
Jouk Jansen40322e12004-04-05 08:50:36 +00002879 case OP_MUL:
Brian Paul7e807512005-11-05 17:10:45 +00002880 fp->Opcode = OPCODE_MUL;
Jouk Jansen40322e12004-04-05 08:50:36 +00002881 break;
2882
2883 case OP_SGE_SAT:
Brian Paule31ac052005-11-20 17:52:40 +00002884 fp->SaturateMode = SATURATE_ZERO_ONE;
Jouk Jansen40322e12004-04-05 08:50:36 +00002885 case OP_SGE:
Brian Paul7e807512005-11-05 17:10:45 +00002886 fp->Opcode = OPCODE_SGE;
Jouk Jansen40322e12004-04-05 08:50:36 +00002887 break;
2888
2889 case OP_SLT_SAT:
Brian Paule31ac052005-11-20 17:52:40 +00002890 fp->SaturateMode = SATURATE_ZERO_ONE;
Jouk Jansen40322e12004-04-05 08:50:36 +00002891 case OP_SLT:
Brian Paul7e807512005-11-05 17:10:45 +00002892 fp->Opcode = OPCODE_SLT;
Jouk Jansen40322e12004-04-05 08:50:36 +00002893 break;
2894
2895 case OP_SUB_SAT:
Brian Paule31ac052005-11-20 17:52:40 +00002896 fp->SaturateMode = SATURATE_ZERO_ONE;
Jouk Jansen40322e12004-04-05 08:50:36 +00002897 case OP_SUB:
Brian Paul7e807512005-11-05 17:10:45 +00002898 fp->Opcode = OPCODE_SUB;
Jouk Jansen40322e12004-04-05 08:50:36 +00002899 break;
2900
2901 case OP_XPD_SAT:
Brian Paule31ac052005-11-20 17:52:40 +00002902 fp->SaturateMode = SATURATE_ZERO_ONE;
Jouk Jansen40322e12004-04-05 08:50:36 +00002903 case OP_XPD:
Brian Paul7e807512005-11-05 17:10:45 +00002904 fp->Opcode = OPCODE_XPD;
Jouk Jansen40322e12004-04-05 08:50:36 +00002905 break;
2906 }
2907
Brianbdf279b2008-03-27 16:19:46 -06002908 if (parse_dst_reg (ctx, inst, vc_head, Program, &fp->DstReg))
Jouk Jansen40322e12004-04-05 08:50:36 +00002909 return 1;
2910 for (a = 0; a < 2; a++) {
Brianbdf279b2008-03-27 16:19:46 -06002911 if (parse_vector_src_reg(ctx, inst, vc_head, Program, &fp->SrcReg[a]))
Keith Whitwell7c26b612005-04-21 14:46:57 +00002912 return 1;
Jouk Jansen40322e12004-04-05 08:50:36 +00002913 }
2914 break;
2915
2916 case OP_ALU_TRI:
2917 switch (code) {
2918 case OP_CMP_SAT:
Brian Paule31ac052005-11-20 17:52:40 +00002919 fp->SaturateMode = SATURATE_ZERO_ONE;
Jouk Jansen40322e12004-04-05 08:50:36 +00002920 case OP_CMP:
Brian Paul7e807512005-11-05 17:10:45 +00002921 fp->Opcode = OPCODE_CMP;
Jouk Jansen40322e12004-04-05 08:50:36 +00002922 break;
2923
2924 case OP_LRP_SAT:
Brian Paule31ac052005-11-20 17:52:40 +00002925 fp->SaturateMode = SATURATE_ZERO_ONE;
Jouk Jansen40322e12004-04-05 08:50:36 +00002926 case OP_LRP:
Brian Paul7e807512005-11-05 17:10:45 +00002927 fp->Opcode = OPCODE_LRP;
Jouk Jansen40322e12004-04-05 08:50:36 +00002928 break;
2929
2930 case OP_MAD_SAT:
Brian Paule31ac052005-11-20 17:52:40 +00002931 fp->SaturateMode = SATURATE_ZERO_ONE;
Jouk Jansen40322e12004-04-05 08:50:36 +00002932 case OP_MAD:
Brian Paul7e807512005-11-05 17:10:45 +00002933 fp->Opcode = OPCODE_MAD;
Jouk Jansen40322e12004-04-05 08:50:36 +00002934 break;
2935 }
2936
Brianbdf279b2008-03-27 16:19:46 -06002937 if (parse_dst_reg (ctx, inst, vc_head, Program, &fp->DstReg))
Jouk Jansen40322e12004-04-05 08:50:36 +00002938 return 1;
Keith Whitwell7c26b612005-04-21 14:46:57 +00002939
Jouk Jansen40322e12004-04-05 08:50:36 +00002940 for (a = 0; a < 3; a++) {
Brianbdf279b2008-03-27 16:19:46 -06002941 if (parse_vector_src_reg(ctx, inst, vc_head, Program, &fp->SrcReg[a]))
Keith Whitwell7c26b612005-04-21 14:46:57 +00002942 return 1;
Jouk Jansen40322e12004-04-05 08:50:36 +00002943 }
2944 break;
2945
2946 case OP_ALU_SWZ:
2947 switch (code) {
2948 case OP_SWZ_SAT:
Brian Paule31ac052005-11-20 17:52:40 +00002949 fp->SaturateMode = SATURATE_ZERO_ONE;
Jouk Jansen40322e12004-04-05 08:50:36 +00002950 case OP_SWZ:
Brian Paul7e807512005-11-05 17:10:45 +00002951 fp->Opcode = OPCODE_SWZ;
Jouk Jansen40322e12004-04-05 08:50:36 +00002952 break;
2953 }
Brianbdf279b2008-03-27 16:19:46 -06002954 if (parse_dst_reg (ctx, inst, vc_head, Program, &fp->DstReg))
Jouk Jansen40322e12004-04-05 08:50:36 +00002955 return 1;
2956
Keith Whitwell7c26b612005-04-21 14:46:57 +00002957 {
Brian Paul32df89e2005-10-29 18:26:43 +00002958 GLubyte swizzle[4];
Brian Paul54cfe692005-10-21 15:22:36 +00002959 GLubyte negateMask;
Brian Paul7aebaf32005-10-30 21:23:23 +00002960 enum register_file file;
2961 GLint index;
Keith Whitwell7c26b612005-04-21 14:46:57 +00002962
Brian Paul32df89e2005-10-29 18:26:43 +00002963 if (parse_src_reg(ctx, inst, vc_head, Program, &file, &index, &rel))
Keith Whitwell7c26b612005-04-21 14:46:57 +00002964 return 1;
Brian Paul32df89e2005-10-29 18:26:43 +00002965 parse_extended_swizzle_mask(inst, swizzle, &negateMask);
2966 fp->SrcReg[0].File = file;
2967 fp->SrcReg[0].Index = index;
Brian Paul54cfe692005-10-21 15:22:36 +00002968 fp->SrcReg[0].NegateBase = negateMask;
Brian Paul32df89e2005-10-29 18:26:43 +00002969 fp->SrcReg[0].Swizzle = MAKE_SWIZZLE4(swizzle[0],
2970 swizzle[1],
2971 swizzle[2],
2972 swizzle[3]);
Keith Whitwell7c26b612005-04-21 14:46:57 +00002973 }
Jouk Jansen40322e12004-04-05 08:50:36 +00002974 break;
2975
2976 case OP_TEX_SAMPLE:
2977 switch (code) {
2978 case OP_TEX_SAT:
Brian Paule31ac052005-11-20 17:52:40 +00002979 fp->SaturateMode = SATURATE_ZERO_ONE;
Jouk Jansen40322e12004-04-05 08:50:36 +00002980 case OP_TEX:
Brian Paul7e807512005-11-05 17:10:45 +00002981 fp->Opcode = OPCODE_TEX;
Jouk Jansen40322e12004-04-05 08:50:36 +00002982 break;
2983
2984 case OP_TXP_SAT:
Brian Paule31ac052005-11-20 17:52:40 +00002985 fp->SaturateMode = SATURATE_ZERO_ONE;
Jouk Jansen40322e12004-04-05 08:50:36 +00002986 case OP_TXP:
Brian Paul7e807512005-11-05 17:10:45 +00002987 fp->Opcode = OPCODE_TXP;
Jouk Jansen40322e12004-04-05 08:50:36 +00002988 break;
2989
2990 case OP_TXB_SAT:
Brian Paule31ac052005-11-20 17:52:40 +00002991 fp->SaturateMode = SATURATE_ZERO_ONE;
Jouk Jansen40322e12004-04-05 08:50:36 +00002992 case OP_TXB:
Brian Paul7e807512005-11-05 17:10:45 +00002993 fp->Opcode = OPCODE_TXB;
Jouk Jansen40322e12004-04-05 08:50:36 +00002994 break;
2995 }
2996
Brianbdf279b2008-03-27 16:19:46 -06002997 if (parse_dst_reg (ctx, inst, vc_head, Program, &fp->DstReg))
Jouk Jansen40322e12004-04-05 08:50:36 +00002998 return 1;
Keith Whitwell7c26b612005-04-21 14:46:57 +00002999
Brianbdf279b2008-03-27 16:19:46 -06003000 if (parse_vector_src_reg(ctx, inst, vc_head, Program, &fp->SrcReg[0]))
Jouk Jansen40322e12004-04-05 08:50:36 +00003001 return 1;
Jouk Jansen40322e12004-04-05 08:50:36 +00003002
3003 /* texImageUnit */
3004 if (parse_texcoord_num (ctx, inst, Program, &texcoord))
3005 return 1;
3006 fp->TexSrcUnit = texcoord;
3007
3008 /* texTarget */
3009 switch (*(*inst)++) {
Ian Romanick7b559a92007-06-07 13:58:50 -07003010 case TEXTARGET_SHADOW1D:
3011 shadow_tex = 1 << texcoord;
3012 /* FALLTHROUGH */
Jouk Jansen40322e12004-04-05 08:50:36 +00003013 case TEXTARGET_1D:
Brian Paul7e807512005-11-05 17:10:45 +00003014 fp->TexSrcTarget = TEXTURE_1D_INDEX;
Jouk Jansen40322e12004-04-05 08:50:36 +00003015 break;
Ian Romanick7b559a92007-06-07 13:58:50 -07003016 case TEXTARGET_SHADOW2D:
3017 shadow_tex = 1 << texcoord;
3018 /* FALLTHROUGH */
Jouk Jansen40322e12004-04-05 08:50:36 +00003019 case TEXTARGET_2D:
Brian Paul7e807512005-11-05 17:10:45 +00003020 fp->TexSrcTarget = TEXTURE_2D_INDEX;
Jouk Jansen40322e12004-04-05 08:50:36 +00003021 break;
3022 case TEXTARGET_3D:
Brian Paul7e807512005-11-05 17:10:45 +00003023 fp->TexSrcTarget = TEXTURE_3D_INDEX;
Jouk Jansen40322e12004-04-05 08:50:36 +00003024 break;
Ian Romanick7b559a92007-06-07 13:58:50 -07003025 case TEXTARGET_SHADOWRECT:
3026 shadow_tex = 1 << texcoord;
3027 /* FALLTHROUGH */
Jouk Jansen40322e12004-04-05 08:50:36 +00003028 case TEXTARGET_RECT:
Brian Paul7e807512005-11-05 17:10:45 +00003029 fp->TexSrcTarget = TEXTURE_RECT_INDEX;
Jouk Jansen40322e12004-04-05 08:50:36 +00003030 break;
3031 case TEXTARGET_CUBE:
Brian Paul7e807512005-11-05 17:10:45 +00003032 fp->TexSrcTarget = TEXTURE_CUBE_INDEX;
Jouk Jansen40322e12004-04-05 08:50:36 +00003033 break;
Ian Romanick69358e72007-06-05 09:24:27 -07003034 case TEXTARGET_SHADOW1D_ARRAY:
Ian Romanick7b559a92007-06-07 13:58:50 -07003035 shadow_tex = 1 << texcoord;
3036 /* FALLTHROUGH */
Ian Romanickbb372f12007-05-16 15:34:22 -07003037 case TEXTARGET_1D_ARRAY:
3038 fp->TexSrcTarget = TEXTURE_1D_ARRAY_INDEX;
3039 break;
Ian Romanick7b559a92007-06-07 13:58:50 -07003040 case TEXTARGET_SHADOW2D_ARRAY:
3041 shadow_tex = 1 << texcoord;
3042 /* FALLTHROUGH */
Ian Romanickbb372f12007-05-16 15:34:22 -07003043 case TEXTARGET_2D_ARRAY:
3044 fp->TexSrcTarget = TEXTURE_2D_ARRAY_INDEX;
3045 break;
Jouk Jansen40322e12004-04-05 08:50:36 +00003046 }
Ian Romanick7b559a92007-06-07 13:58:50 -07003047
3048 /* Don't test the first time a particular sampler is seen. Each time
3049 * after that, make sure the shadow state is the same.
3050 */
3051 if ((_mesa_bitcount(Program->TexturesUsed[texcoord]) > 0)
3052 && ((Program->ShadowSamplers & (1 << texcoord)) != shadow_tex)) {
3053 program_error(ctx, Program->Position,
3054 "texture image unit used for shadow sampling and non-shadow sampling");
3055 return 1;
3056 }
3057
Brian Paulb7fc1c32006-08-30 23:38:03 +00003058 Program->TexturesUsed[texcoord] |= (1 << fp->TexSrcTarget);
3059 /* Check that both "2D" and "CUBE" (for example) aren't both used */
3060 if (_mesa_bitcount(Program->TexturesUsed[texcoord]) > 1) {
Brian Paula088f162006-09-05 23:08:51 +00003061 program_error(ctx, Program->Position,
3062 "multiple targets used on one texture image unit");
Brian Paulb7fc1c32006-08-30 23:38:03 +00003063 return 1;
3064 }
Ian Romanick7b559a92007-06-07 13:58:50 -07003065
3066
3067 Program->ShadowSamplers |= shadow_tex;
Jouk Jansen40322e12004-04-05 08:50:36 +00003068 break;
3069
3070 case OP_TEX_KIL:
Keith Whitwellc3626a92005-11-01 17:25:49 +00003071 Program->UsesKill = 1;
Brianbdf279b2008-03-27 16:19:46 -06003072 if (parse_vector_src_reg(ctx, inst, vc_head, Program, &fp->SrcReg[0]))
Jouk Jansen40322e12004-04-05 08:50:36 +00003073 return 1;
Brian Paul7e807512005-11-05 17:10:45 +00003074 fp->Opcode = OPCODE_KIL;
Jouk Jansen40322e12004-04-05 08:50:36 +00003075 break;
Brian Paulb7fc1c32006-08-30 23:38:03 +00003076 default:
3077 _mesa_problem(ctx, "bad type 0x%x in parse_fp_instruction()", type);
3078 return 1;
Jouk Jansen40322e12004-04-05 08:50:36 +00003079 }
3080
3081 return 0;
3082}
3083
Keith Whitwell7c26b612005-04-21 14:46:57 +00003084
3085/**
3086 * Handle the parsing out of a masked address register
3087 *
3088 * \param Index - The register index we write to
3089 * \param WriteMask - The mask controlling which components we write (1->write)
3090 *
3091 * \return 0 on sucess, 1 on error
3092 */
3093static GLuint
Brian Paula088f162006-09-05 23:08:51 +00003094parse_vp_address_reg (GLcontext * ctx, const GLubyte ** inst,
Keith Whitwell7c26b612005-04-21 14:46:57 +00003095 struct var_cache **vc_head,
3096 struct arb_program *Program,
Brian Paul7e807512005-11-05 17:10:45 +00003097 struct prog_dst_register *reg)
Keith Whitwell7c26b612005-04-21 14:46:57 +00003098{
3099 GLint idx;
3100
3101 if (parse_address_reg (ctx, inst, vc_head, Program, &idx))
3102 return 1;
3103
3104 /* This should be 0x8 */
3105 (*inst)++;
3106
3107 reg->File = PROGRAM_ADDRESS;
3108 reg->Index = idx;
3109
3110 /* Writemask of .x is implied */
3111 reg->WriteMask = 0x1;
3112 return 0;
3113}
3114
Keith Whitwell7c26b612005-04-21 14:46:57 +00003115
Jouk Jansen40322e12004-04-05 08:50:36 +00003116/**
3117 * This is a big mother that handles getting opcodes into the instruction
3118 * and handling the src & dst registers for vertex program instructions
3119 */
3120static GLuint
Brian Paula088f162006-09-05 23:08:51 +00003121parse_vp_instruction (GLcontext * ctx, const GLubyte ** inst,
Jouk Jansen40322e12004-04-05 08:50:36 +00003122 struct var_cache **vc_head, struct arb_program *Program,
Brian Paul7e807512005-11-05 17:10:45 +00003123 struct prog_instruction *vp)
Jouk Jansen40322e12004-04-05 08:50:36 +00003124{
3125 GLint a;
3126 GLubyte type, code;
3127
3128 /* OP_ALU_{ARL, VECTOR, SCALAR, BINSC, BIN, TRI, SWZ} */
3129 type = *(*inst)++;
3130
3131 /* The actual opcode name */
3132 code = *(*inst)++;
3133
Brian Pauld6272e02006-10-29 18:03:16 +00003134 _mesa_init_instructions(vp, 1);
Jouk Jansen40322e12004-04-05 08:50:36 +00003135 /* Record the position in the program string for debugging */
3136 vp->StringPos = Program->Position;
Jouk Jansen40322e12004-04-05 08:50:36 +00003137
3138 switch (type) {
3139 /* XXX: */
3140 case OP_ALU_ARL:
Brian Paul7e807512005-11-05 17:10:45 +00003141 vp->Opcode = OPCODE_ARL;
Jouk Jansen40322e12004-04-05 08:50:36 +00003142
3143 /* Remember to set SrcReg.RelAddr; */
3144
3145 /* Get the masked address register [dst] */
Keith Whitwell7c26b612005-04-21 14:46:57 +00003146 if (parse_vp_address_reg(ctx, inst, vc_head, Program, &vp->DstReg))
Jouk Jansen40322e12004-04-05 08:50:36 +00003147 return 1;
Keith Whitwell7c26b612005-04-21 14:46:57 +00003148
Jouk Jansen40322e12004-04-05 08:50:36 +00003149 vp->DstReg.File = PROGRAM_ADDRESS;
3150
3151 /* Get a scalar src register */
Brianbdf279b2008-03-27 16:19:46 -06003152 if (parse_scalar_src_reg(ctx, inst, vc_head, Program, &vp->SrcReg[0]))
Jouk Jansen40322e12004-04-05 08:50:36 +00003153 return 1;
3154
3155 break;
3156
3157 case OP_ALU_VECTOR:
3158 switch (code) {
3159 case OP_ABS:
Brian Paul7e807512005-11-05 17:10:45 +00003160 vp->Opcode = OPCODE_ABS;
Jouk Jansen40322e12004-04-05 08:50:36 +00003161 break;
3162 case OP_FLR:
Brian Paul7e807512005-11-05 17:10:45 +00003163 vp->Opcode = OPCODE_FLR;
Jouk Jansen40322e12004-04-05 08:50:36 +00003164 break;
3165 case OP_FRC:
Brian Paul7e807512005-11-05 17:10:45 +00003166 vp->Opcode = OPCODE_FRC;
Jouk Jansen40322e12004-04-05 08:50:36 +00003167 break;
3168 case OP_LIT:
Brian Paul7e807512005-11-05 17:10:45 +00003169 vp->Opcode = OPCODE_LIT;
Jouk Jansen40322e12004-04-05 08:50:36 +00003170 break;
3171 case OP_MOV:
Brian Paul7e807512005-11-05 17:10:45 +00003172 vp->Opcode = OPCODE_MOV;
Jouk Jansen40322e12004-04-05 08:50:36 +00003173 break;
3174 }
Keith Whitwell7c26b612005-04-21 14:46:57 +00003175
Brianbdf279b2008-03-27 16:19:46 -06003176 if (parse_dst_reg(ctx, inst, vc_head, Program, &vp->DstReg))
Jouk Jansen40322e12004-04-05 08:50:36 +00003177 return 1;
Keith Whitwell7c26b612005-04-21 14:46:57 +00003178
Brianbdf279b2008-03-27 16:19:46 -06003179 if (parse_vector_src_reg(ctx, inst, vc_head, Program, &vp->SrcReg[0]))
Jouk Jansen40322e12004-04-05 08:50:36 +00003180 return 1;
3181 break;
3182
3183 case OP_ALU_SCALAR:
3184 switch (code) {
3185 case OP_EX2:
Brian Paul7e807512005-11-05 17:10:45 +00003186 vp->Opcode = OPCODE_EX2;
Jouk Jansen40322e12004-04-05 08:50:36 +00003187 break;
3188 case OP_EXP:
Brian Paul7e807512005-11-05 17:10:45 +00003189 vp->Opcode = OPCODE_EXP;
Jouk Jansen40322e12004-04-05 08:50:36 +00003190 break;
3191 case OP_LG2:
Brian Paul7e807512005-11-05 17:10:45 +00003192 vp->Opcode = OPCODE_LG2;
Jouk Jansen40322e12004-04-05 08:50:36 +00003193 break;
3194 case OP_LOG:
Brian Paul7e807512005-11-05 17:10:45 +00003195 vp->Opcode = OPCODE_LOG;
Jouk Jansen40322e12004-04-05 08:50:36 +00003196 break;
3197 case OP_RCP:
Brian Paul7e807512005-11-05 17:10:45 +00003198 vp->Opcode = OPCODE_RCP;
Jouk Jansen40322e12004-04-05 08:50:36 +00003199 break;
3200 case OP_RSQ:
Brian Paul7e807512005-11-05 17:10:45 +00003201 vp->Opcode = OPCODE_RSQ;
Jouk Jansen40322e12004-04-05 08:50:36 +00003202 break;
3203 }
Brianbdf279b2008-03-27 16:19:46 -06003204 if (parse_dst_reg(ctx, inst, vc_head, Program, &vp->DstReg))
Jouk Jansen40322e12004-04-05 08:50:36 +00003205 return 1;
Keith Whitwell7c26b612005-04-21 14:46:57 +00003206
Brianbdf279b2008-03-27 16:19:46 -06003207 if (parse_scalar_src_reg(ctx, inst, vc_head, Program, &vp->SrcReg[0]))
Jouk Jansen40322e12004-04-05 08:50:36 +00003208 return 1;
3209 break;
3210
3211 case OP_ALU_BINSC:
3212 switch (code) {
3213 case OP_POW:
Brian Paul7e807512005-11-05 17:10:45 +00003214 vp->Opcode = OPCODE_POW;
Jouk Jansen40322e12004-04-05 08:50:36 +00003215 break;
3216 }
Brianbdf279b2008-03-27 16:19:46 -06003217 if (parse_dst_reg(ctx, inst, vc_head, Program, &vp->DstReg))
Jouk Jansen40322e12004-04-05 08:50:36 +00003218 return 1;
Keith Whitwell7c26b612005-04-21 14:46:57 +00003219
Jouk Jansen40322e12004-04-05 08:50:36 +00003220 for (a = 0; a < 2; a++) {
Brianbdf279b2008-03-27 16:19:46 -06003221 if (parse_scalar_src_reg(ctx, inst, vc_head, Program, &vp->SrcReg[a]))
Jouk Jansen40322e12004-04-05 08:50:36 +00003222 return 1;
3223 }
3224 break;
3225
3226 case OP_ALU_BIN:
3227 switch (code) {
3228 case OP_ADD:
Brian Paul7e807512005-11-05 17:10:45 +00003229 vp->Opcode = OPCODE_ADD;
Jouk Jansen40322e12004-04-05 08:50:36 +00003230 break;
3231 case OP_DP3:
Brian Paul7e807512005-11-05 17:10:45 +00003232 vp->Opcode = OPCODE_DP3;
Jouk Jansen40322e12004-04-05 08:50:36 +00003233 break;
3234 case OP_DP4:
Brian Paul7e807512005-11-05 17:10:45 +00003235 vp->Opcode = OPCODE_DP4;
Jouk Jansen40322e12004-04-05 08:50:36 +00003236 break;
3237 case OP_DPH:
Brian Paul7e807512005-11-05 17:10:45 +00003238 vp->Opcode = OPCODE_DPH;
Jouk Jansen40322e12004-04-05 08:50:36 +00003239 break;
3240 case OP_DST:
Brian Paul7e807512005-11-05 17:10:45 +00003241 vp->Opcode = OPCODE_DST;
Jouk Jansen40322e12004-04-05 08:50:36 +00003242 break;
3243 case OP_MAX:
Brian Paul7e807512005-11-05 17:10:45 +00003244 vp->Opcode = OPCODE_MAX;
Jouk Jansen40322e12004-04-05 08:50:36 +00003245 break;
3246 case OP_MIN:
Brian Paul7e807512005-11-05 17:10:45 +00003247 vp->Opcode = OPCODE_MIN;
Jouk Jansen40322e12004-04-05 08:50:36 +00003248 break;
3249 case OP_MUL:
Brian Paul7e807512005-11-05 17:10:45 +00003250 vp->Opcode = OPCODE_MUL;
Jouk Jansen40322e12004-04-05 08:50:36 +00003251 break;
3252 case OP_SGE:
Brian Paul7e807512005-11-05 17:10:45 +00003253 vp->Opcode = OPCODE_SGE;
Jouk Jansen40322e12004-04-05 08:50:36 +00003254 break;
3255 case OP_SLT:
Brian Paul7e807512005-11-05 17:10:45 +00003256 vp->Opcode = OPCODE_SLT;
Jouk Jansen40322e12004-04-05 08:50:36 +00003257 break;
3258 case OP_SUB:
Brian Paul7e807512005-11-05 17:10:45 +00003259 vp->Opcode = OPCODE_SUB;
Jouk Jansen40322e12004-04-05 08:50:36 +00003260 break;
3261 case OP_XPD:
Brian Paul7e807512005-11-05 17:10:45 +00003262 vp->Opcode = OPCODE_XPD;
Jouk Jansen40322e12004-04-05 08:50:36 +00003263 break;
3264 }
Brianbdf279b2008-03-27 16:19:46 -06003265 if (parse_dst_reg(ctx, inst, vc_head, Program, &vp->DstReg))
Jouk Jansen40322e12004-04-05 08:50:36 +00003266 return 1;
Keith Whitwell7c26b612005-04-21 14:46:57 +00003267
Jouk Jansen40322e12004-04-05 08:50:36 +00003268 for (a = 0; a < 2; a++) {
Brianbdf279b2008-03-27 16:19:46 -06003269 if (parse_vector_src_reg(ctx, inst, vc_head, Program, &vp->SrcReg[a]))
Jouk Jansen40322e12004-04-05 08:50:36 +00003270 return 1;
3271 }
3272 break;
3273
3274 case OP_ALU_TRI:
3275 switch (code) {
3276 case OP_MAD:
Brian Paul7e807512005-11-05 17:10:45 +00003277 vp->Opcode = OPCODE_MAD;
Jouk Jansen40322e12004-04-05 08:50:36 +00003278 break;
3279 }
3280
Brianbdf279b2008-03-27 16:19:46 -06003281 if (parse_dst_reg(ctx, inst, vc_head, Program, &vp->DstReg))
Jouk Jansen40322e12004-04-05 08:50:36 +00003282 return 1;
Keith Whitwell7c26b612005-04-21 14:46:57 +00003283
Jouk Jansen40322e12004-04-05 08:50:36 +00003284 for (a = 0; a < 3; a++) {
Brianbdf279b2008-03-27 16:19:46 -06003285 if (parse_vector_src_reg(ctx, inst, vc_head, Program, &vp->SrcReg[a]))
Jouk Jansen40322e12004-04-05 08:50:36 +00003286 return 1;
3287 }
3288 break;
3289
3290 case OP_ALU_SWZ:
3291 switch (code) {
3292 case OP_SWZ:
Brian Paul7e807512005-11-05 17:10:45 +00003293 vp->Opcode = OPCODE_SWZ;
Jouk Jansen40322e12004-04-05 08:50:36 +00003294 break;
3295 }
Keith Whitwell7c26b612005-04-21 14:46:57 +00003296 {
Brian Paul32df89e2005-10-29 18:26:43 +00003297 GLubyte swizzle[4];
3298 GLubyte negateMask;
3299 GLboolean relAddr;
Brian Paul7aebaf32005-10-30 21:23:23 +00003300 enum register_file file;
3301 GLint index;
Jouk Jansen40322e12004-04-05 08:50:36 +00003302
Brianbdf279b2008-03-27 16:19:46 -06003303 if (parse_dst_reg(ctx, inst, vc_head, Program, &vp->DstReg))
Keith Whitwell7c26b612005-04-21 14:46:57 +00003304 return 1;
3305
Brian Paul32df89e2005-10-29 18:26:43 +00003306 if (parse_src_reg(ctx, inst, vc_head, Program, &file, &index, &relAddr))
Keith Whitwell7c26b612005-04-21 14:46:57 +00003307 return 1;
Brian Paul32df89e2005-10-29 18:26:43 +00003308 parse_extended_swizzle_mask (inst, swizzle, &negateMask);
3309 vp->SrcReg[0].File = file;
3310 vp->SrcReg[0].Index = index;
Brian Paul7e807512005-11-05 17:10:45 +00003311 vp->SrcReg[0].NegateBase = negateMask;
Brian Paul32df89e2005-10-29 18:26:43 +00003312 vp->SrcReg[0].Swizzle = MAKE_SWIZZLE4(swizzle[0],
3313 swizzle[1],
3314 swizzle[2],
3315 swizzle[3]);
3316 vp->SrcReg[0].RelAddr = relAddr;
Keith Whitwell7c26b612005-04-21 14:46:57 +00003317 }
Jouk Jansen40322e12004-04-05 08:50:36 +00003318 break;
3319 }
3320 return 0;
3321}
3322
3323#if DEBUG_PARSING
3324
3325static GLvoid
Jouk Jansen40322e12004-04-05 08:50:36 +00003326debug_variables (GLcontext * ctx, struct var_cache *vc_head,
3327 struct arb_program *Program)
3328{
3329 struct var_cache *vc;
3330 GLint a, b;
3331
Brianb618ac82007-02-22 09:39:25 -07003332 fprintf (stderr, "debug_variables, vc_head: %p\n", (void*) vc_head);
Jouk Jansen40322e12004-04-05 08:50:36 +00003333
3334 /* First of all, print out the contents of the var_cache */
3335 vc = vc_head;
3336 while (vc) {
Brianb618ac82007-02-22 09:39:25 -07003337 fprintf (stderr, "[%p]\n", (void*) vc);
Jouk Jansen40322e12004-04-05 08:50:36 +00003338 switch (vc->type) {
3339 case vt_none:
3340 fprintf (stderr, "UNDEFINED %s\n", vc->name);
3341 break;
3342 case vt_attrib:
3343 fprintf (stderr, "ATTRIB %s\n", vc->name);
3344 fprintf (stderr, " binding: 0x%x\n", vc->attrib_binding);
3345 break;
3346 case vt_param:
3347 fprintf (stderr, "PARAM %s begin: %d len: %d\n", vc->name,
3348 vc->param_binding_begin, vc->param_binding_length);
3349 b = vc->param_binding_begin;
3350 for (a = 0; a < vc->param_binding_length; a++) {
3351 fprintf (stderr, "%s\n",
Brianb618ac82007-02-22 09:39:25 -07003352 Program->Base.Parameters->Parameters[a + b].Name);
3353 if (Program->Base.Parameters->Parameters[a + b].Type == PROGRAM_STATE_VAR) {
3354 const char *s;
3355 s = _mesa_program_state_string(Program->Base.Parameters->Parameters
3356 [a + b].StateIndexes);
3357 fprintf(stderr, "%s\n", s);
3358 _mesa_free((char *) s);
Jouk Jansen40322e12004-04-05 08:50:36 +00003359 }
3360 else
3361 fprintf (stderr, "%f %f %f %f\n",
Brianb618ac82007-02-22 09:39:25 -07003362 Program->Base.Parameters->ParameterValues[a + b][0],
3363 Program->Base.Parameters->ParameterValues[a + b][1],
3364 Program->Base.Parameters->ParameterValues[a + b][2],
3365 Program->Base.Parameters->ParameterValues[a + b][3]);
Jouk Jansen40322e12004-04-05 08:50:36 +00003366 }
3367 break;
3368 case vt_temp:
3369 fprintf (stderr, "TEMP %s\n", vc->name);
3370 fprintf (stderr, " binding: 0x%x\n", vc->temp_binding);
3371 break;
3372 case vt_output:
3373 fprintf (stderr, "OUTPUT %s\n", vc->name);
3374 fprintf (stderr, " binding: 0x%x\n", vc->output_binding);
3375 break;
3376 case vt_alias:
3377 fprintf (stderr, "ALIAS %s\n", vc->name);
Brianb618ac82007-02-22 09:39:25 -07003378 fprintf (stderr, " binding: 0x%p (%s)\n",
3379 (void*) vc->alias_binding, vc->alias_binding->name);
Jouk Jansen40322e12004-04-05 08:50:36 +00003380 break;
Brianb618ac82007-02-22 09:39:25 -07003381 default:
3382 /* nothing */
3383 ;
Jouk Jansen40322e12004-04-05 08:50:36 +00003384 }
3385 vc = vc->next;
3386 }
3387}
3388
Brian Paul72030e02005-11-03 03:30:34 +00003389#endif /* DEBUG_PARSING */
Brian Paul7aebaf32005-10-30 21:23:23 +00003390
3391
3392/**
Jouk Jansen40322e12004-04-05 08:50:36 +00003393 * The main loop for parsing a fragment or vertex program
3394 *
Brian Paul72030e02005-11-03 03:30:34 +00003395 * \return 1 on error, 0 on success
Jouk Jansen40322e12004-04-05 08:50:36 +00003396 */
Brian Paul72030e02005-11-03 03:30:34 +00003397static GLint
Brian Paula088f162006-09-05 23:08:51 +00003398parse_instructions(GLcontext * ctx, const GLubyte * inst,
3399 struct var_cache **vc_head, struct arb_program *Program)
Jouk Jansen40322e12004-04-05 08:50:36 +00003400{
Brian Paul72030e02005-11-03 03:30:34 +00003401 const GLuint maxInst = (Program->Base.Target == GL_FRAGMENT_PROGRAM_ARB)
3402 ? ctx->Const.FragmentProgram.MaxInstructions
3403 : ctx->Const.VertexProgram.MaxInstructions;
Jouk Jansen40322e12004-04-05 08:50:36 +00003404 GLint err = 0;
3405
Brian Paul72030e02005-11-03 03:30:34 +00003406 ASSERT(MAX_INSTRUCTIONS >= maxInst);
3407
Jouk Jansen40322e12004-04-05 08:50:36 +00003408 Program->MajorVersion = (GLuint) * inst++;
3409 Program->MinorVersion = (GLuint) * inst++;
3410
3411 while (*inst != END) {
3412 switch (*inst++) {
3413
3414 case OPTION:
3415 switch (*inst++) {
3416 case ARB_PRECISION_HINT_FASTEST:
3417 Program->PrecisionOption = GL_FASTEST;
3418 break;
3419
3420 case ARB_PRECISION_HINT_NICEST:
3421 Program->PrecisionOption = GL_NICEST;
3422 break;
3423
3424 case ARB_FOG_EXP:
3425 Program->FogOption = GL_EXP;
3426 break;
3427
3428 case ARB_FOG_EXP2:
3429 Program->FogOption = GL_EXP2;
3430 break;
3431
3432 case ARB_FOG_LINEAR:
3433 Program->FogOption = GL_LINEAR;
3434 break;
3435
3436 case ARB_POSITION_INVARIANT:
3437 if (Program->Base.Target == GL_VERTEX_PROGRAM_ARB)
Brian Paul45cd2f92005-11-03 02:25:10 +00003438 Program->HintPositionInvariant = GL_TRUE;
Jouk Jansen40322e12004-04-05 08:50:36 +00003439 break;
3440
3441 case ARB_FRAGMENT_PROGRAM_SHADOW:
3442 if (Program->Base.Target == GL_FRAGMENT_PROGRAM_ARB) {
3443 /* TODO ARB_fragment_program_shadow code */
3444 }
3445 break;
Michal Krolad22ce82004-10-11 08:13:25 +00003446
3447 case ARB_DRAW_BUFFERS:
3448 if (Program->Base.Target == GL_FRAGMENT_PROGRAM_ARB) {
3449 /* do nothing for now */
3450 }
3451 break;
Ian Romanickbb372f12007-05-16 15:34:22 -07003452
3453 case MESA_TEXTURE_ARRAY:
3454 /* do nothing for now */
3455 break;
Jouk Jansen40322e12004-04-05 08:50:36 +00003456 }
3457 break;
3458
3459 case INSTRUCTION:
Brian Paul72030e02005-11-03 03:30:34 +00003460 /* check length */
3461 if (Program->Base.NumInstructions + 1 >= maxInst) {
Brian Paula088f162006-09-05 23:08:51 +00003462 program_error(ctx, Program->Position,
3463 "Max instruction count exceeded");
Brian Paul72030e02005-11-03 03:30:34 +00003464 return 1;
3465 }
Jouk Jansen40322e12004-04-05 08:50:36 +00003466 Program->Position = parse_position (&inst);
Brian Paul72030e02005-11-03 03:30:34 +00003467 /* parse the current instruction */
Jouk Jansen40322e12004-04-05 08:50:36 +00003468 if (Program->Base.Target == GL_FRAGMENT_PROGRAM_ARB) {
Jouk Jansen40322e12004-04-05 08:50:36 +00003469 err = parse_fp_instruction (ctx, &inst, vc_head, Program,
Brian Paul8c41a142005-11-19 15:36:28 +00003470 &Program->Base.Instructions[Program->Base.NumInstructions]);
Jouk Jansen40322e12004-04-05 08:50:36 +00003471 }
3472 else {
Jouk Jansen40322e12004-04-05 08:50:36 +00003473 err = parse_vp_instruction (ctx, &inst, vc_head, Program,
Brian Paul8c41a142005-11-19 15:36:28 +00003474 &Program->Base.Instructions[Program->Base.NumInstructions]);
Jouk Jansen40322e12004-04-05 08:50:36 +00003475 }
3476
Brian Paul72030e02005-11-03 03:30:34 +00003477 /* increment instuction count */
Jouk Jansen40322e12004-04-05 08:50:36 +00003478 Program->Base.NumInstructions++;
3479 break;
3480
3481 case DECLARATION:
3482 err = parse_declaration (ctx, &inst, vc_head, Program);
3483 break;
3484
3485 default:
3486 break;
3487 }
3488
3489 if (err)
3490 break;
3491 }
3492
3493 /* Finally, tag on an OPCODE_END instruction */
Brian Paul8c41a142005-11-19 15:36:28 +00003494 {
Brian Paul7aebaf32005-10-30 21:23:23 +00003495 const GLuint numInst = Program->Base.NumInstructions;
Brian Pauld6272e02006-10-29 18:03:16 +00003496 _mesa_init_instructions(Program->Base.Instructions + numInst, 1);
Brian Paul8c41a142005-11-19 15:36:28 +00003497 Program->Base.Instructions[numInst].Opcode = OPCODE_END;
Jouk Jansen40322e12004-04-05 08:50:36 +00003498 /* YYY Wrong Position in program, whatever, at least not random -> crash
3499 Program->Position = parse_position (&inst);
3500 */
Brian Paul8c41a142005-11-19 15:36:28 +00003501 Program->Base.Instructions[numInst].StringPos = Program->Position;
Jouk Jansen40322e12004-04-05 08:50:36 +00003502 }
Jouk Jansen40322e12004-04-05 08:50:36 +00003503 Program->Base.NumInstructions++;
3504
Brian Paul05051032005-11-01 04:36:33 +00003505 /*
3506 * Initialize native counts to logical counts. The device driver may
3507 * change them if program is translated into a hardware program.
3508 */
3509 Program->Base.NumNativeInstructions = Program->Base.NumInstructions;
3510 Program->Base.NumNativeTemporaries = Program->Base.NumTemporaries;
3511 Program->Base.NumNativeParameters = Program->Base.NumParameters;
3512 Program->Base.NumNativeAttributes = Program->Base.NumAttributes;
3513 Program->Base.NumNativeAddressRegs = Program->Base.NumAddressRegs;
Brian Paul05051032005-11-01 04:36:33 +00003514
Jouk Jansen40322e12004-04-05 08:50:36 +00003515 return err;
3516}
3517
Brian Paul7aebaf32005-10-30 21:23:23 +00003518
Jouk Jansen40322e12004-04-05 08:50:36 +00003519/* XXX temporary */
Brian5cc12922006-12-14 14:27:05 -07003520LONGSTRING static char core_grammar_text[] =
Brianc223c6b2007-07-04 13:15:20 -06003521#include "shader/grammar/grammar_syn.h"
Jouk Jansen40322e12004-04-05 08:50:36 +00003522;
3523
Brian Paul7aebaf32005-10-30 21:23:23 +00003524
Brian Paul8c41a142005-11-19 15:36:28 +00003525/**
3526 * Set a grammar parameter.
3527 * \param name the grammar parameter
3528 * \param value the new parameter value
3529 * \return 0 if OK, 1 if error
3530 */
3531static int
3532set_reg8 (GLcontext *ctx, grammar id, const char *name, GLubyte value)
Jouk Jansen40322e12004-04-05 08:50:36 +00003533{
3534 char error_msg[300];
3535 GLint error_pos;
3536
Brian Paul8c41a142005-11-19 15:36:28 +00003537 if (grammar_set_reg8 (id, (const byte *) name, value))
Jouk Jansen40322e12004-04-05 08:50:36 +00003538 return 0;
3539
3540 grammar_get_last_error ((byte *) error_msg, 300, &error_pos);
3541 _mesa_set_program_error (ctx, error_pos, error_msg);
3542 _mesa_error (ctx, GL_INVALID_OPERATION, "Grammar Register Error");
3543 return 1;
3544}
3545
Brian Paul8c41a142005-11-19 15:36:28 +00003546
3547/**
3548 * Enable support for the given language option in the parser.
3549 * \return 1 if OK, 0 if error
3550 */
3551static int
3552enable_ext(GLcontext *ctx, grammar id, const char *name)
Jouk Jansen40322e12004-04-05 08:50:36 +00003553{
Brian Paul8c41a142005-11-19 15:36:28 +00003554 return !set_reg8(ctx, id, name, 1);
Jouk Jansen40322e12004-04-05 08:50:36 +00003555}
3556
Brian Paul8c41a142005-11-19 15:36:28 +00003557
3558/**
3559 * Enable parser extensions based on which OpenGL extensions are supported
3560 * by this rendering context.
3561 *
3562 * \return GL_TRUE if OK, GL_FALSE if error.
3563 */
3564static GLboolean
3565enable_parser_extensions(GLcontext *ctx, grammar id)
Jouk Jansen40322e12004-04-05 08:50:36 +00003566{
Brian Paul8c41a142005-11-19 15:36:28 +00003567#if 0
3568 /* These are not supported at this time */
3569 if ((ctx->Extensions.ARB_vertex_blend ||
3570 ctx->Extensions.EXT_vertex_weighting)
Brian Paul43cc1dc2006-09-05 23:11:09 +00003571 && !enable_ext(ctx, id, "vertex_blend"))
Brian Paul8c41a142005-11-19 15:36:28 +00003572 return GL_FALSE;
3573 if (ctx->Extensions.ARB_matrix_palette
3574 && !enable_ext(ctx, id, "matrix_palette"))
3575 return GL_FALSE;
Ian Romanick7b559a92007-06-07 13:58:50 -07003576#endif
Brian Paul8c41a142005-11-19 15:36:28 +00003577 if (ctx->Extensions.ARB_fragment_program_shadow
3578 && !enable_ext(ctx, id, "fragment_program_shadow"))
3579 return GL_FALSE;
Brian Paul8c41a142005-11-19 15:36:28 +00003580 if (ctx->Extensions.EXT_point_parameters
3581 && !enable_ext(ctx, id, "point_parameters"))
3582 return GL_FALSE;
3583 if (ctx->Extensions.EXT_secondary_color
3584 && !enable_ext(ctx, id, "secondary_color"))
3585 return GL_FALSE;
3586 if (ctx->Extensions.EXT_fog_coord
3587 && !enable_ext(ctx, id, "fog_coord"))
3588 return GL_FALSE;
3589 if (ctx->Extensions.NV_texture_rectangle
3590 && !enable_ext(ctx, id, "texture_rectangle"))
3591 return GL_FALSE;
3592 if (ctx->Extensions.ARB_draw_buffers
3593 && !enable_ext(ctx, id, "draw_buffers"))
3594 return GL_FALSE;
Ian Romanickbb372f12007-05-16 15:34:22 -07003595 if (ctx->Extensions.MESA_texture_array
3596 && !enable_ext(ctx, id, "texture_array"))
3597 return GL_FALSE;
Brian Paul3a557502006-09-05 23:15:29 +00003598#if 1
3599 /* hack for Warcraft (see bug 8060) */
3600 enable_ext(ctx, id, "vertex_blend");
3601#endif
3602
Brian Paul8c41a142005-11-19 15:36:28 +00003603 return GL_TRUE;
Jouk Jansen40322e12004-04-05 08:50:36 +00003604}
3605
Brian Paul8c41a142005-11-19 15:36:28 +00003606
Jouk Jansen40322e12004-04-05 08:50:36 +00003607/**
3608 * This kicks everything off.
3609 *
3610 * \param ctx - The GL Context
3611 * \param str - The program string
3612 * \param len - The program string length
Brian Paul45703642005-10-29 15:52:31 +00003613 * \param program - The arb_program struct to return all the parsed info in
3614 * \return GL_TRUE on sucess, GL_FALSE on error
Jouk Jansen40322e12004-04-05 08:50:36 +00003615 */
Brian Paul8c41a142005-11-19 15:36:28 +00003616static GLboolean
3617_mesa_parse_arb_program(GLcontext *ctx, GLenum target,
3618 const GLubyte *str, GLsizei len,
3619 struct arb_program *program)
Jouk Jansen40322e12004-04-05 08:50:36 +00003620{
3621 GLint a, err, error_pos;
3622 char error_msg[300];
3623 GLuint parsed_len;
3624 struct var_cache *vc_head;
3625 grammar arbprogram_syn_id;
3626 GLubyte *parsed, *inst;
3627 GLubyte *strz = NULL;
3628 static int arbprogram_syn_is_ok = 0; /* XXX temporary */
3629
Brian Paul8c41a142005-11-19 15:36:28 +00003630 /* set the program target before parsing */
3631 program->Base.Target = target;
3632
Brian Paul7f76b8f2004-09-10 01:05:39 +00003633 /* Reset error state */
3634 _mesa_set_program_error(ctx, -1, NULL);
3635
Brian Paul8c41a142005-11-19 15:36:28 +00003636 /* check if arb_grammar_text (arbprogram.syn) is syntactically correct */
Jouk Jansen40322e12004-04-05 08:50:36 +00003637 if (!arbprogram_syn_is_ok) {
Brian Paul8c41a142005-11-19 15:36:28 +00003638 /* One-time initialization of parsing system */
Jouk Jansen40322e12004-04-05 08:50:36 +00003639 grammar grammar_syn_id;
Jouk Jansen40322e12004-04-05 08:50:36 +00003640 GLuint parsed_len;
Jouk Jansen40322e12004-04-05 08:50:36 +00003641
3642 grammar_syn_id = grammar_load_from_text ((byte *) core_grammar_text);
3643 if (grammar_syn_id == 0) {
3644 grammar_get_last_error ((byte *) error_msg, 300, &error_pos);
Brian Paul8c41a142005-11-19 15:36:28 +00003645 /* XXX this is not a GL error - it's an implementation bug! - FIX */
Jouk Jansen40322e12004-04-05 08:50:36 +00003646 _mesa_set_program_error (ctx, error_pos, error_msg);
3647 _mesa_error (ctx, GL_INVALID_OPERATION,
Brian Paul8c41a142005-11-19 15:36:28 +00003648 "glProgramStringARB(Error loading grammar rule set)");
Brian Paul45703642005-10-29 15:52:31 +00003649 return GL_FALSE;
Jouk Jansen40322e12004-04-05 08:50:36 +00003650 }
3651
Brian Paul8c41a142005-11-19 15:36:28 +00003652 err = !grammar_check(grammar_syn_id, (byte *) arb_grammar_text,
3653 &parsed, &parsed_len);
Jouk Jansen40322e12004-04-05 08:50:36 +00003654
Brian Paul49a80ca2006-04-28 15:40:11 +00003655 /* 'parsed' is unused here */
3656 _mesa_free (parsed);
3657 parsed = NULL;
3658
Brian Paul45703642005-10-29 15:52:31 +00003659 /* NOTE: we can't destroy grammar_syn_id right here because
3660 * grammar_destroy() can reset the last error
3661 */
Brian Paul8c41a142005-11-19 15:36:28 +00003662 if (err) {
3663 /* XXX this is not a GL error - it's an implementation bug! - FIX */
Jouk Jansen40322e12004-04-05 08:50:36 +00003664 grammar_get_last_error ((byte *) error_msg, 300, &error_pos);
3665 _mesa_set_program_error (ctx, error_pos, error_msg);
Brian Paul8c41a142005-11-19 15:36:28 +00003666 _mesa_error (ctx, GL_INVALID_OPERATION,
3667 "glProgramString(Error loading grammar rule set");
Jouk Jansen40322e12004-04-05 08:50:36 +00003668 grammar_destroy (grammar_syn_id);
Brian Paul45703642005-10-29 15:52:31 +00003669 return GL_FALSE;
Jouk Jansen40322e12004-04-05 08:50:36 +00003670 }
3671
3672 grammar_destroy (grammar_syn_id);
3673
3674 arbprogram_syn_is_ok = 1;
3675 }
3676
3677 /* create the grammar object */
3678 arbprogram_syn_id = grammar_load_from_text ((byte *) arb_grammar_text);
3679 if (arbprogram_syn_id == 0) {
Brian Paul8c41a142005-11-19 15:36:28 +00003680 /* XXX this is not a GL error - it's an implementation bug! - FIX */
Jouk Jansen40322e12004-04-05 08:50:36 +00003681 grammar_get_last_error ((GLubyte *) error_msg, 300, &error_pos);
3682 _mesa_set_program_error (ctx, error_pos, error_msg);
3683 _mesa_error (ctx, GL_INVALID_OPERATION,
Brian Paul8c41a142005-11-19 15:36:28 +00003684 "glProgramString(Error loading grammer rule set)");
Brian Paul45703642005-10-29 15:52:31 +00003685 return GL_FALSE;
Jouk Jansen40322e12004-04-05 08:50:36 +00003686 }
3687
3688 /* Set program_target register value */
Brian Paul55194df2005-11-19 23:29:18 +00003689 if (set_reg8 (ctx, arbprogram_syn_id, "program_target",
Jouk Jansen40322e12004-04-05 08:50:36 +00003690 program->Base.Target == GL_FRAGMENT_PROGRAM_ARB ? 0x10 : 0x20)) {
3691 grammar_destroy (arbprogram_syn_id);
Brian Paul45703642005-10-29 15:52:31 +00003692 return GL_FALSE;
Jouk Jansen40322e12004-04-05 08:50:36 +00003693 }
3694
Brian Paul8c41a142005-11-19 15:36:28 +00003695 if (!enable_parser_extensions(ctx, arbprogram_syn_id)) {
3696 grammar_destroy(arbprogram_syn_id);
Brian Paul45703642005-10-29 15:52:31 +00003697 return GL_FALSE;
Jouk Jansen40322e12004-04-05 08:50:36 +00003698 }
3699
3700 /* check for NULL character occurences */
3701 {
Brian Paul8c41a142005-11-19 15:36:28 +00003702 GLint i;
3703 for (i = 0; i < len; i++) {
Jouk Jansen40322e12004-04-05 08:50:36 +00003704 if (str[i] == '\0') {
Brian Paula088f162006-09-05 23:08:51 +00003705 program_error(ctx, i, "illegal character");
Jouk Jansen40322e12004-04-05 08:50:36 +00003706 grammar_destroy (arbprogram_syn_id);
Brian Paul45703642005-10-29 15:52:31 +00003707 return GL_FALSE;
Jouk Jansen40322e12004-04-05 08:50:36 +00003708 }
Brian Paul8c41a142005-11-19 15:36:28 +00003709 }
Jouk Jansen40322e12004-04-05 08:50:36 +00003710 }
3711
3712 /* copy the program string to a null-terminated string */
Brian Paulbdd15b52004-05-04 15:11:06 +00003713 strz = (GLubyte *) _mesa_malloc (len + 1);
Brian Paul45703642005-10-29 15:52:31 +00003714 if (!strz) {
Brian Paul8c41a142005-11-19 15:36:28 +00003715 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glProgramStringARB");
3716 grammar_destroy (arbprogram_syn_id);
Brian Paul45703642005-10-29 15:52:31 +00003717 return GL_FALSE;
3718 }
Jouk Jansen40322e12004-04-05 08:50:36 +00003719 _mesa_memcpy (strz, str, len);
3720 strz[len] = '\0';
3721
Michal Krolb80bc052004-10-21 14:09:54 +00003722 /* do a fast check on program string - initial production buffer is 4K */
Brian Paul8c41a142005-11-19 15:36:28 +00003723 err = !grammar_fast_check(arbprogram_syn_id, strz,
3724 &parsed, &parsed_len, 0x1000);
Jouk Jansen40322e12004-04-05 08:50:36 +00003725
3726 /* Syntax parse error */
Brian Paul8c41a142005-11-19 15:36:28 +00003727 if (err) {
Brian Paula088f162006-09-05 23:08:51 +00003728 grammar_get_last_error((GLubyte *) error_msg, 300, &error_pos);
3729 program_error(ctx, error_pos, error_msg);
Brian Paul5fe90292004-07-20 21:15:13 +00003730
Brian Paulb3aefd12005-09-19 20:12:32 +00003731#if DEBUG_PARSING
Brian Paula088f162006-09-05 23:08:51 +00003732 /* useful for debugging */
Brian Paulb3aefd12005-09-19 20:12:32 +00003733 do {
Brian Paul5fe90292004-07-20 21:15:13 +00003734 int line, col;
3735 char *s;
Brian Paul45703642005-10-29 15:52:31 +00003736 fprintf(stderr, "program: %s\n", (char *) strz);
Brian5052dab2008-03-27 16:05:40 -06003737 fprintf(stderr, "Error Pos: %d\n", ctx->Program.ErrorPos);
3738 s = (char *) _mesa_find_line_column(strz, strz+ctx->Program.ErrorPos,
Brian Paula088f162006-09-05 23:08:51 +00003739 &line, &col);
Brian Paulb3aefd12005-09-19 20:12:32 +00003740 fprintf(stderr, "line %d col %d: %s\n", line, col, s);
Brian5052dab2008-03-27 16:05:40 -06003741 } while (0);
Brian Paulb3aefd12005-09-19 20:12:32 +00003742#endif
Brian Paul5fe90292004-07-20 21:15:13 +00003743
Brian Paula088f162006-09-05 23:08:51 +00003744 _mesa_free(strz);
3745 _mesa_free(parsed);
3746
Jouk Jansen40322e12004-04-05 08:50:36 +00003747 grammar_destroy (arbprogram_syn_id);
Brian Paul45703642005-10-29 15:52:31 +00003748 return GL_FALSE;
Jouk Jansen40322e12004-04-05 08:50:36 +00003749 }
3750
Jouk Jansen40322e12004-04-05 08:50:36 +00003751 grammar_destroy (arbprogram_syn_id);
3752
Brian Paul8c41a142005-11-19 15:36:28 +00003753 /*
3754 * Program string is syntactically correct at this point
3755 * Parse the tokenized version of the program now, generating
3756 * vertex/fragment program instructions.
3757 */
3758
Jouk Jansen40322e12004-04-05 08:50:36 +00003759 /* Initialize the arb_program struct */
3760 program->Base.String = strz;
Brian Paul383c39e2006-08-25 15:14:25 +00003761 program->Base.Instructions = _mesa_alloc_instructions(MAX_INSTRUCTIONS);
Jouk Jansen40322e12004-04-05 08:50:36 +00003762 program->Base.NumInstructions =
3763 program->Base.NumTemporaries =
3764 program->Base.NumParameters =
3765 program->Base.NumAttributes = program->Base.NumAddressRegs = 0;
Brian Paulde997602005-11-12 17:53:14 +00003766 program->Base.Parameters = _mesa_new_parameter_list ();
3767 program->Base.InputsRead = 0x0;
3768 program->Base.OutputsWritten = 0x0;
Jouk Jansen40322e12004-04-05 08:50:36 +00003769 program->Position = 0;
3770 program->MajorVersion = program->MinorVersion = 0;
3771 program->PrecisionOption = GL_DONT_CARE;
3772 program->FogOption = GL_NONE;
3773 program->HintPositionInvariant = GL_FALSE;
3774 for (a = 0; a < MAX_TEXTURE_IMAGE_UNITS; a++)
Brian Paul45cd2f92005-11-03 02:25:10 +00003775 program->TexturesUsed[a] = 0x0;
Ian Romanick7b559a92007-06-07 13:58:50 -07003776 program->ShadowSamplers = 0x0;
Jouk Jansen40322e12004-04-05 08:50:36 +00003777 program->NumAluInstructions =
3778 program->NumTexInstructions =
3779 program->NumTexIndirections = 0;
Keith Whitwellc3626a92005-11-01 17:25:49 +00003780 program->UsesKill = 0;
3781
Jouk Jansen40322e12004-04-05 08:50:36 +00003782 vc_head = NULL;
Brian Paul45703642005-10-29 15:52:31 +00003783 err = GL_FALSE;
Jouk Jansen40322e12004-04-05 08:50:36 +00003784
3785 /* Start examining the tokens in the array */
3786 inst = parsed;
3787
3788 /* Check the grammer rev */
3789 if (*inst++ != REVISION) {
Brian Paula088f162006-09-05 23:08:51 +00003790 program_error (ctx, 0, "Grammar version mismatch");
Brian Paul45703642005-10-29 15:52:31 +00003791 err = GL_TRUE;
Jouk Jansen40322e12004-04-05 08:50:36 +00003792 }
3793 else {
Michal Krolb80bc052004-10-21 14:09:54 +00003794 /* ignore program target */
3795 inst++;
Brian Paul8c41a142005-11-19 15:36:28 +00003796 err = parse_instructions(ctx, inst, &vc_head, program);
Jouk Jansen40322e12004-04-05 08:50:36 +00003797 }
3798
3799 /*debug_variables(ctx, vc_head, program); */
3800
3801 /* We're done with the parsed binary array */
3802 var_cache_destroy (&vc_head);
3803
3804 _mesa_free (parsed);
Brian Paul45703642005-10-29 15:52:31 +00003805
Brian Paul8c41a142005-11-19 15:36:28 +00003806 /* Reallocate the instruction array from size [MAX_INSTRUCTIONS]
3807 * to size [ap.Base.NumInstructions].
3808 */
Brian Paula7543902006-08-24 21:58:32 +00003809 program->Base.Instructions
3810 = _mesa_realloc_instructions(program->Base.Instructions,
3811 MAX_INSTRUCTIONS,
3812 program->Base.NumInstructions);
3813
Brian Paul45703642005-10-29 15:52:31 +00003814 return !err;
Jouk Jansen40322e12004-04-05 08:50:36 +00003815}
Brian Paul8c41a142005-11-19 15:36:28 +00003816
3817
3818
3819void
3820_mesa_parse_arb_fragment_program(GLcontext* ctx, GLenum target,
3821 const GLvoid *str, GLsizei len,
Brian Paul122629f2006-07-20 16:49:57 +00003822 struct gl_fragment_program *program)
Brian Paul8c41a142005-11-19 15:36:28 +00003823{
3824 struct arb_program ap;
3825 GLuint i;
3826
3827 ASSERT(target == GL_FRAGMENT_PROGRAM_ARB);
Brian Paul95801792005-12-06 15:41:43 +00003828 if (!_mesa_parse_arb_program(ctx, target, (const GLubyte*) str, len, &ap)) {
Brian Paul8c41a142005-11-19 15:36:28 +00003829 /* Error in the program. Just return. */
3830 return;
3831 }
3832
3833 /* Copy the relevant contents of the arb_program struct into the
3834 * fragment_program struct.
3835 */
3836 program->Base.String = ap.Base.String;
3837 program->Base.NumInstructions = ap.Base.NumInstructions;
3838 program->Base.NumTemporaries = ap.Base.NumTemporaries;
3839 program->Base.NumParameters = ap.Base.NumParameters;
3840 program->Base.NumAttributes = ap.Base.NumAttributes;
3841 program->Base.NumAddressRegs = ap.Base.NumAddressRegs;
Roland Scheideggere6de1ed2006-08-30 11:55:18 +00003842 program->Base.NumNativeInstructions = ap.Base.NumNativeInstructions;
3843 program->Base.NumNativeTemporaries = ap.Base.NumNativeTemporaries;
3844 program->Base.NumNativeParameters = ap.Base.NumNativeParameters;
3845 program->Base.NumNativeAttributes = ap.Base.NumNativeAttributes;
3846 program->Base.NumNativeAddressRegs = ap.Base.NumNativeAddressRegs;
Brian21f99792007-01-09 11:00:21 -07003847 program->Base.NumAluInstructions = ap.Base.NumAluInstructions;
3848 program->Base.NumTexInstructions = ap.Base.NumTexInstructions;
3849 program->Base.NumTexIndirections = ap.Base.NumTexIndirections;
3850 program->Base.NumNativeAluInstructions = ap.Base.NumAluInstructions;
3851 program->Base.NumNativeTexInstructions = ap.Base.NumTexInstructions;
3852 program->Base.NumNativeTexIndirections = ap.Base.NumTexIndirections;
Brian Paul8c41a142005-11-19 15:36:28 +00003853 program->Base.InputsRead = ap.Base.InputsRead;
3854 program->Base.OutputsWritten = ap.Base.OutputsWritten;
Briand1284d32008-03-12 15:33:41 -06003855 for (i = 0; i < MAX_TEXTURE_IMAGE_UNITS; i++) {
Brianc9db2232007-01-04 17:22:19 -07003856 program->Base.TexturesUsed[i] = ap.TexturesUsed[i];
Briand1284d32008-03-12 15:33:41 -06003857 if (ap.TexturesUsed[i])
3858 program->Base.SamplersUsed |= (1 << i);
3859 }
Ian Romanick7b559a92007-06-07 13:58:50 -07003860 program->Base.ShadowSamplers = ap.ShadowSamplers;
Brian Paul8c41a142005-11-19 15:36:28 +00003861 program->FogOption = ap.FogOption;
Keith Whitwell7ecdfb22007-03-04 21:47:05 +00003862 program->UsesKill = ap.UsesKill;
Brian Paul8c41a142005-11-19 15:36:28 +00003863
3864 if (program->Base.Instructions)
3865 _mesa_free(program->Base.Instructions);
3866 program->Base.Instructions = ap.Base.Instructions;
3867
3868 if (program->Base.Parameters)
3869 _mesa_free_parameter_list(program->Base.Parameters);
3870 program->Base.Parameters = ap.Base.Parameters;
3871
Brian Paulc0ef1662008-03-25 11:32:31 -06003872 /* Append fog instructions now if the program has "OPTION ARB_fog_exp"
3873 * or similar. We used to leave this up to drivers, but it appears
3874 * there's no hardware that wants to do fog in a discrete stage separate
3875 * from the fragment shader.
3876 */
3877 if (program->FogOption != GL_NONE) {
3878 _mesa_append_fog_code(ctx, program);
3879 program->FogOption = GL_NONE;
3880 }
3881
Brian Paul8c41a142005-11-19 15:36:28 +00003882#if DEBUG_FP
Brian Paul11a54c32006-11-15 19:54:25 +00003883 _mesa_printf("____________Fragment program %u ________\n", program->Base.ID);
3884 _mesa_print_program(&program->Base);
Brian Paul8c41a142005-11-19 15:36:28 +00003885#endif
3886}
3887
3888
3889
3890/**
3891 * Parse the vertex program string. If success, update the given
3892 * vertex_program object with the new program. Else, leave the vertex_program
3893 * object unchanged.
3894 */
3895void
3896_mesa_parse_arb_vertex_program(GLcontext *ctx, GLenum target,
3897 const GLvoid *str, GLsizei len,
Brian Paul122629f2006-07-20 16:49:57 +00003898 struct gl_vertex_program *program)
Brian Paul8c41a142005-11-19 15:36:28 +00003899{
3900 struct arb_program ap;
3901
3902 ASSERT(target == GL_VERTEX_PROGRAM_ARB);
3903
Brian Paul95801792005-12-06 15:41:43 +00003904 if (!_mesa_parse_arb_program(ctx, target, (const GLubyte*) str, len, &ap)) {
Briand46ac952008-03-27 16:04:20 -06003905 _mesa_error(ctx, GL_INVALID_OPERATION, "glProgramString(bad program)");
Brian Paul8c41a142005-11-19 15:36:28 +00003906 return;
3907 }
3908
3909 /* Copy the relevant contents of the arb_program struct into the
3910 * vertex_program struct.
3911 */
3912 program->Base.String = ap.Base.String;
3913 program->Base.NumInstructions = ap.Base.NumInstructions;
3914 program->Base.NumTemporaries = ap.Base.NumTemporaries;
3915 program->Base.NumParameters = ap.Base.NumParameters;
3916 program->Base.NumAttributes = ap.Base.NumAttributes;
3917 program->Base.NumAddressRegs = ap.Base.NumAddressRegs;
Roland Scheideggere6de1ed2006-08-30 11:55:18 +00003918 program->Base.NumNativeInstructions = ap.Base.NumNativeInstructions;
3919 program->Base.NumNativeTemporaries = ap.Base.NumNativeTemporaries;
3920 program->Base.NumNativeParameters = ap.Base.NumNativeParameters;
3921 program->Base.NumNativeAttributes = ap.Base.NumNativeAttributes;
3922 program->Base.NumNativeAddressRegs = ap.Base.NumNativeAddressRegs;
Brian Paul8c41a142005-11-19 15:36:28 +00003923 program->Base.InputsRead = ap.Base.InputsRead;
3924 program->Base.OutputsWritten = ap.Base.OutputsWritten;
3925 program->IsPositionInvariant = ap.HintPositionInvariant;
3926
3927 if (program->Base.Instructions)
3928 _mesa_free(program->Base.Instructions);
3929 program->Base.Instructions = ap.Base.Instructions;
3930
3931 if (program->Base.Parameters)
3932 _mesa_free_parameter_list(program->Base.Parameters);
3933 program->Base.Parameters = ap.Base.Parameters;
3934
3935#if DEBUG_VP
Roland Scheidegger54dac2c2007-02-09 00:36:40 +01003936 _mesa_printf("____________Vertex program %u __________\n", program->Base.Id);
Brian Paul8c41a142005-11-19 15:36:28 +00003937 _mesa_print_program(&program->Base);
3938#endif
3939}