CVPParser Class Reference

#include <vertex_program_parse.h>

---

Detailed Description

A vertex program parser.

Author:

Nicolas Vizerie

Nevrax France

Date:

2002

Definition at line 191 of file vertex_program_parse.h.

Public Types
typedef std::vector< CVPInstruction >	TProgram
Public Member Functions
bool	parse (const char *src, TProgram &result, std::string &errorOutput)
Static Public Member Functions
void	dump (const TProgram &prg, std::string &dest)
bool	isInputUsed (const TProgram &prg, CVPOperand::EInputRegister input)
Private Member Functions
bool	parseAddressRegister (CVPOperand &operand, std::string &errorOutput)
bool	parseConstantRegister (CVPOperand &operand, std::string &errorOutput)
bool	parseInputRegister (CVPOperand &operand, std::string &errorOutput)
bool	parseInstruction (CVPInstruction &instr, std::string &errorOutput, bool &endEncountered)
bool	parseOp2 (CVPInstruction &instr, std::string &errorOutput)
bool	parseOp3 (CVPInstruction &instr, std::string &errorOutput)
bool	parseOp4 (CVPInstruction &instr, std::string &errorOutput)
bool	parseOperand (CVPOperand &operand, bool outputOperand, std::string &errorOutput)
bool	parseOutputRegister (CVPOperand &operand, std::string &errorOutput)
bool	parseSwizzle (CVPSwizzle &swizzle, std::string &errorOutput)
bool	parseVariableRegister (CVPOperand &operand, std::string &errorOutput)
bool	parseWriteMask (uint &mask, std::string &errorOutput)
void	skipSpacesAndComments ()
Private Attributes
const char *	_CurrChar
uint	_LineIndex
const char *	_LineStart
uint	_RegisterMask [96]

---

Member Typedef Documentation

typedef std::vector<CVPInstruction> CVPParser::TProgram

Definition at line 194 of file vertex_program_parse.h. Referenced by NL3D::CDriverGL::activeEXTVertexShader(), NL3D::CDriverGL::activeNVVertexProgram(), dump(), NL3D::CMeshVPPerPixelLight::initInstance(), isInputUsed(), parse(), and NL3D::CDriverGL::setupEXTVertexShader().

---

Member Function Documentation

void CVPParser::dump (  const TProgram &  prg, std::string &  dest )  [static]

Debugging purpose : This output a parsed vertex program in a string, with the standard format. This can serve as a base for other format code generation Definition at line 1110 of file vertex_program_parse.cpp. References dumpInstr(), TProgram, and uint. { dest = "!!VP1.0 \n"; for(uint k = 0; k < prg.size(); ++k) { std::string instr; dumpInstr(prg[k], instr); dest += instr; } dest +="END"; }

bool CVPParser::isInputUsed (  const TProgram &  prg, CVPOperand::EInputRegister  input )  [static]

Definition at line 893 of file vertex_program_parse.cpp. References src, TProgram, and uint. Referenced by NL3D::CDriverGL::setupEXTVertexShader(). { for(uint k = 0; k < prg.size(); ++k) { uint numSrc = prg[k].getNumUsedSrc(); for(uint l = 0; l < numSrc; ++l) { const CVPOperand &src = prg[k].getSrc(l); if (src.Type == CVPOperand::InputRegister && src.Value.InputRegisterValue == input) return true; } } return false; }

bool CVPParser::parse (  const char *  src, TProgram &  result, std::string &  errorOutput )

