2 * Mesa 3-D graphics library
5 * Copyright (C) 1999-2005 Brian Paul All Rights Reserved.
7 * Permission is hereby granted, free of charge, to any person obtaining a
8 * copy of this software and associated documentation files (the "Software"),
9 * to deal in the Software without restriction, including without limitation
10 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
11 * and/or sell copies of the Software, and to permit persons to whom the
12 * Software is furnished to do so, subject to the following conditions:
14 * The above copyright notice and this permission notice shall be included
15 * in all copies or substantial portions of the Software.
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
18 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
21 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
22 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
27 * NVIDIA fragment program parser.
32 * Regarding GL_NV_fragment_program:
34 * Portions of this software may use or implement intellectual
35 * property owned and licensed by NVIDIA Corporation. NVIDIA disclaims
36 * any and all warranties with respect to such intellectual property,
37 * including any use thereof or modifications thereto.
40 #include "main/glheader.h"
41 #include "main/context.h"
42 #include "main/imports.h"
43 #include "main/macros.h"
45 #include "prog_parameter.h"
46 #include "prog_print.h"
47 #include "prog_instruction.h"
48 #include "nvfragparse.h"
57 #define INPUT_1V_T 7 /* one source vector, plus textureId */
58 #define INPUT_3V_T 8 /* one source vector, plus textureId */
60 #define INPUT_1V_S 10 /* a string and a vector register */
63 #define OUTPUT_NONE 22
65 /* IRIX defines some of these */
72 /* Optional suffixes */
73 #define _R FLOAT32 /* float */
74 #define _H FLOAT16 /* half-float */
75 #define _X FIXED12 /* fixed */
76 #define _C 0x08 /* set cond codes */
77 #define _S 0x10 /* saturate, clamp result to [0,1] */
79 struct instruction_pattern {
81 enum prog_opcode opcode;
87 static const struct instruction_pattern Instructions[] = {
88 { "ADD", OPCODE_ADD, INPUT_2V, OUTPUT_V, _R | _H | _X | _C | _S },
89 { "COS", OPCODE_COS, INPUT_1S, OUTPUT_S, _R | _H | _C | _S },
90 { "DDX", OPCODE_DDX, INPUT_1V, OUTPUT_V, _R | _H | _C | _S },
91 { "DDY", OPCODE_DDY, INPUT_1V, OUTPUT_V, _R | _H | _C | _S },
92 { "DP3", OPCODE_DP3, INPUT_2V, OUTPUT_S, _R | _H | _X | _C | _S },
93 { "DP4", OPCODE_DP4, INPUT_2V, OUTPUT_S, _R | _H | _X | _C | _S },
94 { "DST", OPCODE_DP4, INPUT_2V, OUTPUT_V, _R | _H | _C | _S },
95 { "EX2", OPCODE_DP4, INPUT_1S, OUTPUT_S, _R | _H | _C | _S },
96 { "FLR", OPCODE_FLR, INPUT_1V, OUTPUT_V, _R | _H | _X | _C | _S },
97 { "FRC", OPCODE_FRC, INPUT_1V, OUTPUT_V, _R | _H | _X | _C | _S },
98 { "KIL", OPCODE_KIL_NV, INPUT_CC, OUTPUT_NONE, 0 },
99 { "LG2", OPCODE_LG2, INPUT_1S, OUTPUT_S, _R | _H | _C | _S },
100 { "LIT", OPCODE_LIT, INPUT_1V, OUTPUT_V, _R | _H | _C | _S },
101 { "LRP", OPCODE_LRP, INPUT_3V, OUTPUT_V, _R | _H | _X | _C | _S },
102 { "MAD", OPCODE_MAD, INPUT_3V, OUTPUT_V, _R | _H | _X | _C | _S },
103 { "MAX", OPCODE_MAX, INPUT_2V, OUTPUT_V, _R | _H | _X | _C | _S },
104 { "MIN", OPCODE_MIN, INPUT_2V, OUTPUT_V, _R | _H | _X | _C | _S },
105 { "MOV", OPCODE_MOV, INPUT_1V, OUTPUT_V, _R | _H | _X | _C | _S },
106 { "MUL", OPCODE_MUL, INPUT_2V, OUTPUT_V, _R | _H | _X | _C | _S },
107 { "PK2H", OPCODE_PK2H, INPUT_1V, OUTPUT_S, 0 },
108 { "PK2US", OPCODE_PK2US, INPUT_1V, OUTPUT_S, 0 },
109 { "PK4B", OPCODE_PK4B, INPUT_1V, OUTPUT_S, 0 },
110 { "PK4UB", OPCODE_PK4UB, INPUT_1V, OUTPUT_S, 0 },
111 { "POW", OPCODE_POW, INPUT_2S, OUTPUT_S, _R | _H | _C | _S },
112 { "RCP", OPCODE_RCP, INPUT_1S, OUTPUT_S, _R | _H | _C | _S },
113 { "RFL", OPCODE_RFL, INPUT_2V, OUTPUT_V, _R | _H | _C | _S },
114 { "RSQ", OPCODE_RSQ, INPUT_1S, OUTPUT_S, _R | _H | _C | _S },
115 { "SEQ", OPCODE_SEQ, INPUT_2V, OUTPUT_V, _R | _H | _X | _C | _S },
116 { "SFL", OPCODE_SFL, INPUT_2V, OUTPUT_V, _R | _H | _X | _C | _S },
117 { "SGE", OPCODE_SGE, INPUT_2V, OUTPUT_V, _R | _H | _X | _C | _S },
118 { "SGT", OPCODE_SGT, INPUT_2V, OUTPUT_V, _R | _H | _X | _C | _S },
119 { "SIN", OPCODE_SIN, INPUT_1S, OUTPUT_S, _R | _H | _C | _S },
120 { "SLE", OPCODE_SLE, INPUT_2V, OUTPUT_V, _R | _H | _X | _C | _S },
121 { "SLT", OPCODE_SLT, INPUT_2V, OUTPUT_V, _R | _H | _X | _C | _S },
122 { "SNE", OPCODE_SNE, INPUT_2V, OUTPUT_V, _R | _H | _X | _C | _S },
123 { "STR", OPCODE_STR, INPUT_2V, OUTPUT_V, _R | _H | _X | _C | _S },
124 { "SUB", OPCODE_SUB, INPUT_2V, OUTPUT_V, _R | _H | _X | _C | _S },
125 { "TEX", OPCODE_TEX, INPUT_1V_T, OUTPUT_V, _C | _S },
126 { "TXD", OPCODE_TXD, INPUT_3V_T, OUTPUT_V, _C | _S },
127 { "TXP", OPCODE_TXP_NV, INPUT_1V_T, OUTPUT_V, _C | _S },
128 { "UP2H", OPCODE_UP2H, INPUT_1S, OUTPUT_V, _C | _S },
129 { "UP2US", OPCODE_UP2US, INPUT_1S, OUTPUT_V, _C | _S },
130 { "UP4B", OPCODE_UP4B, INPUT_1S, OUTPUT_V, _C | _S },
131 { "UP4UB", OPCODE_UP4UB, INPUT_1S, OUTPUT_V, _C | _S },
132 { "X2D", OPCODE_X2D, INPUT_3V, OUTPUT_V, _R | _H | _C | _S },
133 { "PRINT", OPCODE_PRINT, INPUT_1V_S, OUTPUT_NONE, 0 },
134 { NULL, (enum prog_opcode) -1, 0, 0, 0 }
139 * Information needed or computed during parsing.
140 * Remember, we can't modify the target program object until we've
141 * _successfully_ parsed the program text.
144 struct gl_context *ctx;
145 const GLubyte *start; /* start of program string */
146 const GLubyte *pos; /* current position */
147 const GLubyte *curLine;
148 struct gl_fragment_program *program; /* current program */
150 struct gl_program_parameter_list *parameters;
152 GLuint numInst; /* number of instructions parsed */
153 GLuint inputsRead; /* bitmask of input registers used */
154 GLuint outputsWritten; /* bitmask of 1 << FRAG_OUTPUT_* bits */
155 GLuint texturesUsed[MAX_TEXTURE_IMAGE_UNITS];
161 * Called whenever we find an error during parsing.
164 record_error(struct parse_state *parseState, const char *msg, int lineNo)
168 const GLubyte *lineStr;
169 lineStr = _mesa_find_line_column(parseState->start,
170 parseState->pos, &line, &column);
171 _mesa_debug(parseState->ctx,
172 "nvfragparse.c(%d): line %d, column %d:%s (%s)\n",
173 lineNo, line, column, (char *) lineStr, msg);
174 free((void *) lineStr);
179 /* Check that no error was already recorded. Only record the first one. */
180 if (parseState->ctx->Program.ErrorString[0] == 0) {
181 _mesa_set_program_error(parseState->ctx,
182 parseState->pos - parseState->start,
188 #define RETURN_ERROR \
190 record_error(parseState, "Unexpected end of input.", __LINE__); \
194 #define RETURN_ERROR1(msg) \
196 record_error(parseState, msg, __LINE__); \
200 #define RETURN_ERROR2(msg1, msg2) \
203 sprintf(err, "%s %s", msg1, msg2); \
204 record_error(parseState, err, __LINE__); \
212 * Search a list of instruction structures for a match.
214 static struct instruction_pattern
215 MatchInstruction(const GLubyte *token)
217 const struct instruction_pattern *inst;
218 struct instruction_pattern result;
221 result.opcode = MAX_OPCODE; /* i.e. invalid instruction */
226 for (inst = Instructions; inst->name; inst++) {
227 if (strncmp((const char *) token, inst->name, 3) == 0) {
233 if (token[i] == 'R') {
234 result.suffixes |= _R;
237 else if (token[i] == 'H') {
238 result.suffixes |= _H;
241 else if (token[i] == 'X') {
242 result.suffixes |= _X;
245 if (token[i] == 'C') {
246 result.suffixes |= _C;
249 if (token[i] == '_' && token[i+1] == 'S' &&
250 token[i+2] == 'A' && token[i+3] == 'T') {
251 result.suffixes |= _S;
263 /**********************************************************************/
266 static GLboolean IsLetter(GLubyte b)
268 return (b >= 'a' && b <= 'z') ||
269 (b >= 'A' && b <= 'Z') ||
275 static GLboolean IsDigit(GLubyte b)
277 return b >= '0' && b <= '9';
281 static GLboolean IsWhitespace(GLubyte b)
283 return b == ' ' || b == '\t' || b == '\n' || b == '\r';
288 * Starting at 'str' find the next token. A token can be an integer,
289 * an identifier or punctuation symbol.
290 * \return <= 0 we found an error, else, return number of characters parsed.
293 GetToken(struct parse_state *parseState, GLubyte *token)
295 const GLubyte *str = parseState->pos;
300 /* skip whitespace and comments */
301 while (str[i] && (IsWhitespace(str[i]) || str[i] == '#')) {
304 while (str[i] && (str[i] != '\n' && str[i] != '\r')) {
307 if (str[i] == '\n' || str[i] == '\r')
308 parseState->curLine = str + i + 1;
311 /* skip whitespace */
312 if (str[i] == '\n' || str[i] == '\r')
313 parseState->curLine = str + i + 1;
321 /* try matching an integer */
322 while (str[i] && IsDigit(str[i])) {
323 token[j++] = str[i++];
325 if (j > 0 || !str[i]) {
330 /* try matching an identifier */
331 if (IsLetter(str[i])) {
332 while (str[i] && (IsLetter(str[i]) || IsDigit(str[i]))) {
333 token[j++] = str[i++];
339 /* punctuation character */
353 * Get next token from input stream and increment stream pointer past token.
356 Parse_Token(struct parse_state *parseState, GLubyte *token)
359 i = GetToken(parseState, token);
361 parseState->pos += (-i);
364 parseState->pos += i;
370 * Get next token from input stream but don't increment stream pointer.
373 Peek_Token(struct parse_state *parseState, GLubyte *token)
376 i = GetToken(parseState, token);
378 parseState->pos += (-i);
381 len = (GLint) strlen((const char *) token);
382 parseState->pos += (i - len);
387 /**********************************************************************/
389 static const char *InputRegisters[MAX_NV_FRAGMENT_PROGRAM_INPUTS + 1] = {
390 "WPOS", "COL0", "COL1", "FOGC",
391 "TEX0", "TEX1", "TEX2", "TEX3", "TEX4", "TEX5", "TEX6", "TEX7", NULL
396 /**********************************************************************/
399 * Try to match 'pattern' as the next token after any whitespace/comments.
402 Parse_String(struct parse_state *parseState, const char *pattern)
407 /* skip whitespace and comments */
408 while (IsWhitespace(*parseState->pos) || *parseState->pos == '#') {
409 if (*parseState->pos == '#') {
410 while (*parseState->pos && (*parseState->pos != '\n' && *parseState->pos != '\r')) {
411 parseState->pos += 1;
413 if (*parseState->pos == '\n' || *parseState->pos == '\r')
414 parseState->curLine = parseState->pos + 1;
417 /* skip whitespace */
418 if (*parseState->pos == '\n' || *parseState->pos == '\r')
419 parseState->curLine = parseState->pos + 1;
420 parseState->pos += 1;
424 /* Try to match the pattern */
426 for (i = 0; pattern[i]; i++) {
427 if (*m != (GLubyte) pattern[i])
433 return GL_TRUE; /* success */
438 Parse_Identifier(struct parse_state *parseState, GLubyte *ident)
440 if (!Parse_Token(parseState, ident))
442 if (IsLetter(ident[0]))
445 RETURN_ERROR1("Expected an identfier");
450 * Parse a floating point constant, or a defined symbol name.
452 * Output: number[0 .. 3] will get the value.
455 Parse_ScalarConstant(struct parse_state *parseState, GLfloat *number)
459 *number = (GLfloat) _mesa_strtof((const char *) parseState->pos, &end);
461 if (end && end > (char *) parseState->pos) {
463 parseState->pos = (GLubyte *) end;
470 /* should be an identifier */
472 const GLfloat *constant;
473 if (!Parse_Identifier(parseState, ident))
474 RETURN_ERROR1("Expected an identifier");
475 constant = _mesa_lookup_parameter_value(parseState->parameters,
476 -1, (const char *) ident);
477 /* XXX Check that it's a constant and not a parameter */
479 RETURN_ERROR1("Undefined symbol");
482 COPY_4V(number, constant);
491 * Parse a vector constant, one of:
494 * { float, float, float }
495 * { float, float, float, float }
498 Parse_VectorConstant(struct parse_state *parseState, GLfloat *vec)
500 /* "{" was already consumed */
502 ASSIGN_4V(vec, 0.0, 0.0, 0.0, 1.0);
504 if (!Parse_ScalarConstant(parseState, vec+0)) /* X */
507 if (Parse_String(parseState, "}")) {
511 if (!Parse_String(parseState, ","))
512 RETURN_ERROR1("Expected comma in vector constant");
514 if (!Parse_ScalarConstant(parseState, vec+1)) /* Y */
517 if (Parse_String(parseState, "}")) {
521 if (!Parse_String(parseState, ","))
522 RETURN_ERROR1("Expected comma in vector constant");
524 if (!Parse_ScalarConstant(parseState, vec+2)) /* Z */
527 if (Parse_String(parseState, "}")) {
531 if (!Parse_String(parseState, ","))
532 RETURN_ERROR1("Expected comma in vector constant");
534 if (!Parse_ScalarConstant(parseState, vec+3)) /* W */
537 if (!Parse_String(parseState, "}"))
538 RETURN_ERROR1("Expected closing brace in vector constant");
545 * Parse <number>, <varname> or {a, b, c, d}.
546 * Return number of values in the vector or scalar, or zero if parse error.
549 Parse_VectorOrScalarConstant(struct parse_state *parseState, GLfloat *vec)
551 if (Parse_String(parseState, "{")) {
552 return Parse_VectorConstant(parseState, vec);
555 GLboolean b = Parse_ScalarConstant(parseState, vec);
557 vec[1] = vec[2] = vec[3] = vec[0];
565 * Parse a texture image source:
566 * [TEX0 | TEX1 | .. | TEX15] , [1D | 2D | 3D | CUBE | RECT]
569 Parse_TextureImageId(struct parse_state *parseState,
570 GLubyte *texUnit, GLubyte *texTargetBit)
572 GLubyte imageSrc[100];
575 if (!Parse_Token(parseState, imageSrc))
578 if (imageSrc[0] != 'T' ||
579 imageSrc[1] != 'E' ||
580 imageSrc[2] != 'X') {
581 RETURN_ERROR1("Expected TEX# source");
583 unit = atoi((const char *) imageSrc + 3);
584 if ((unit < 0 || unit > MAX_TEXTURE_IMAGE_UNITS) ||
585 (unit == 0 && (imageSrc[3] != '0' || imageSrc[4] != 0))) {
586 RETURN_ERROR1("Invalied TEX# source index");
590 if (!Parse_String(parseState, ","))
591 RETURN_ERROR1("Expected ,");
593 if (Parse_String(parseState, "1D")) {
594 *texTargetBit = TEXTURE_1D_BIT;
596 else if (Parse_String(parseState, "2D")) {
597 *texTargetBit = TEXTURE_2D_BIT;
599 else if (Parse_String(parseState, "3D")) {
600 *texTargetBit = TEXTURE_3D_BIT;
602 else if (Parse_String(parseState, "CUBE")) {
603 *texTargetBit = TEXTURE_CUBE_BIT;
605 else if (Parse_String(parseState, "RECT")) {
606 *texTargetBit = TEXTURE_RECT_BIT;
609 RETURN_ERROR1("Invalid texture target token");
612 /* update record of referenced texture units */
613 parseState->texturesUsed[*texUnit] |= *texTargetBit;
614 if (_mesa_bitcount(parseState->texturesUsed[*texUnit]) > 1) {
615 RETURN_ERROR1("Only one texture target can be used per texture unit.");
623 * Parse a scalar suffix like .x, .y, .z or .w or parse a swizzle suffix
624 * like .wxyz, .xxyy, etc and return the swizzle indexes.
627 Parse_SwizzleSuffix(const GLubyte *token, GLuint swizzle[4])
630 /* single letter swizzle (scalar) */
632 ASSIGN_4V(swizzle, 0, 0, 0, 0);
633 else if (token[0] == 'y')
634 ASSIGN_4V(swizzle, 1, 1, 1, 1);
635 else if (token[0] == 'z')
636 ASSIGN_4V(swizzle, 2, 2, 2, 2);
637 else if (token[0] == 'w')
638 ASSIGN_4V(swizzle, 3, 3, 3, 3);
643 /* 4-component swizzle (vector) */
645 for (k = 0; k < 4 && token[k]; k++) {
648 else if (token[k] == 'y')
650 else if (token[k] == 'z')
652 else if (token[k] == 'w')
665 Parse_CondCodeMask(struct parse_state *parseState,
666 struct prog_dst_register *dstReg)
668 if (Parse_String(parseState, "EQ"))
669 dstReg->CondMask = COND_EQ;
670 else if (Parse_String(parseState, "GE"))
671 dstReg->CondMask = COND_GE;
672 else if (Parse_String(parseState, "GT"))
673 dstReg->CondMask = COND_GT;
674 else if (Parse_String(parseState, "LE"))
675 dstReg->CondMask = COND_LE;
676 else if (Parse_String(parseState, "LT"))
677 dstReg->CondMask = COND_LT;
678 else if (Parse_String(parseState, "NE"))
679 dstReg->CondMask = COND_NE;
680 else if (Parse_String(parseState, "TR"))
681 dstReg->CondMask = COND_TR;
682 else if (Parse_String(parseState, "FL"))
683 dstReg->CondMask = COND_FL;
685 RETURN_ERROR1("Invalid condition code mask");
687 /* look for optional .xyzw swizzle */
688 if (Parse_String(parseState, ".")) {
692 if (!Parse_Token(parseState, token)) /* get xyzw suffix */
695 if (!Parse_SwizzleSuffix(token, swz))
696 RETURN_ERROR1("Invalid swizzle suffix");
698 dstReg->CondSwizzle = MAKE_SWIZZLE4(swz[0], swz[1], swz[2], swz[3]);
706 * Parse a temporary register: Rnn or Hnn
709 Parse_TempReg(struct parse_state *parseState, GLint *tempRegNum)
713 /* Should be 'R##' or 'H##' */
714 if (!Parse_Token(parseState, token))
716 if (token[0] != 'R' && token[0] != 'H')
717 RETURN_ERROR1("Expected R## or H##");
719 if (IsDigit(token[1])) {
720 GLint reg = atoi((const char *) (token + 1));
723 if (reg >= MAX_NV_FRAGMENT_PROGRAM_TEMPS)
724 RETURN_ERROR1("Invalid temporary register name");
728 RETURN_ERROR1("Invalid temporary register name");
736 * Parse a write-only dummy register: RC or HC.
739 Parse_DummyReg(struct parse_state *parseState, GLint *regNum)
741 if (Parse_String(parseState, "RC")) {
744 else if (Parse_String(parseState, "HC")) {
748 RETURN_ERROR1("Invalid write-only register name");
756 * Parse a program local parameter register "p[##]"
759 Parse_ProgramParamReg(struct parse_state *parseState, GLint *regNum)
763 if (!Parse_String(parseState, "p["))
764 RETURN_ERROR1("Expected p[");
766 if (!Parse_Token(parseState, token))
769 if (IsDigit(token[0])) {
770 /* a numbered program parameter register */
771 GLint reg = atoi((const char *) token);
772 if (reg >= MAX_NV_FRAGMENT_PROGRAM_PARAMS)
773 RETURN_ERROR1("Invalid constant program number");
780 if (!Parse_String(parseState, "]"))
781 RETURN_ERROR1("Expected ]");
788 * Parse f[name] - fragment input register
791 Parse_FragReg(struct parse_state *parseState, GLint *tempRegNum)
797 if (!Parse_String(parseState, "f["))
798 RETURN_ERROR1("Expected f[");
800 /* get <name> and look for match */
801 if (!Parse_Token(parseState, token)) {
804 for (j = 0; InputRegisters[j]; j++) {
805 if (strcmp((const char *) token, InputRegisters[j]) == 0) {
807 parseState->inputsRead |= (1 << j);
811 if (!InputRegisters[j]) {
812 /* unknown input register label */
813 RETURN_ERROR2("Invalid register name", token);
817 if (!Parse_String(parseState, "]"))
818 RETURN_ERROR1("Expected ]");
825 Parse_OutputReg(struct parse_state *parseState, GLint *outputRegNum)
830 if (!Parse_String(parseState, "o["))
831 RETURN_ERROR1("Expected o[");
833 /* Get output reg name */
834 if (!Parse_Token(parseState, token))
837 /* try to match an output register name */
838 if (strcmp((char *) token, "COLR") == 0 ||
839 strcmp((char *) token, "COLH") == 0) {
840 /* note that we don't distinguish between COLR and COLH */
841 *outputRegNum = FRAG_RESULT_COLOR;
842 parseState->outputsWritten |= (1 << FRAG_RESULT_COLOR);
844 else if (strcmp((char *) token, "DEPR") == 0) {
845 *outputRegNum = FRAG_RESULT_DEPTH;
846 parseState->outputsWritten |= (1 << FRAG_RESULT_DEPTH);
849 RETURN_ERROR1("Invalid output register name");
853 if (!Parse_String(parseState, "]"))
854 RETURN_ERROR1("Expected ]");
861 Parse_MaskedDstReg(struct parse_state *parseState,
862 struct prog_dst_register *dstReg)
867 /* Dst reg can be R<n>, H<n>, o[n], RC or HC */
868 if (!Peek_Token(parseState, token))
871 if (strcmp((const char *) token, "RC") == 0 ||
872 strcmp((const char *) token, "HC") == 0) {
873 /* a write-only register */
874 dstReg->File = PROGRAM_WRITE_ONLY;
875 if (!Parse_DummyReg(parseState, &idx))
879 else if (token[0] == 'R' || token[0] == 'H') {
880 /* a temporary register */
881 dstReg->File = PROGRAM_TEMPORARY;
882 if (!Parse_TempReg(parseState, &idx))
886 else if (token[0] == 'o') {
887 /* an output register */
888 dstReg->File = PROGRAM_OUTPUT;
889 if (!Parse_OutputReg(parseState, &idx))
894 RETURN_ERROR1("Invalid destination register name");
897 /* Parse optional write mask */
898 if (Parse_String(parseState, ".")) {
902 if (!Parse_Token(parseState, token)) /* get xyzw writemask */
905 dstReg->WriteMask = 0;
907 if (token[k] == 'x') {
908 dstReg->WriteMask |= WRITEMASK_X;
911 if (token[k] == 'y') {
912 dstReg->WriteMask |= WRITEMASK_Y;
915 if (token[k] == 'z') {
916 dstReg->WriteMask |= WRITEMASK_Z;
919 if (token[k] == 'w') {
920 dstReg->WriteMask |= WRITEMASK_W;
924 RETURN_ERROR1("Invalid writemask character");
929 dstReg->WriteMask = WRITEMASK_XYZW;
932 /* optional condition code mask */
933 if (Parse_String(parseState, "(")) {
934 /* ("EQ" | "GE" | "GT" | "LE" | "LT" | "NE" | "TR" | "FL".x|y|z|w) */
935 /* ("EQ" | "GE" | "GT" | "LE" | "LT" | "NE" | "TR" | "FL".[xyzw]) */
936 if (!Parse_CondCodeMask(parseState, dstReg))
939 if (!Parse_String(parseState, ")")) /* consume ")" */
940 RETURN_ERROR1("Expected )");
945 /* no cond code mask */
946 dstReg->CondMask = COND_TR;
947 dstReg->CondSwizzle = SWIZZLE_NOOP;
954 * Parse a vector source (register, constant, etc):
955 * <vectorSrc> ::= <absVectorSrc>
957 * <absVectorSrc> ::= <negate> "|" <baseVectorSrc> "|"
960 Parse_VectorSrc(struct parse_state *parseState,
961 struct prog_src_register *srcReg)
966 GLuint negateBase, negateAbs;
969 * First, take care of +/- and absolute value stuff.
971 if (Parse_String(parseState, "-"))
973 else if (Parse_String(parseState, "+"))
976 if (Parse_String(parseState, "|")) {
977 srcReg->Abs = GL_TRUE;
978 negateAbs = (sign < 0.0F) ? NEGATE_XYZW : NEGATE_NONE;
980 if (Parse_String(parseState, "-"))
981 negateBase = NEGATE_XYZW;
982 else if (Parse_String(parseState, "+"))
983 negateBase = NEGATE_NONE;
985 negateBase = NEGATE_NONE;
988 srcReg->Abs = GL_FALSE;
989 negateAbs = NEGATE_NONE;
990 negateBase = (sign < 0.0F) ? NEGATE_XYZW : NEGATE_NONE;
993 srcReg->Negate = srcReg->Abs ? negateAbs : negateBase;
995 /* This should be the real src vector/register name */
996 if (!Peek_Token(parseState, token))
999 /* Src reg can be Rn, Hn, f[n], p[n], a named parameter, a scalar
1000 * literal or vector literal.
1002 if (token[0] == 'R' || token[0] == 'H') {
1003 srcReg->File = PROGRAM_TEMPORARY;
1004 if (!Parse_TempReg(parseState, &idx))
1006 srcReg->Index = idx;
1008 else if (token[0] == 'f') {
1009 /* XXX this might be an identifier! */
1010 srcReg->File = PROGRAM_INPUT;
1011 if (!Parse_FragReg(parseState, &idx))
1013 srcReg->Index = idx;
1015 else if (token[0] == 'p') {
1016 /* XXX this might be an identifier! */
1017 srcReg->File = PROGRAM_LOCAL_PARAM;
1018 if (!Parse_ProgramParamReg(parseState, &idx))
1020 srcReg->Index = idx;
1022 else if (IsLetter(token[0])){
1025 if (!Parse_Identifier(parseState, ident))
1027 paramIndex = _mesa_lookup_parameter_index(parseState->parameters,
1028 -1, (const char *) ident);
1029 if (paramIndex < 0) {
1030 RETURN_ERROR2("Undefined constant or parameter: ", ident);
1032 srcReg->File = PROGRAM_NAMED_PARAM;
1033 srcReg->Index = paramIndex;
1035 else if (IsDigit(token[0]) || token[0] == '-' || token[0] == '+' || token[0] == '.'){
1036 /* literal scalar constant */
1039 if (!Parse_ScalarConstant(parseState, values))
1041 paramIndex = _mesa_add_unnamed_constant(parseState->parameters,
1043 srcReg->File = PROGRAM_NAMED_PARAM;
1044 srcReg->Index = paramIndex;
1046 else if (token[0] == '{'){
1047 /* literal vector constant */
1050 (void) Parse_String(parseState, "{");
1051 if (!Parse_VectorConstant(parseState, values))
1053 paramIndex = _mesa_add_unnamed_constant(parseState->parameters,
1055 srcReg->File = PROGRAM_NAMED_PARAM;
1056 srcReg->Index = paramIndex;
1059 RETURN_ERROR2("Invalid source register name", token);
1062 /* init swizzle fields */
1063 srcReg->Swizzle = SWIZZLE_NOOP;
1065 /* Look for optional swizzle suffix */
1066 if (Parse_String(parseState, ".")) {
1069 if (!Parse_Token(parseState, token))
1072 if (!Parse_SwizzleSuffix(token, swz))
1073 RETURN_ERROR1("Invalid swizzle suffix");
1075 srcReg->Swizzle = MAKE_SWIZZLE4(swz[0], swz[1], swz[2], swz[3]);
1078 /* Finish absolute value */
1079 if (srcReg->Abs && !Parse_String(parseState, "|")) {
1080 RETURN_ERROR1("Expected |");
1088 Parse_ScalarSrcReg(struct parse_state *parseState,
1089 struct prog_src_register *srcReg)
1092 GLfloat sign = 1.0F;
1093 GLboolean needSuffix = GL_TRUE;
1095 GLuint negateBase, negateAbs;
1098 * First, take care of +/- and absolute value stuff.
1100 if (Parse_String(parseState, "-"))
1102 else if (Parse_String(parseState, "+"))
1105 if (Parse_String(parseState, "|")) {
1106 srcReg->Abs = GL_TRUE;
1107 negateAbs = (sign < 0.0F) ? NEGATE_XYZW : NEGATE_NONE;
1109 if (Parse_String(parseState, "-"))
1110 negateBase = NEGATE_XYZW;
1111 else if (Parse_String(parseState, "+"))
1112 negateBase = NEGATE_NONE;
1114 negateBase = NEGATE_NONE;
1117 srcReg->Abs = GL_FALSE;
1118 negateAbs = NEGATE_NONE;
1119 negateBase = (sign < 0.0F) ? NEGATE_XYZW : NEGATE_NONE;
1122 srcReg->Negate = srcReg->Abs ? negateAbs : negateBase;
1124 if (!Peek_Token(parseState, token))
1127 /* Src reg can be R<n>, H<n> or a named fragment attrib */
1128 if (token[0] == 'R' || token[0] == 'H') {
1129 srcReg->File = PROGRAM_TEMPORARY;
1130 if (!Parse_TempReg(parseState, &idx))
1132 srcReg->Index = idx;
1134 else if (token[0] == 'f') {
1135 srcReg->File = PROGRAM_INPUT;
1136 if (!Parse_FragReg(parseState, &idx))
1138 srcReg->Index = idx;
1140 else if (token[0] == '{') {
1141 /* vector literal */
1144 (void) Parse_String(parseState, "{");
1145 if (!Parse_VectorConstant(parseState, values))
1147 paramIndex = _mesa_add_unnamed_constant(parseState->parameters,
1149 srcReg->File = PROGRAM_NAMED_PARAM;
1150 srcReg->Index = paramIndex;
1152 else if (IsLetter(token[0])){
1153 /* named param/constant */
1156 if (!Parse_Identifier(parseState, ident))
1158 paramIndex = _mesa_lookup_parameter_index(parseState->parameters,
1159 -1, (const char *) ident);
1160 if (paramIndex < 0) {
1161 RETURN_ERROR2("Undefined constant or parameter: ", ident);
1163 srcReg->File = PROGRAM_NAMED_PARAM;
1164 srcReg->Index = paramIndex;
1166 else if (IsDigit(token[0])) {
1167 /* scalar literal */
1170 if (!Parse_ScalarConstant(parseState, values))
1172 paramIndex = _mesa_add_unnamed_constant(parseState->parameters,
1174 srcReg->Index = paramIndex;
1175 srcReg->File = PROGRAM_NAMED_PARAM;
1176 needSuffix = GL_FALSE;
1179 RETURN_ERROR2("Invalid scalar source argument", token);
1182 srcReg->Swizzle = 0;
1184 /* parse .[xyzw] suffix */
1185 if (!Parse_String(parseState, "."))
1186 RETURN_ERROR1("Expected .");
1188 if (!Parse_Token(parseState, token))
1191 if (token[0] == 'x' && token[1] == 0) {
1192 srcReg->Swizzle = 0;
1194 else if (token[0] == 'y' && token[1] == 0) {
1195 srcReg->Swizzle = 1;
1197 else if (token[0] == 'z' && token[1] == 0) {
1198 srcReg->Swizzle = 2;
1200 else if (token[0] == 'w' && token[1] == 0) {
1201 srcReg->Swizzle = 3;
1204 RETURN_ERROR1("Invalid scalar source suffix");
1208 /* Finish absolute value */
1209 if (srcReg->Abs && !Parse_String(parseState, "|")) {
1210 RETURN_ERROR1("Expected |");
1218 Parse_PrintInstruction(struct parse_state *parseState,
1219 struct prog_instruction *inst)
1226 /* The first argument is a literal string 'just like this' */
1227 if (!Parse_String(parseState, "'"))
1228 RETURN_ERROR1("Expected '");
1230 str = parseState->pos;
1231 for (len = 0; str[len] != '\''; len++) /* find closing quote */
1233 parseState->pos += len + 1;
1234 msg = (GLubyte*) malloc(len + 1);
1236 memcpy(msg, str, len);
1240 if (Parse_String(parseState, ",")) {
1241 /* got an optional register to print */
1243 GetToken(parseState, token);
1244 if (token[0] == 'o') {
1246 if (!Parse_OutputReg(parseState, &idx))
1248 inst->SrcReg[0].Index = idx;
1249 inst->SrcReg[0].File = PROGRAM_OUTPUT;
1253 if (!Parse_VectorSrc(parseState, &inst->SrcReg[0]))
1258 inst->SrcReg[0].File = PROGRAM_UNDEFINED;
1261 inst->SrcReg[0].Swizzle = SWIZZLE_NOOP;
1262 inst->SrcReg[0].Abs = GL_FALSE;
1263 inst->SrcReg[0].Negate = NEGATE_NONE;
1270 Parse_InstructionSequence(struct parse_state *parseState,
1271 struct prog_instruction program[])
1274 struct prog_instruction *inst = program + parseState->numInst;
1275 struct instruction_pattern instMatch;
1278 /* Initialize the instruction */
1279 _mesa_init_instructions(inst, 1);
1281 /* special instructions */
1282 if (Parse_String(parseState, "DEFINE")) {
1284 GLfloat value[7]; /* yes, 7 to be safe */
1285 if (!Parse_Identifier(parseState, id))
1287 /* XXX make sure id is not a reserved identifer, like R9 */
1288 if (!Parse_String(parseState, "="))
1289 RETURN_ERROR1("Expected =");
1290 if (!Parse_VectorOrScalarConstant(parseState, value))
1292 if (!Parse_String(parseState, ";"))
1293 RETURN_ERROR1("Expected ;");
1294 if (_mesa_lookup_parameter_index(parseState->parameters,
1295 -1, (const char *) id) >= 0) {
1296 RETURN_ERROR2(id, "already defined");
1298 _mesa_add_named_parameter(parseState->parameters,
1299 (const char *) id, value);
1301 else if (Parse_String(parseState, "DECLARE")) {
1303 GLfloat value[7] = {0, 0, 0, 0, 0, 0, 0}; /* yes, to be safe */
1304 if (!Parse_Identifier(parseState, id))
1306 /* XXX make sure id is not a reserved identifer, like R9 */
1307 if (Parse_String(parseState, "=")) {
1308 if (!Parse_VectorOrScalarConstant(parseState, value))
1311 if (!Parse_String(parseState, ";"))
1312 RETURN_ERROR1("Expected ;");
1313 if (_mesa_lookup_parameter_index(parseState->parameters,
1314 -1, (const char *) id) >= 0) {
1315 RETURN_ERROR2(id, "already declared");
1317 _mesa_add_named_parameter(parseState->parameters,
1318 (const char *) id, value);
1320 else if (Parse_String(parseState, "END")) {
1321 inst->Opcode = OPCODE_END;
1322 parseState->numInst++;
1323 if (Parse_Token(parseState, token)) {
1324 RETURN_ERROR1("Code after END opcode.");
1329 /* general/arithmetic instruction */
1332 if (!Parse_Token(parseState, token)) {
1333 RETURN_ERROR1("Missing END instruction.");
1336 /* try to find matching instuction */
1337 instMatch = MatchInstruction(token);
1338 if (instMatch.opcode >= MAX_OPCODE) {
1339 /* bad instruction name */
1340 RETURN_ERROR2("Unexpected token: ", token);
1343 inst->Opcode = instMatch.opcode;
1344 inst->Precision = instMatch.suffixes & (_R | _H | _X);
1345 inst->SaturateMode = (instMatch.suffixes & (_S))
1346 ? SATURATE_ZERO_ONE : SATURATE_OFF;
1347 inst->CondUpdate = (instMatch.suffixes & (_C)) ? GL_TRUE : GL_FALSE;
1350 * parse the input and output operands
1352 if (instMatch.outputs == OUTPUT_S || instMatch.outputs == OUTPUT_V) {
1353 if (!Parse_MaskedDstReg(parseState, &inst->DstReg))
1355 if (!Parse_String(parseState, ","))
1356 RETURN_ERROR1("Expected ,");
1358 else if (instMatch.outputs == OUTPUT_NONE) {
1359 if (instMatch.opcode == OPCODE_KIL_NV) {
1360 /* This is a little weird, the cond code info is in
1361 * the dest register.
1363 if (!Parse_CondCodeMask(parseState, &inst->DstReg))
1367 ASSERT(instMatch.opcode == OPCODE_PRINT);
1371 if (instMatch.inputs == INPUT_1V) {
1372 if (!Parse_VectorSrc(parseState, &inst->SrcReg[0]))
1375 else if (instMatch.inputs == INPUT_2V) {
1376 if (!Parse_VectorSrc(parseState, &inst->SrcReg[0]))
1378 if (!Parse_String(parseState, ","))
1379 RETURN_ERROR1("Expected ,");
1380 if (!Parse_VectorSrc(parseState, &inst->SrcReg[1]))
1383 else if (instMatch.inputs == INPUT_3V) {
1384 if (!Parse_VectorSrc(parseState, &inst->SrcReg[0]))
1386 if (!Parse_String(parseState, ","))
1387 RETURN_ERROR1("Expected ,");
1388 if (!Parse_VectorSrc(parseState, &inst->SrcReg[1]))
1390 if (!Parse_String(parseState, ","))
1391 RETURN_ERROR1("Expected ,");
1392 if (!Parse_VectorSrc(parseState, &inst->SrcReg[2]))
1395 else if (instMatch.inputs == INPUT_1S) {
1396 if (!Parse_ScalarSrcReg(parseState, &inst->SrcReg[0]))
1399 else if (instMatch.inputs == INPUT_2S) {
1400 if (!Parse_ScalarSrcReg(parseState, &inst->SrcReg[0]))
1402 if (!Parse_String(parseState, ","))
1403 RETURN_ERROR1("Expected ,");
1404 if (!Parse_ScalarSrcReg(parseState, &inst->SrcReg[1]))
1407 else if (instMatch.inputs == INPUT_CC) {
1410 else if (instMatch.inputs == INPUT_1V_T) {
1412 if (!Parse_VectorSrc(parseState, &inst->SrcReg[0]))
1414 if (!Parse_String(parseState, ","))
1415 RETURN_ERROR1("Expected ,");
1416 if (!Parse_TextureImageId(parseState, &unit, &idx))
1418 inst->TexSrcUnit = unit;
1419 inst->TexSrcTarget = idx;
1421 else if (instMatch.inputs == INPUT_3V_T) {
1423 if (!Parse_VectorSrc(parseState, &inst->SrcReg[0]))
1425 if (!Parse_String(parseState, ","))
1426 RETURN_ERROR1("Expected ,");
1427 if (!Parse_VectorSrc(parseState, &inst->SrcReg[1]))
1429 if (!Parse_String(parseState, ","))
1430 RETURN_ERROR1("Expected ,");
1431 if (!Parse_VectorSrc(parseState, &inst->SrcReg[2]))
1433 if (!Parse_String(parseState, ","))
1434 RETURN_ERROR1("Expected ,");
1435 if (!Parse_TextureImageId(parseState, &unit, &idx))
1437 inst->TexSrcUnit = unit;
1438 inst->TexSrcTarget = idx;
1440 else if (instMatch.inputs == INPUT_1V_S) {
1441 if (!Parse_PrintInstruction(parseState, inst))
1445 /* end of statement semicolon */
1446 if (!Parse_String(parseState, ";"))
1447 RETURN_ERROR1("Expected ;");
1449 parseState->numInst++;
1451 if (parseState->numInst >= MAX_NV_FRAGMENT_PROGRAM_INSTRUCTIONS)
1452 RETURN_ERROR1("Program too long");
1461 * Parse/compile the 'str' returning the compiled 'program'.
1462 * ctx->Program.ErrorPos will be -1 if successful. Otherwise, ErrorPos
1463 * indicates the position of the error in 'str'.
1466 _mesa_parse_nv_fragment_program(struct gl_context *ctx, GLenum dstTarget,
1467 const GLubyte *str, GLsizei len,
1468 struct gl_fragment_program *program)
1470 struct parse_state parseState;
1471 struct prog_instruction instBuffer[MAX_NV_FRAGMENT_PROGRAM_INSTRUCTIONS];
1472 struct prog_instruction *newInst;
1474 GLubyte *programString;
1476 /* Make a null-terminated copy of the program string */
1477 programString = (GLubyte *) MALLOC(len + 1);
1478 if (!programString) {
1479 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glLoadProgramNV");
1482 memcpy(programString, str, len);
1483 programString[len] = 0;
1485 /* Get ready to parse */
1486 memset(&parseState, 0, sizeof(struct parse_state));
1487 parseState.ctx = ctx;
1488 parseState.start = programString;
1489 parseState.program = program;
1490 parseState.numInst = 0;
1491 parseState.curLine = programString;
1492 parseState.parameters = _mesa_new_parameter_list();
1494 /* Reset error state */
1495 _mesa_set_program_error(ctx, -1, NULL);
1497 /* check the program header */
1498 if (strncmp((const char *) programString, "!!FP1.0", 7) == 0) {
1499 target = GL_FRAGMENT_PROGRAM_NV;
1500 parseState.pos = programString + 7;
1502 else if (strncmp((const char *) programString, "!!FCP1.0", 8) == 0) {
1503 /* fragment / register combiner program - not supported */
1504 _mesa_set_program_error(ctx, 0, "Invalid fragment program header");
1505 _mesa_error(ctx, GL_INVALID_OPERATION, "glLoadProgramNV(bad header)");
1509 /* invalid header */
1510 _mesa_set_program_error(ctx, 0, "Invalid fragment program header");
1511 _mesa_error(ctx, GL_INVALID_OPERATION, "glLoadProgramNV(bad header)");
1515 /* make sure target and header match */
1516 if (target != dstTarget) {
1517 _mesa_error(ctx, GL_INVALID_OPERATION,
1518 "glLoadProgramNV(target mismatch 0x%x != 0x%x)",
1523 if (Parse_InstructionSequence(&parseState, instBuffer)) {
1525 /* successful parse! */
1527 if (parseState.outputsWritten == 0) {
1528 /* must write at least one output! */
1529 _mesa_error(ctx, GL_INVALID_OPERATION,
1530 "Invalid fragment program - no outputs written.");
1534 /* copy the compiled instructions */
1535 assert(parseState.numInst <= MAX_NV_FRAGMENT_PROGRAM_INSTRUCTIONS);
1536 newInst = _mesa_alloc_instructions(parseState.numInst);
1538 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glLoadProgramNV");
1539 return; /* out of memory */
1541 _mesa_copy_instructions(newInst, instBuffer, parseState.numInst);
1543 /* install the program */
1544 program->Base.Target = target;
1545 if (program->Base.String) {
1546 FREE(program->Base.String);
1548 program->Base.String = programString;
1549 program->Base.Format = GL_PROGRAM_FORMAT_ASCII_ARB;
1550 if (program->Base.Instructions) {
1551 free(program->Base.Instructions);
1553 program->Base.Instructions = newInst;
1554 program->Base.NumInstructions = parseState.numInst;
1555 program->Base.InputsRead = parseState.inputsRead;
1556 program->Base.OutputsWritten = parseState.outputsWritten;
1557 for (u = 0; u < ctx->Const.MaxTextureImageUnits; u++)
1558 program->Base.TexturesUsed[u] = parseState.texturesUsed[u];
1560 /* save program parameters */
1561 program->Base.Parameters = parseState.parameters;
1563 /* allocate registers for declared program parameters */
1565 _mesa_assign_program_registers(&(program->SymbolTable));
1569 printf("--- glLoadProgramNV(%d) result ---\n", program->Base.Id);
1570 _mesa_fprint_program_opt(stdout, &program->Base, PROG_PRINT_NV, 0);
1571 printf("----------------------------------\n");
1576 _mesa_error(ctx, GL_INVALID_OPERATION, "glLoadProgramNV");
1577 /* NOTE: _mesa_set_program_error would have been called already */
1583 _mesa_nv_fragment_input_register_name(GLuint i)
1585 ASSERT(i < MAX_NV_FRAGMENT_PROGRAM_INPUTS);
1586 return InputRegisters[i];