/** * Parse a program local parameter register "p[##]" */ static GLboolean Parse_ProgramParamReg(struct parse_state *parseState, GLint *regNum) { GLubyte token[100]; if (!Parse_String(parseState, "p[")) RETURN_ERROR1("Expected p["); if (!Parse_Token(parseState, token)) RETURN_ERROR; if (IsDigit(token[0])) { /* a numbered program parameter register */ GLint reg = _mesa_atoi((const char *) token); if (reg >= MAX_NV_FRAGMENT_PROGRAM_PARAMS) RETURN_ERROR1("Invalid constant program number"); *regNum = reg; } else { RETURN_ERROR; } if (!Parse_String(parseState, "]")) RETURN_ERROR1("Expected ]"); return GL_TRUE; }
/** * Parse f[name] - fragment input register */ static GLboolean Parse_FragReg(struct parse_state *parseState, GLint *tempRegNum) { GLubyte token[100]; GLint j; /* Match 'f[' */ if (!Parse_String(parseState, "f[")) RETURN_ERROR1("Expected f["); /* get <name> and look for match */ if (!Parse_Token(parseState, token)) { RETURN_ERROR; } for (j = 0; InputRegisters[j]; j++) { if (_mesa_strcmp((const char *) token, InputRegisters[j]) == 0) { *tempRegNum = j; parseState->inputsRead |= (1 << j); break; } } if (!InputRegisters[j]) { /* unknown input register label */ RETURN_ERROR2("Invalid register name", token); } /* Match '[' */ if (!Parse_String(parseState, "]")) RETURN_ERROR1("Expected ]"); return GL_TRUE; }
static GLboolean Parse_ScalarInstruction(struct parse_state *parseState, struct prog_instruction *inst, enum prog_opcode opcode) { if (opcode == OPCODE_RCC && !parseState->isVersion1_1) RETURN_ERROR1("RCC illegal for vertex program 1.0"); inst->Opcode = opcode; inst->StringPos = parseState->curLine - parseState->start; /* dest reg */ if (!Parse_MaskedDstReg(parseState, &inst->DstReg)) RETURN_ERROR; /* comma */ if (!Parse_String(parseState, ",")) RETURN_ERROR; /* first src arg */ if (!Parse_ScalarSrcReg(parseState, &inst->SrcReg[0])) RETURN_ERROR; /* semicolon */ if (!Parse_String(parseState, ";")) RETURN_ERROR; return GL_TRUE; }
static GLboolean Parse_AddressInstruction(struct parse_state *parseState, struct prog_instruction *inst) { inst->Opcode = OPCODE_ARL; inst->StringPos = parseState->curLine - parseState->start; /* Make ARB_vp backends happy */ inst->DstReg.File = PROGRAM_ADDRESS; inst->DstReg.WriteMask = WRITEMASK_X; inst->DstReg.Index = 0; /* dest A0 reg */ if (!Parse_AddrReg(parseState)) RETURN_ERROR; /* comma */ if (!Parse_String(parseState, ",")) RETURN_ERROR; /* parse src reg */ if (!Parse_ScalarSrcReg(parseState, &inst->SrcReg[0])) RETURN_ERROR; /* semicolon */ if (!Parse_String(parseState, ";")) RETURN_ERROR; return GL_TRUE; }
UCS2 *Parser::Parse_Concat(bool pathname) { UCS2 *str; UCS2 *New; Parse_Paren_Begin(); New = Parse_String(); EXPECT CASE(RIGHT_PAREN_TOKEN) UNGET EXIT END_CASE OTHERWISE UNGET Parse_Comma(); str = Parse_String(pathname); New = UCS2_strcat(New, str); POV_FREE(str); END_CASE END_EXPECT Parse_Paren_End(); return New; }
/** * Parse absolute program parameter register "c[##]" */ static GLboolean Parse_AbsParamReg(struct parse_state *parseState, GLint *regNum) { GLubyte token[100]; if (!Parse_String(parseState, "c")) RETURN_ERROR; if (!Parse_String(parseState, "[")) RETURN_ERROR; if (!Parse_Token(parseState, token)) RETURN_ERROR; if (IsDigit(token[0])) { /* a numbered program parameter register */ GLint reg = _mesa_atoi((char *) token); if (reg >= MAX_NV_VERTEX_PROGRAM_PARAMS) RETURN_ERROR1("Bad program parameter number"); *regNum = reg; } else { RETURN_ERROR; } if (!Parse_String(parseState, "]")) RETURN_ERROR; return GL_TRUE; }
static GLint Parse_UnaryOpInstruction(struct parse_state *parseState, struct vp_instruction *inst, enum vp_opcode opcode) { if (opcode == VP_OPCODE_ABS && !parseState->isVersion1_1) RETURN_ERROR1("ABS illegal for vertex program 1.0"); inst->Opcode = opcode; inst->StringPos = parseState->curLine - parseState->start; /* dest reg */ if (!Parse_MaskedDstReg(parseState, &inst->DstReg)) RETURN_ERROR; /* comma */ if (!Parse_String(parseState, ",")) RETURN_ERROR; /* src arg */ if (!Parse_SwizzleSrcReg(parseState, &inst->SrcReg[0])) RETURN_ERROR; /* semicolon */ if (!Parse_String(parseState, ";")) RETURN_ERROR; return GL_TRUE; }
static GLboolean Parse_OutputReg(struct parse_state *parseState, GLint *outputRegNum) { GLubyte token[100]; /* Match "o[" */ if (!Parse_String(parseState, "o[")) RETURN_ERROR1("Expected o["); /* Get output reg name */ if (!Parse_Token(parseState, token)) RETURN_ERROR; /* try to match an output register name */ if (_mesa_strcmp((char *) token, "COLR") == 0 || _mesa_strcmp((char *) token, "COLH") == 0) { /* note that we don't distinguish between COLR and COLH */ *outputRegNum = FRAG_RESULT_COLOR; parseState->outputsWritten |= (1 << FRAG_RESULT_COLOR); } else if (_mesa_strcmp((char *) token, "DEPR") == 0) { *outputRegNum = FRAG_RESULT_DEPTH; parseState->outputsWritten |= (1 << FRAG_RESULT_DEPTH); } else { RETURN_ERROR1("Invalid output register name"); } /* Match ']' */ if (!Parse_String(parseState, "]")) RETURN_ERROR1("Expected ]"); return GL_TRUE; }
static GLboolean Parse_BiOpInstruction(struct parse_state *parseState, struct prog_instruction *inst, enum prog_opcode opcode) { if (opcode == OPCODE_DPH && !parseState->isVersion1_1) RETURN_ERROR1("DPH illegal for vertex program 1.0"); if (opcode == OPCODE_SUB && !parseState->isVersion1_1) RETURN_ERROR1("SUB illegal for vertex program 1.0"); inst->Opcode = opcode; inst->StringPos = parseState->curLine - parseState->start; /* dest reg */ if (!Parse_MaskedDstReg(parseState, &inst->DstReg)) RETURN_ERROR; /* comma */ if (!Parse_String(parseState, ",")) RETURN_ERROR; /* first src arg */ if (!Parse_SwizzleSrcReg(parseState, &inst->SrcReg[0])) RETURN_ERROR; /* comma */ if (!Parse_String(parseState, ",")) RETURN_ERROR; /* second src arg */ if (!Parse_SwizzleSrcReg(parseState, &inst->SrcReg[1])) RETURN_ERROR; /* semicolon */ if (!Parse_String(parseState, ";")) RETURN_ERROR; /* make sure we don't reference more than one program parameter register */ if (inst->SrcReg[0].File == PROGRAM_ENV_PARAM && inst->SrcReg[1].File == PROGRAM_ENV_PARAM && inst->SrcReg[0].Index != inst->SrcReg[1].Index) RETURN_ERROR1("Can't reference two program parameter registers"); /* make sure we don't reference more than one vertex attribute register */ if (inst->SrcReg[0].File == PROGRAM_INPUT && inst->SrcReg[1].File == PROGRAM_INPUT && inst->SrcReg[0].Index != inst->SrcReg[1].Index) RETURN_ERROR1("Can't reference two vertex attribute registers"); return GL_TRUE; }
static GLboolean Parse_PrintInstruction(struct parse_state *parseState, struct prog_instruction *inst) { const GLubyte *str; GLubyte *msg; GLuint len; GLint idx; /* The first argument is a literal string 'just like this' */ if (!Parse_String(parseState, "'")) RETURN_ERROR1("Expected '"); str = parseState->pos; for (len = 0; str[len] != '\''; len++) /* find closing quote */ ; parseState->pos += len + 1; msg = (GLubyte*) malloc(len + 1); memcpy(msg, str, len); msg[len] = 0; inst->Data = msg; if (Parse_String(parseState, ",")) { /* got an optional register to print */ GLubyte token[100]; GetToken(parseState, token); if (token[0] == 'o') { /* dst reg */ if (!Parse_OutputReg(parseState, &idx)) RETURN_ERROR; inst->SrcReg[0].Index = idx; inst->SrcReg[0].File = PROGRAM_OUTPUT; } else { /* src reg */ if (!Parse_VectorSrc(parseState, &inst->SrcReg[0])) RETURN_ERROR; } } else { inst->SrcReg[0].File = PROGRAM_UNDEFINED; } inst->SrcReg[0].Swizzle = SWIZZLE_NOOP; inst->SrcReg[0].Abs = GL_FALSE; inst->SrcReg[0].Negate = NEGATE_NONE; return GL_TRUE; }
/** * Parse a write-only dummy register: RC or HC. */ static GLboolean Parse_DummyReg(struct parse_state *parseState, GLint *regNum) { if (Parse_String(parseState, "RC")) { *regNum = 0; } else if (Parse_String(parseState, "HC")) { *regNum = 1; } else { RETURN_ERROR1("Invalid write-only register name"); } return GL_TRUE; }
UCS2 *Parser::Parse_Substr(bool pathname) { UCS2 *str; UCS2 *New; int l, d; GET(LEFT_PAREN_TOKEN); str = Parse_String(pathname); Parse_Comma(); l = (int)Parse_Float(); Parse_Comma(); d = (int)Parse_Float(); GET(RIGHT_PAREN_TOKEN); if(((l + d - 1) > UCS2_strlen(str)) || (l < 0) || (d < 0)) Error("Illegal parameters in substr."); New = reinterpret_cast<UCS2 *>(POV_MALLOC(sizeof(UCS2) * (d + 1), "temporary string")); UCS2_strncpy(New, &(str[l - 1]), d); New[d] = 0; POV_FREE(str); return New; }
std::string Parser::Parse_SysString(bool pathname, bool require) { UCS2 *cstr = Parse_String(pathname, require); std::string ret(UCS2toSysString(cstr)); POV_FREE(cstr); return ret; }
/** * Parse address register "A0.x" */ static GLboolean Parse_AddrReg(struct parse_state *parseState) { /* match 'A0' */ if (!Parse_String(parseState, "A0")) RETURN_ERROR; /* match '.' */ if (!Parse_String(parseState, ".")) RETURN_ERROR; /* match 'x' */ if (!Parse_String(parseState, "x")) RETURN_ERROR; return GL_TRUE; }
static GLboolean Parse_OptionSequence(struct parse_state *parseState, struct vp_instruction program[]) { while (1) { if (!Parse_String(parseState, "OPTION")) return GL_TRUE; /* ok, not an OPTION statement */ if (Parse_String(parseState, "NV_position_invariant")) { parseState->isPositionInvariant = GL_TRUE; } else { RETURN_ERROR1("unexpected OPTION statement"); } if (!Parse_String(parseState, ";")) return GL_FALSE; } }
/** * Parse v[#] or v[<name>] */ static GLboolean Parse_AttribReg(struct parse_state *parseState, GLint *tempRegNum) { GLubyte token[100]; GLint j; /* Match 'v' */ if (!Parse_String(parseState, "v")) RETURN_ERROR; /* Match '[' */ if (!Parse_String(parseState, "[")) RETURN_ERROR; /* match number or named register */ if (!Parse_Token(parseState, token)) RETURN_ERROR; if (parseState->isStateProgram && token[0] != '0') RETURN_ERROR1("Only v[0] accessible in vertex state programs"); if (IsDigit(token[0])) { GLint reg = _mesa_atoi((char *) token); if (reg >= MAX_NV_VERTEX_PROGRAM_INPUTS) RETURN_ERROR1("Bad vertex attribute register name"); *tempRegNum = reg; } else { for (j = 0; InputRegisters[j]; j++) { if (_mesa_strcmp((const char *) token, InputRegisters[j]) == 0) { *tempRegNum = j; break; } } if (!InputRegisters[j]) { /* unknown input register label */ RETURN_ERROR2("Bad register name", token); } } /* Match '[' */ if (!Parse_String(parseState, "]")) RETURN_ERROR; return GL_TRUE; }
void Parser::ParseString(UTF8String& s, bool pathname) { /// @todo Add support for non-ASCII strings. UCS2 *str = Parse_String(pathname); char *New = UCS2_To_String(str); s = New; POV_FREE(str); }
UCS2 *Parser::Parse_Strlwr(bool pathname) { UCS2 *New; GET(LEFT_PAREN_TOKEN); New = Parse_String(pathname); UCS2_strlwr(New); GET(RIGHT_PAREN_TOKEN); return New; }
UCS2 *Parser::Parse_Strlwr(bool pathname) { UCS2 *New; Parse_Paren_Begin(); New = Parse_String(pathname); UCS2_strlwr(New); Parse_Paren_End(); return New; }
char * Db_Record::Get_Field_Number (int number, char field [], int field_size) { char *ptr = Record (); if (ptr == NULL) { Status (RECORD_SIZE); return (NULL); } for (int i=0; i < number && ptr != NULL; i++) { ptr = Parse_String (ptr, field, field_size); } return (field); }
static GLboolean Parse_OutputReg(struct parse_state *parseState, GLint *outputRegNum) { GLubyte token[100]; GLint start, j; /* Match 'o' */ if (!Parse_String(parseState, "o")) RETURN_ERROR; /* Match '[' */ if (!Parse_String(parseState, "[")) RETURN_ERROR; /* Get output reg name */ if (!Parse_Token(parseState, token)) RETURN_ERROR; if (parseState->isPositionInvariant) start = 1; /* skip HPOS register name */ else start = 0; /* try to match an output register name */ for (j = start; OutputRegisters[j]; j++) { if (_mesa_strcmp((const char *) token, OutputRegisters[j]) == 0) { *outputRegNum = j; break; } } if (!OutputRegisters[j]) RETURN_ERROR1("Unrecognized output register name"); /* Match ']' */ if (!Parse_String(parseState, "]")) RETURN_ERROR1("Expected ]"); return GL_TRUE; }
/** * Parse <number>, <varname> or {a, b, c, d}. * Return number of values in the vector or scalar, or zero if parse error. */ static GLuint Parse_VectorOrScalarConstant(struct parse_state *parseState, GLfloat *vec) { if (Parse_String(parseState, "{")) { return Parse_VectorConstant(parseState, vec); } else { GLboolean b = Parse_ScalarConstant(parseState, vec); if (b) { vec[1] = vec[2] = vec[3] = vec[0]; } return b; } }
static GLboolean Parse_AddressInstruction(struct parse_state *parseState, struct vp_instruction *inst) { inst->Opcode = VP_OPCODE_ARL; inst->StringPos = parseState->curLine - parseState->start; /* dest A0 reg */ if (!Parse_AddrReg(parseState)) RETURN_ERROR; /* comma */ if (!Parse_String(parseState, ",")) RETURN_ERROR; /* parse src reg */ if (!Parse_ScalarSrcReg(parseState, &inst->SrcReg[0])) RETURN_ERROR; /* semicolon */ if (!Parse_String(parseState, ";")) RETURN_ERROR; return GL_TRUE; }
static GLboolean Parse_CondCodeMask(struct parse_state *parseState, struct prog_dst_register *dstReg) { if (Parse_String(parseState, "EQ")) dstReg->CondMask = COND_EQ; else if (Parse_String(parseState, "GE")) dstReg->CondMask = COND_GE; else if (Parse_String(parseState, "GT")) dstReg->CondMask = COND_GT; else if (Parse_String(parseState, "LE")) dstReg->CondMask = COND_LE; else if (Parse_String(parseState, "LT")) dstReg->CondMask = COND_LT; else if (Parse_String(parseState, "NE")) dstReg->CondMask = COND_NE; else if (Parse_String(parseState, "TR")) dstReg->CondMask = COND_TR; else if (Parse_String(parseState, "FL")) dstReg->CondMask = COND_FL; else RETURN_ERROR1("Invalid condition code mask"); /* look for optional .xyzw swizzle */ if (Parse_String(parseState, ".")) { GLubyte token[100]; GLuint swz[4]; if (!Parse_Token(parseState, token)) /* get xyzw suffix */ RETURN_ERROR; if (!Parse_SwizzleSuffix(token, swz)) RETURN_ERROR1("Invalid swizzle suffix"); dstReg->CondSwizzle = MAKE_SWIZZLE4(swz[0], swz[1], swz[2], swz[3]); } return GL_TRUE; }
/** * Parse a texture image source: * [TEX0 | TEX1 | .. | TEX15] , [1D | 2D | 3D | CUBE | RECT] */ static GLboolean Parse_TextureImageId(struct parse_state *parseState, GLubyte *texUnit, GLubyte *texTargetBit) { GLubyte imageSrc[100]; GLint unit; if (!Parse_Token(parseState, imageSrc)) RETURN_ERROR; if (imageSrc[0] != 'T' || imageSrc[1] != 'E' || imageSrc[2] != 'X') { RETURN_ERROR1("Expected TEX# source"); } unit = atoi((const char *) imageSrc + 3); if ((unit < 0 || unit > MAX_TEXTURE_IMAGE_UNITS) || (unit == 0 && (imageSrc[3] != '0' || imageSrc[4] != 0))) { RETURN_ERROR1("Invalied TEX# source index"); } *texUnit = unit; if (!Parse_String(parseState, ",")) RETURN_ERROR1("Expected ,"); if (Parse_String(parseState, "1D")) { *texTargetBit = TEXTURE_1D_BIT; } else if (Parse_String(parseState, "2D")) { *texTargetBit = TEXTURE_2D_BIT; } else if (Parse_String(parseState, "3D")) { *texTargetBit = TEXTURE_3D_BIT; } else if (Parse_String(parseState, "CUBE")) { *texTargetBit = TEXTURE_CUBE_BIT; } else if (Parse_String(parseState, "RECT")) { *texTargetBit = TEXTURE_RECT_BIT; } else { RETURN_ERROR1("Invalid texture target token"); } /* update record of referenced texture units */ parseState->texturesUsed[*texUnit] |= *texTargetBit; if (_mesa_bitcount(parseState->texturesUsed[*texUnit]) > 1) { RETURN_ERROR1("Only one texture target can be used per texture unit."); } return GL_TRUE; }
/** * Parse a vector constant, one of: * { float } * { float, float } * { float, float, float } * { float, float, float, float } */ static GLboolean Parse_VectorConstant(struct parse_state *parseState, GLfloat *vec) { /* "{" was already consumed */ ASSIGN_4V(vec, 0.0, 0.0, 0.0, 1.0); if (!Parse_ScalarConstant(parseState, vec+0)) /* X */ return GL_FALSE; if (Parse_String(parseState, "}")) { return GL_TRUE; } if (!Parse_String(parseState, ",")) RETURN_ERROR1("Expected comma in vector constant"); if (!Parse_ScalarConstant(parseState, vec+1)) /* Y */ return GL_FALSE; if (Parse_String(parseState, "}")) { return GL_TRUE; } if (!Parse_String(parseState, ",")) RETURN_ERROR1("Expected comma in vector constant"); if (!Parse_ScalarConstant(parseState, vec+2)) /* Z */ return GL_FALSE; if (Parse_String(parseState, "}")) { return GL_TRUE; } if (!Parse_String(parseState, ",")) RETURN_ERROR1("Expected comma in vector constant"); if (!Parse_ScalarConstant(parseState, vec+3)) /* W */ return GL_FALSE; if (!Parse_String(parseState, "}")) RETURN_ERROR1("Expected closing brace in vector constant"); return GL_TRUE; }
static GLboolean Parse_TriOpInstruction(struct parse_state *parseState, struct vp_instruction *inst, enum vp_opcode opcode) { inst->Opcode = opcode; inst->StringPos = parseState->curLine - parseState->start; /* dest reg */ if (!Parse_MaskedDstReg(parseState, &inst->DstReg)) RETURN_ERROR; /* comma */ if (!Parse_String(parseState, ",")) RETURN_ERROR; /* first src arg */ if (!Parse_SwizzleSrcReg(parseState, &inst->SrcReg[0])) RETURN_ERROR; /* comma */ if (!Parse_String(parseState, ",")) RETURN_ERROR; /* second src arg */ if (!Parse_SwizzleSrcReg(parseState, &inst->SrcReg[1])) RETURN_ERROR; /* comma */ if (!Parse_String(parseState, ",")) RETURN_ERROR; /* third src arg */ if (!Parse_SwizzleSrcReg(parseState, &inst->SrcReg[2])) RETURN_ERROR; /* semicolon */ if (!Parse_String(parseState, ";")) RETURN_ERROR; /* make sure we don't reference more than one program parameter register */ if ((inst->SrcReg[0].File == PROGRAM_ENV_PARAM && inst->SrcReg[1].File == PROGRAM_ENV_PARAM && inst->SrcReg[0].Index != inst->SrcReg[1].Index) || (inst->SrcReg[0].File == PROGRAM_ENV_PARAM && inst->SrcReg[2].File == PROGRAM_ENV_PARAM && inst->SrcReg[0].Index != inst->SrcReg[2].Index) || (inst->SrcReg[1].File == PROGRAM_ENV_PARAM && inst->SrcReg[2].File == PROGRAM_ENV_PARAM && inst->SrcReg[1].Index != inst->SrcReg[2].Index)) RETURN_ERROR1("Can only reference one program register"); /* make sure we don't reference more than one vertex attribute register */ if ((inst->SrcReg[0].File == PROGRAM_INPUT && inst->SrcReg[1].File == PROGRAM_INPUT && inst->SrcReg[0].Index != inst->SrcReg[1].Index) || (inst->SrcReg[0].File == PROGRAM_INPUT && inst->SrcReg[2].File == PROGRAM_INPUT && inst->SrcReg[0].Index != inst->SrcReg[2].Index) || (inst->SrcReg[1].File == PROGRAM_INPUT && inst->SrcReg[2].File == PROGRAM_INPUT && inst->SrcReg[1].Index != inst->SrcReg[2].Index)) RETURN_ERROR1("Can only reference one input register"); return GL_TRUE; }
static GLboolean Parse_ScalarSrcReg(struct parse_state *parseState, struct vp_src_register *srcReg) { GLubyte token[100]; srcReg->RelAddr = GL_FALSE; /* check for '-' */ if (!Peek_Token(parseState, token)) RETURN_ERROR; if (token[0] == '-') { srcReg->Negate = GL_TRUE; (void) Parse_String(parseState, "-"); /* consume '-' */ if (!Peek_Token(parseState, token)) RETURN_ERROR; } else { srcReg->Negate = GL_FALSE; } /* Src reg can be R<n>, c[n], c[n +/- offset], or a named vertex attrib */ if (token[0] == 'R') { srcReg->File = PROGRAM_TEMPORARY; if (!Parse_TempReg(parseState, &srcReg->Index)) RETURN_ERROR; } else if (token[0] == 'c') { if (!Parse_ParamReg(parseState, srcReg)) RETURN_ERROR; } else if (token[0] == 'v') { srcReg->File = PROGRAM_INPUT; if (!Parse_AttribReg(parseState, &srcReg->Index)) RETURN_ERROR; } else { RETURN_ERROR2("Bad source register name", token); } /* Look for .[xyzw] suffix */ if (!Parse_String(parseState, ".")) RETURN_ERROR; if (!Parse_Token(parseState, token)) RETURN_ERROR; if (token[0] == 'x' && token[1] == 0) { srcReg->Swizzle[0] = 0; } else if (token[0] == 'y' && token[1] == 0) { srcReg->Swizzle[0] = 1; } else if (token[0] == 'z' && token[1] == 0) { srcReg->Swizzle[0] = 2; } else if (token[0] == 'w' && token[1] == 0) { srcReg->Swizzle[0] = 3; } else { RETURN_ERROR1("Bad scalar source suffix"); } srcReg->Swizzle[1] = srcReg->Swizzle[2] = srcReg->Swizzle[3] = 0; return GL_TRUE; }
static GLboolean Parse_SwizzleSrcReg(struct parse_state *parseState, struct vp_src_register *srcReg) { GLubyte token[100]; srcReg->RelAddr = GL_FALSE; /* check for '-' */ if (!Peek_Token(parseState, token)) RETURN_ERROR; if (token[0] == '-') { (void) Parse_String(parseState, "-"); srcReg->Negate = GL_TRUE; if (!Peek_Token(parseState, token)) RETURN_ERROR; } else { srcReg->Negate = GL_FALSE; } /* Src reg can be R<n>, c[n], c[n +/- offset], or a named vertex attrib */ if (token[0] == 'R') { srcReg->File = PROGRAM_TEMPORARY; if (!Parse_TempReg(parseState, &srcReg->Index)) RETURN_ERROR; } else if (token[0] == 'c') { if (!Parse_ParamReg(parseState, srcReg)) RETURN_ERROR; } else if (token[0] == 'v') { srcReg->File = PROGRAM_INPUT; if (!Parse_AttribReg(parseState, &srcReg->Index)) RETURN_ERROR; } else { RETURN_ERROR2("Bad source register name", token); } /* init swizzle fields */ srcReg->Swizzle[0] = 0; srcReg->Swizzle[1] = 1; srcReg->Swizzle[2] = 2; srcReg->Swizzle[3] = 3; /* Look for optional swizzle suffix */ if (!Peek_Token(parseState, token)) RETURN_ERROR; if (token[0] == '.') { (void) Parse_String(parseState, "."); /* consume . */ if (!Parse_Token(parseState, token)) RETURN_ERROR; if (token[1] == 0) { /* single letter swizzle */ if (token[0] == 'x') ASSIGN_4V(srcReg->Swizzle, 0, 0, 0, 0); else if (token[0] == 'y') ASSIGN_4V(srcReg->Swizzle, 1, 1, 1, 1); else if (token[0] == 'z') ASSIGN_4V(srcReg->Swizzle, 2, 2, 2, 2); else if (token[0] == 'w') ASSIGN_4V(srcReg->Swizzle, 3, 3, 3, 3); else RETURN_ERROR1("Expected x, y, z, or w"); } else { /* 2, 3 or 4-component swizzle */ GLint k; for (k = 0; token[k] && k < 5; k++) { if (token[k] == 'x') srcReg->Swizzle[k] = 0; else if (token[k] == 'y') srcReg->Swizzle[k] = 1; else if (token[k] == 'z') srcReg->Swizzle[k] = 2; else if (token[k] == 'w') srcReg->Swizzle[k] = 3; else RETURN_ERROR; } if (k >= 5) RETURN_ERROR; } } return GL_TRUE; }
static GLboolean Parse_MaskedDstReg(struct parse_state *parseState, struct vp_dst_register *dstReg) { GLubyte token[100]; /* Dst reg can be R<n> or o[n] */ if (!Peek_Token(parseState, token)) RETURN_ERROR; if (token[0] == 'R') { /* a temporary register */ dstReg->File = PROGRAM_TEMPORARY; if (!Parse_TempReg(parseState, &dstReg->Index)) RETURN_ERROR; } else if (!parseState->isStateProgram && token[0] == 'o') { /* an output register */ dstReg->File = PROGRAM_OUTPUT; if (!Parse_OutputReg(parseState, &dstReg->Index)) RETURN_ERROR; } else if (parseState->isStateProgram && token[0] == 'c' && parseState->isStateProgram) { /* absolute program parameter register */ /* Only valid for vertex state programs */ dstReg->File = PROGRAM_ENV_PARAM; if (!Parse_AbsParamReg(parseState, &dstReg->Index)) RETURN_ERROR; } else { RETURN_ERROR1("Bad destination register name"); } /* Parse optional write mask */ if (!Peek_Token(parseState, token)) RETURN_ERROR; if (token[0] == '.') { /* got a mask */ GLint k = 0; if (!Parse_String(parseState, ".")) RETURN_ERROR; if (!Parse_Token(parseState, token)) RETURN_ERROR; dstReg->WriteMask[0] = GL_FALSE; dstReg->WriteMask[1] = GL_FALSE; dstReg->WriteMask[2] = GL_FALSE; dstReg->WriteMask[3] = GL_FALSE; if (token[k] == 'x') { dstReg->WriteMask[0] = GL_TRUE; k++; } if (token[k] == 'y') { dstReg->WriteMask[1] = GL_TRUE; k++; } if (token[k] == 'z') { dstReg->WriteMask[2] = GL_TRUE; k++; } if (token[k] == 'w') { dstReg->WriteMask[3] = GL_TRUE; k++; } if (k == 0) { RETURN_ERROR1("Bad writemask character"); } return GL_TRUE; } else { dstReg->WriteMask[0] = GL_TRUE; dstReg->WriteMask[1] = GL_TRUE; dstReg->WriteMask[2] = GL_TRUE; dstReg->WriteMask[3] = GL_TRUE; return GL_TRUE; } }