Parse a vertex program, and convert to proprietary format. It is intended to be use by a driver implementation. Warning: : Only syntax is checked. It doesn't check that a register has been initialised before use. Parameters: src  The input text of a vertex program, in OpenGL format. result  The result program. errorOuput  If parsing failed, contains the reason Returns: true if the parsing succeeded Definition at line 921 of file vertex_program_parse.cpp. References _CurrChar, _LineIndex, _LineStart, _RegisterMask, getStringUntilCR(), parseInstruction(), src, NLMISC::toString(), and TProgram. Referenced by NL3D::CDriverGL::activeEXTVertexShader(), NL3D::CDriverGL::activeNVVertexProgram(), and NL3D::CMeshVPPerPixelLight::initInstance(). { if (!src) return false; // std::fill(_RegisterMask, _RegisterMask + 96, 0); // _CurrChar = src; _LineStart = src; _LineIndex = 1; // //skipSpacesAndComments(); // in fact space are not allowed at the start of the vertex program // parse version if ( _CurrChar[0] != '!' || _CurrChar[1] != '!' || _CurrChar[2] != 'V' || _CurrChar[3] != 'P' || _CurrChar[4] != '1' || _CurrChar[5] != '.' || (_CurrChar[6] != '0' && _CurrChar[6] != '1')) { errorOutput = "Can't parse version."; return false; } _CurrChar += 7; errorOutput.clear(); // parse instructions bool endEncoutered = false; std::string errorMess; for(;;) { CVPInstruction instr; if (!parseInstruction(instr, errorMess, endEncoutered)) { errorOutput = std::string("CVPParser::parse : Error encountered at line ") + NLMISC::toString(_LineIndex) + std::string(" : ") + errorMess + std::string(" Text : ") + getStringUntilCR(_LineStart); return false; } if (endEncoutered) break; result.push_back(instr); } return true; }

bool CVPParser::parseAddressRegister (  CVPOperand &  operand, std::string &  errorOutput )  [private]

Definition at line 533 of file vertex_program_parse.cpp. References _CurrChar, and CVPOperand::Type. Referenced by parseOperand(). { ++_CurrChar; operand.Type = CVPOperand::AddressRegister; if (_CurrChar[0] != '0' || _CurrChar[1] != '.' || _CurrChar[2] != 'x') { errorOutput = "Can't parse address register."; return false; } _CurrChar += 3; return true; }

bool CVPParser::parseConstantRegister (  CVPOperand &  operand, std::string &  errorOutput )  [private]

Definition at line 442 of file vertex_program_parse.cpp. References _CurrChar, index, CVPOperand::Indexed, parseUInt(), skipSpacesAndComments(), CVPOperand::Type, uint, and CVPOperand::Value. Referenced by parseOperand(). { ++_CurrChar; operand.Type = CVPOperand::Constant; if (*_CurrChar != '[') { errorOutput = "'[' expected when parsing a constant register."; return false; } ++_CurrChar; skipSpacesAndComments(); uint &index = operand.Value.ConstantValue; if (isdigit(*_CurrChar)) { // immediat case : c[0] to c[95] _CurrChar = parseUInt(_CurrChar, index); if (index > 95) { errorOutput = "Constant register index must range from 0 to 95."; return false; } operand.Indexed = false; } else if (*_CurrChar == 'A') { // indexed case : c[A0.x + 0] to c[A0.x + 95] operand.Indexed = true; index = 0; if (_CurrChar[1] == '0' && _CurrChar[2] == '.' && _CurrChar[3] == 'x') { _CurrChar += 4; skipSpacesAndComments(); if (*_CurrChar == '+') { ++ _CurrChar; skipSpacesAndComments(); if (isdigit(*_CurrChar)) { _CurrChar = parseUInt(_CurrChar, index); if (index > 95) { errorOutput = "Constant register index must range from 0 to 95."; return false; } } else { errorOutput = "Can't parse offset for constant register."; return false; } } } else { errorOutput = "Can't parse constant register index."; return false; } } skipSpacesAndComments(); if (*_CurrChar != ']') { errorOutput = "']' expected when parsing an input register."; return false; } ++_CurrChar; return true; }

bool CVPParser::parseInputRegister (  CVPOperand &  operand, std::string &  errorOutput )  [private]

Definition at line 224 of file vertex_program_parse.cpp. References _CurrChar, index, skipSpacesAndComments(), CVPOperand::Type, uint, uint32, and CVPOperand::Value. Referenced by parseOperand(). { ++_CurrChar; operand.Type = CVPOperand::InputRegister; if (*_CurrChar != '[') { errorOutput = "'[' expected when parsing an input register."; return false; } ++_CurrChar; skipSpacesAndComments(); if (isdigit(*_CurrChar)) { // The input register is expressed as an index uint index = *_CurrChar - '0'; ++_CurrChar; if (isdigit(*_CurrChar)) { index = 10 * index + (*_CurrChar - '0'); ++_CurrChar; } if (index > 15) { errorOutput = "Invalid index for input register, must be in [0, 15]."; return false; } operand.Value.InputRegisterValue = (CVPOperand::EInputRegister) index; } else { // The input register is expressed as a string uint32 strValue = 0; // read the 4 letters for(uint k = 0; k < 4; ++k) { if (!isalnum(*_CurrChar)) { errorOutput = "Can't parse index for input register."; return false; } strValue |= ((uint32) *_CurrChar) << (8 * (3 - k)); ++_CurrChar; } switch (strValue) { case 'OPOS': operand.Value.InputRegisterValue = CVPOperand::IPosition; break; case 'WGHT': operand.Value.InputRegisterValue = CVPOperand::IWeight; break; case 'NRML': operand.Value.InputRegisterValue = CVPOperand::INormal; break; case 'COL0': operand.Value.InputRegisterValue = CVPOperand::IPrimaryColor; break; case 'COL1': operand.Value.InputRegisterValue = CVPOperand::ISecondaryColor; break; case 'FOGC': operand.Value.InputRegisterValue = CVPOperand::IFogCoord; break; // texture argument case 'TEX0': case 'TEX1': case 'TEX2': case 'TEX3': case 'TEX4': case 'TEX5': case 'TEX6': case 'TEX7': operand.Value.InputRegisterValue = (CVPOperand::EInputRegister) (CVPOperand::ITex0 + strValue & 0xff - '0'); break; default: errorOutput = "Can't parse index for input register."; return false; } } skipSpacesAndComments(); if (*_CurrChar != ']') { errorOutput = "']' expected when parsing an input register."; return false; } ++ _CurrChar; return true; }

bool CVPParser::parseInstruction (  CVPInstruction &  instr, std::string &  errorOutput, bool &  endEncountered )  [private]

Definition at line 714 of file vertex_program_parse.cpp. References _CurrChar, _RegisterMask, CVPInstruction::Dest, END, CVPSwizzle::isScalar(), CVPInstruction::LOG, LOG, CVPInstruction::Opcode, parseOp2(), parseOp3(), parseOp4(), skipSpacesAndComments(), CVPInstruction::Src1, CVPOperand::Swizzle, CVPOperand::Type, uint, uint32, CVPOperand::Value, and CVPOperand::WriteMask. Referenced by parse(). { skipSpacesAndComments(); endEncountered = false; uint32 instrStr = 0; uint k; for(k = 0; k < 4; ++k) { if (!isalnum(*_CurrChar)) { if (k < 3) // at least 3 letter in an instruction { errorOutput = "Syntax error : can't read opcode."; return false; } else break; } instrStr |= ((uint) *_CurrChar) << (8 * (3 - k)); ++ _CurrChar; } if (k != 4) { instrStr |= (uint32) ' '; } switch (instrStr) { case 'ARL ': instr.Opcode = CVPInstruction::ARL; if (!parseOp2(instr, errorOutput)) return false; if (!instr.Src1.Swizzle.isScalar()) { errorOutput = "ARL need a scalar src value."; return false; } break; case 'RSQ ': instr.Opcode = CVPInstruction::RSQ; if (!parseOp2(instr, errorOutput)) return false; if (!instr.Src1.Swizzle.isScalar()) { errorOutput = "RSQ need a scalar src value."; return false; } break; case 'EXP ': case 'EXPP': instr.Opcode = CVPInstruction::EXPP; if (!parseOp2(instr, errorOutput)) return false; if (!instr.Src1.Swizzle.isScalar()) { errorOutput = "EXP need a scalar src value."; return false; } /* if (instr.Src1.Swizzle.Comp[0] != CVPSwizzle.W) { errorOutput = "EXPP input scalar must be w"; return false; }*/ break; case 'LOG ': instr.Opcode = CVPInstruction::LOG; if (!parseOp2(instr, errorOutput)) return false; if (!instr.Src1.Swizzle.isScalar()) { errorOutput = "LOG need a scalar src value."; return false; } /* if (instr.Src1.Swizzle.Comp[0] != CVPSwizzle.W) { errorOutput = "LOG input scalar must be w"; return false; } */ break; case 'RCP ': instr.Opcode = CVPInstruction::RCP; if (!parseOp2(instr, errorOutput)) return false; if (!instr.Src1.Swizzle.isScalar()) { errorOutput = "RCP need a scalar src value."; return false; } break; case 'MOV ': instr.Opcode = CVPInstruction::MOV; if (!parseOp2(instr, errorOutput)) return false; break; case 'LIT ': instr.Opcode = CVPInstruction::LIT; if (!parseOp2(instr, errorOutput)) return false; break; case 'MAD ': instr.Opcode = CVPInstruction::MAD; if (!parseOp4(instr, errorOutput)) return false; break; case 'ADD ': instr.Opcode = CVPInstruction::ADD; if (!parseOp3(instr, errorOutput)) return false; break; case 'MUL ': instr.Opcode = CVPInstruction::MUL; if (!parseOp3(instr, errorOutput)) return false; break; case 'DP3 ': instr.Opcode = CVPInstruction::DP3; if (!parseOp3(instr, errorOutput)) return false; break; case 'DP4 ': instr.Opcode = CVPInstruction::DP4; if (!parseOp3(instr, errorOutput)) return false; break; case 'DST ': instr.Opcode = CVPInstruction::DST; if (!parseOp3(instr, errorOutput)) return false; break; case 'MIN ': instr.Opcode = CVPInstruction::MIN; if (!parseOp3(instr, errorOutput)) return false; break; case 'MAX ': instr.Opcode = CVPInstruction::MAX; if (!parseOp3(instr, errorOutput)) return false; break; case 'SLT ': instr.Opcode = CVPInstruction::SLT; if (!parseOp3(instr, errorOutput)) return false; break; case 'SGE ': instr.Opcode = CVPInstruction::SGE; if (!parseOp3(instr, errorOutput)) return false; break; case 'END ': endEncountered = true; return true; break; default: errorOutput = "Syntax error : unknow opcode."; return false; break; } if (instr.Dest.Type == CVPOperand::Variable) { _RegisterMask[instr.Dest.Value.VariableValue] |= instr.Dest.WriteMask; } // it is not allowed to write to an adress register except for ARL if (instrStr != 'ARL ') { if (instr.Dest.Type == CVPOperand::AddressRegister) { errorOutput = "Can't write to address register."; return false; } } // parse semi-colon skipSpacesAndComments(); // if (*_CurrChar != ';') { errorOutput = "';' expected."; return false; } ++_CurrChar; return true; }

bool CVPParser::parseOp2 (  CVPInstruction &  instr, std::string &  errorOutput )  [private]

Definition at line 547 of file vertex_program_parse.cpp. References _CurrChar, CVPInstruction::Dest, parseOperand(), skipSpacesAndComments(), CVPInstruction::Src1, and CVPOperand::Type. Referenced by parseInstruction(), and parseOp3(). { skipSpacesAndComments(); // parse ouput if (!parseOperand(instr.Dest, true, errorOutput)) return false; // Can't write in input or consant register if (instr.Dest.Type == CVPOperand::Constant || instr.Dest.Type == CVPOperand::InputRegister) { errorOutput = "Can't write to a constant or input register"; return false; } // skipSpacesAndComments(); if (*_CurrChar != ',') { errorOutput = "',' expected."; return false; } ++_CurrChar; skipSpacesAndComments(); // parse src1 if (!parseOperand(instr.Src1, false, errorOutput)) return false; if (instr.Src1.Type == CVPOperand::AddressRegister || instr.Src1.Type == CVPOperand::OutputRegister) { errorOutput = "Src1 must be constant, variable, or input register."; return false; } return true; }

bool CVPParser::parseOp3 (  CVPInstruction &  instr, std::string &  errorOutput )  [private]

Definition at line 579 of file vertex_program_parse.cpp. References _CurrChar, CVPOperand::Indexed, parseOp2(), parseOperand(), skipSpacesAndComments(), CVPInstruction::Src1, CVPInstruction::Src2, CVPOperand::Type, and CVPOperand::Value. Referenced by parseInstruction(), and parseOp4(). { if (!parseOp2(instr, errorOutput)) return false; skipSpacesAndComments(); if (*_CurrChar != ',') { errorOutput = "',' expected."; return false; } ++_CurrChar; skipSpacesAndComments(); // parse src2 if (!parseOperand(instr.Src2, false, errorOutput)) return false; if (instr.Src2.Type == CVPOperand::AddressRegister || instr.Src2.Type == CVPOperand::OutputRegister) { errorOutput = "Src2 must be constant, variable, or input register."; return false; } // make sure we do not have 2 =/= contant register as src (or in put register) // 2 constant registers ? if (instr.Src1.Type == CVPOperand::Constant && instr.Src2.Type == CVPOperand::Constant) { // the index must be the same if (! ( instr.Src1.Indexed == instr.Src2.Indexed && instr.Src1.Value.ConstantValue == instr.Src2.Value.ConstantValue ) ) { errorOutput = "Can't read 2 different constant registers in a single instruction."; return false; } } // 2 input registers ? if (instr.Src1.Type == CVPOperand::InputRegister && instr.Src2.Type == CVPOperand::InputRegister) { // the index must be the same if (instr.Src1.Value.InputRegisterValue != instr.Src2.Value.InputRegisterValue) { errorOutput = "Can't read 2 different input registers in a single instruction."; return false; } } return true; }

bool CVPParser::parseOp4 (  CVPInstruction &  instr, std::string &  errorOutput )  [private]

Definition at line 632 of file vertex_program_parse.cpp. References _CurrChar, CVPOperand::Indexed, parseOp3(), parseOperand(), skipSpacesAndComments(), CVPInstruction::Src1, CVPInstruction::Src2, CVPInstruction::Src3, CVPOperand::Type, and CVPOperand::Value. Referenced by parseInstruction(). { if (!parseOp3(instr, errorOutput)) return false; // parse src 3 skipSpacesAndComments(); if (*_CurrChar != ',') { errorOutput = "',' expected."; return false; } ++_CurrChar; skipSpacesAndComments(); // parse src4 if (!parseOperand(instr.Src3, false, errorOutput)) return false; if (instr.Src3.Type == CVPOperand::AddressRegister || instr.Src3.Type == CVPOperand::OutputRegister) { errorOutput = "Src3 must be constant, variable, or input register."; return false; } // check for different contant / input registers // // Duplicated constant register if (instr.Src3.Type == CVPOperand::Constant) { if (instr.Src1.Type == CVPOperand::Constant) { if (! ( instr.Src1.Indexed == instr.Src3.Indexed && instr.Src1.Value.ConstantValue == instr.Src3.Value.ConstantValue ) ) { errorOutput = "Can't read 2 different constant registers in a single instruction."; return false; } } if (instr.Src2.Type == CVPOperand::Constant) { if (! ( instr.Src2.Indexed == instr.Src3.Indexed && instr.Src2.Value.ConstantValue == instr.Src3.Value.ConstantValue ) ) { errorOutput = "Can't read 2 different constant registers in a single instruction."; return false; } } } // Duplicated input register if (instr.Src3.Type == CVPOperand::InputRegister) { if (instr.Src1.Type == CVPOperand::InputRegister) { if (instr.Src1.Value.InputRegisterValue != instr.Src3.Value.InputRegisterValue) { errorOutput = "Can't read 2 different input registers in a single instruction."; return false; } } if (instr.Src2.Type == CVPOperand::InputRegister) { if (instr.Src2.Value.InputRegisterValue != instr.Src3.Value.InputRegisterValue) { errorOutput = "Can't read 2 different input registers in a single instruction."; return false; } } } return true; }

bool CVPParser::parseOperand (  CVPOperand &  operand, bool  outputOperand, std::string &  errorOutput )  [private]

Definition at line 142 of file vertex_program_parse.cpp. References _CurrChar, _RegisterMask, CVPSwizzle::Comp, CVPOperand::Negate, parseAddressRegister(), parseConstantRegister(), parseInputRegister(), parseOutputRegister(), parseSwizzle(), parseVariableRegister(), parseWriteMask(), skipSpacesAndComments(), CVPOperand::Swizzle, CVPOperand::Type, uint, CVPOperand::Value, and CVPOperand::WriteMask. Referenced by parseOp2(), parseOp3(), and parseOp4(). { skipSpacesAndComments(); bool result; if (outputOperand) { operand.Negate = false; switch(*_CurrChar) { case 'o': result = parseOutputRegister(operand, errorOutput); break; case 'R': result = parseVariableRegister(operand, errorOutput); break; case 'A': result = parseAddressRegister(operand, errorOutput); break; case '-': errorOutput = "Negation not allowed on ouput register."; return false; default: errorOutput = "Output, Address, or Temporary register expected as an output operand."; return false; } if (!result) return false; // parse the write mask return parseWriteMask(operand.WriteMask, errorOutput); } else { operand.Negate = false; switch(*_CurrChar) { case 'v': result = parseInputRegister(operand, errorOutput); break; case 'R': result = parseVariableRegister(operand, errorOutput); break; case 'c': result = parseConstantRegister(operand, errorOutput); break; case 'a': result = parseAddressRegister(operand, errorOutput); break; case '-': { operand.Negate = true; // negation ++ _CurrChar; skipSpacesAndComments(); switch(*_CurrChar) { case 'v': result = parseInputRegister(operand, errorOutput); break; case 'R': result = parseVariableRegister(operand, errorOutput); break; case 'c': result = parseConstantRegister(operand, errorOutput); break; default: errorOutput = "Negation must be followed by an input register, a variable register, or a constant."; return false; break; } } break; default: errorOutput = "Syntax error."; return false; break; } if (!result) return false; if (operand.Type != CVPOperand::AddressRegister) { if (!parseSwizzle(operand.Swizzle, errorOutput)) return false; if (operand.Type == CVPOperand::Variable) { for(uint k = 0; k < 4; ++k) { if (!(_RegisterMask[operand.Value.VariableValue] & (1 << operand.Swizzle.Comp[k]))) { errorOutput = "Can't read a register component before writing to it."; return false; } } } } return true; } }

bool CVPParser::parseOutputRegister (  CVPOperand &  operand, std::string &  errorOutput )  [private]

Definition at line 370 of file vertex_program_parse.cpp. References _CurrChar, skipSpacesAndComments(), CVPOperand::Type, uint, uint32, and CVPOperand::Value. Referenced by parseOperand(). { ++_CurrChar; operand.Type = CVPOperand::OutputRegister; if (*_CurrChar != '[') { errorOutput = "'[' expected when parsing an ouput register."; return false; } ++_CurrChar; skipSpacesAndComments(); // The input register is expressed as a string uint32 strValue = 0; // read the 4 letters for(uint k = 0; k < 4; ++k) { if (!isalnum(*_CurrChar)) { errorOutput = "Can't parse index for output register."; return false; } strValue |= ((uint32) *_CurrChar) << (8 * (3 - k)); ++_CurrChar; } // convert to enum switch(strValue) { case 'HPOS': operand.Value.OutputRegisterValue = CVPOperand::OHPosition; break; case 'COL0': operand.Value.OutputRegisterValue = CVPOperand::OPrimaryColor; break; case 'COL1': operand.Value.OutputRegisterValue = CVPOperand::OSecondaryColor; break; case 'BFC0': operand.Value.OutputRegisterValue = CVPOperand::OBackFacePrimaryColor; break; case 'BFC1': operand.Value.OutputRegisterValue = CVPOperand::OBackFaceSecondaryColor; break; case 'FOGC': operand.Value.OutputRegisterValue = CVPOperand::OFogCoord; break; case 'PSIZ': operand.Value.OutputRegisterValue = CVPOperand::OPointSize; break; case 'TEX0': operand.Value.OutputRegisterValue = CVPOperand::OTex0; break; case 'TEX1': operand.Value.OutputRegisterValue = CVPOperand::OTex1; break; case 'TEX2': operand.Value.OutputRegisterValue = CVPOperand::OTex2; break; case 'TEX3': operand.Value.OutputRegisterValue = CVPOperand::OTex3; break; case 'TEX4': operand.Value.OutputRegisterValue = CVPOperand::OTex4; break; case 'TEX5': operand.Value.OutputRegisterValue = CVPOperand::OTex5; break; case 'TEX6': operand.Value.OutputRegisterValue = CVPOperand::OTex6; break; case 'TEX7': operand.Value.OutputRegisterValue = CVPOperand::OTex7; break; default: errorOutput = "Can't read index for output register."; return false; break; } skipSpacesAndComments(); if (*_CurrChar != ']') { errorOutput = "']' expected when parsing an output register."; return false; } ++_CurrChar; return true; }

bool CVPParser::parseSwizzle (  CVPSwizzle &  swizzle, std::string &  errorOutput )  [private]

Definition at line 315 of file vertex_program_parse.cpp. References _CurrChar, CVPSwizzle::Comp, letterToSwizzleComp(), and uint. Referenced by parseOperand(). { if (*_CurrChar != '.') { // no swizzle swizzle.Comp[0] = CVPSwizzle::X; swizzle.Comp[1] = CVPSwizzle::Y; swizzle.Comp[2] = CVPSwizzle::Z; swizzle.Comp[3] = CVPSwizzle::W; return true; } ++_CurrChar; // 4 letters case for(uint k = 0; k < 4; ++k) { if (!isalpha(*_CurrChar)) { if (k == 1) // 1 letter case { switch(*_CurrChar) { case ',': case ';': case ' ': case '\t': case '\r': case '\n': case '#': swizzle.Comp[1] = swizzle.Comp[2] = swizzle.Comp[3] = swizzle.Comp[0]; return true; break; default: errorOutput = "Can't parse swizzle."; } } else { errorOutput = "Invalid swizzle value."; return false; } } if (!letterToSwizzleComp(*_CurrChar, swizzle.Comp[k])) { errorOutput = "Invalid swizzle value."; return false; } ++ _CurrChar; } return true; }

bool CVPParser::parseVariableRegister (  CVPOperand &  operand, std::string &  errorOutput )  [private]

Definition at line 513 of file vertex_program_parse.cpp. References _CurrChar, index, parseUInt(), CVPOperand::Type, uint, and CVPOperand::Value. Referenced by parseOperand(). { ++_CurrChar; operand.Type = CVPOperand::Variable; if (!isdigit(*_CurrChar)) { errorOutput = "Can't parse variable register."; return false; } uint &index = operand.Value.VariableValue; _CurrChar = parseUInt(_CurrChar, index); if (index > 11) { errorOutput = "Variable register index must range from 0 to 11."; return false; } return true; }

bool CVPParser::parseWriteMask (  uint &  mask, std::string &  errorOutput )  [private]

Definition at line 31 of file vertex_program_parse.cpp. References _CurrChar, and uint. Referenced by parseOperand(). { // parse output mask if (*_CurrChar != '.') { // no output masks mask = 0xf; //output 4 coordinates return true; } else { ++ _CurrChar; mask = 0; for(uint k = 0; k < 4; ++k) { uint maskIndex; switch(*_CurrChar) { case 'x': maskIndex = 0; break; case 'y': maskIndex = 1; break; case 'z': maskIndex = 2; break; case 'w': maskIndex = 3; break; default: if (k >= 1) return true; else { errorOutput = "Can't parse output mask."; return false; } break; } ++_CurrChar; if (mask & (1 << maskIndex)) { errorOutput = "Duplicated output mask component."; return false; } mask |= 1 << maskIndex; } return true; } }

void CVPParser::skipSpacesAndComments (   )  [private]

Skip tabulation and space in a source code Definition at line 77 of file vertex_program_parse.cpp. References _CurrChar, _LineIndex, and _LineStart. Referenced by parseConstantRegister(), parseInputRegister(), parseInstruction(), parseOp2(), parseOp3(), parseOp4(), parseOperand(), and parseOutputRegister(). { bool stop = false; do { switch(*_CurrChar) { case '\t': case '\r': case ' ' : ++_CurrChar; break; // case '\n': ++_CurrChar; ++_LineIndex; _LineStart = _CurrChar; break; case '#': // comment go till end of line while (*_CurrChar != '\n' && *_CurrChar != '\0') ++_CurrChar; skipSpacesAndComments(); break; default: stop = true; break; } } while (!stop); }

---

Field Documentation

const char* CVPParser::_CurrChar [private]

Definition at line 216 of file vertex_program_parse.h. Referenced by parse(), parseAddressRegister(), parseConstantRegister(), parseInputRegister(), parseInstruction(), parseOp2(), parseOp3(), parseOp4(), parseOperand(), parseOutputRegister(), parseSwizzle(), parseVariableRegister(), parseWriteMask(), and skipSpacesAndComments().

uint CVPParser::_LineIndex [private]

Definition at line 218 of file vertex_program_parse.h. Referenced by parse(), and skipSpacesAndComments().

const char* CVPParser::_LineStart [private]

Definition at line 217 of file vertex_program_parse.h. Referenced by parse(), and skipSpacesAndComments().

uint CVPParser::_RegisterMask[96] [private]

Definition at line 219 of file vertex_program_parse.h. Referenced by parse(), parseInstruction(), and parseOperand().

---

The documentation for this class was generated from the following files:

• vertex_program_parse.h
• vertex_program_parse.cpp

---