bool ReturnNode::checkReturn(DataType returnType, SemanticDebugger *semanticDebugger) { if(returnType != DATA_TYPE_UNDEFINED && returnType != DATA_TYPE_VOID) { DataType expressionType = this->expression_->typeCheck(semanticDebugger); this->returnType_ = expressionType; if(expressionType != returnType && expressionType != DATA_TYPE_ERROR) { const char *returnTypeName = getDataTypeName(returnType); const char *expressionTypeName = getDataTypeName(expressionType); semanticDebugger->debugTypeMismatchError("return", returnTypeName, expressionTypeName, this->expression_->getFirstLine()); } else if(expressionType == returnType && this->expression_->isConstant()) { this->expression_ = this->expression_->getConstantExpression(); } } else if(returnType ==DATA_TYPE_VOID) { semanticDebugger->debugReturnInProcedureError(this->getFirstLine()); } else { semanticDebugger->debugReturnOutOfFunctionError(this->getFirstLine()); } return true; }
void Db::createTable(const Table& table) { table.assertNonMutable(); std::string sql; if (!table.check()) { throw std::invalid_argument("The Table definition is invalid"); } sql.append("CREATE "); if(table.isTemporary()) { sql.append("TEMPORARY "); } sql.append(" TABLE ").append(table.getName()).append("( "); if (table.isAutoPK()) { sql.append("id INTEGER PRIMARY KEY ASC, "); } const std::vector<std::string>& column_name(table.getColumnName()); const std::vector<DataType>& column_type(table.getColumnType()); for(size_t i; i < column_name.size(); i++) { sql.append(column_name[i]). append(" ").append(getDataTypeName(column_type[i])).append(" "); if (i == table.getPK() & !table.isAutoPK()) { sql.append("PRIMARY KEY, "); } else { sql.append(", "); } } sql.resize(sql.size() - 2); sql.append(");"); this->exec(sql); }
void interpreteByteCode(char *buf, int length) { char *progBuf = buf; char *stop = progBuf + length; struct instruction instruct; long offset; long count; long l; double d; enum data_type type; while (progBuf < stop) { /*get instruction info*/ printf("Offset: %ld\n", progBuf - buf); instruct = GetInstructionAndAdvance(progBuf); printf("OP[%X]: %s\n", instruct.opType, getName(instruct.opType)); switch (instruct.opType) { case iJMP: case iJMPF: case iJMPT: case iLVPUSH: case iGVPUSH: offset = GetTypeAndAdvance(progBuf, long); printf("\toffset: %ld\n", offset); break; case iIPUSH: l = GetTypeAndAdvance(progBuf, long); printf("\tValue: %ld\n", l); break; case iFPUSH: d = GetTypeAndAdvance(progBuf, double); printf("\tValue: %lf\n", d); break; case iVALLOC: case iVDALLOC: count = GetTypeAndAdvance(progBuf, long); printf("\tCount: %ld\n", count); break; case iVSETTYPE: offset = GetTypeAndAdvance(progBuf, long); type = GetTypeAndAdvance(progBuf, enum datasource); printf("\tOffset: %ld\n", offset); printf("\tType: %s\n", getDataTypeName(type)); break; default: break; } } }
PropertyHelper<UBox>::return_type PropertyHelper<UBox>::fromString(const String& str) { UBox ret(UDim(0.0f, 0.0f), UDim(0.0f, 0.0f), UDim(0.0f, 0.0f), UDim(0.0f, 0.0f)); if (str.empty()) return ret; std::stringstream& sstream = SharedStringstream::GetPreparedStream(str); sstream >> ret; if (sstream.fail()) throwParsingException(getDataTypeName(), str); return ret; }
PropertyHelper<URect>::return_type PropertyHelper<URect>::fromString(const String& str) { URect ur(UVector2(UDim(0.0f, 0.0f), UDim(0.0f, 0.0f)), UVector2(UDim(0.0f, 0.0f), UDim(0.0f, 0.0f))); if (str.empty()) return ur; std::stringstream& sstream = SharedStringstream::GetPreparedStream(str); sstream >> ur; if (sstream.fail()) throwParsingException(getDataTypeName(), str); return ur; }
PropertyHelper<UDim>::return_type PropertyHelper<UDim>::fromString(const String& str) { UDim ud(0.0f, 0.0f); if (str.empty()) return ud; std::stringstream& sstream = SharedStringstream::GetPreparedStream(str); sstream >> ud; if (sstream.fail()) throwParsingException(getDataTypeName(), str); return ud; }
PropertyHelper<float>::return_type PropertyHelper<float>::fromString(const String& str) { float val = 0.0f; if (str.empty()) return val; std::stringstream& sstream = SharedStringstream::GetPreparedStream(str); sstream >> val; if (sstream.fail()) throwParsingException(getDataTypeName(), str); return val; }
void FormalParameterInformation::debug(SymbolTableDebugger *symbolTableDebugger) { const char *categoryTypeName = getIdentifierCategoryTypeName( this->getCategoryType() ); const char *typeName = getDataTypeName( this->getType() ); stringstream scopeLevelStr; scopeLevelStr << this->getScopeLevel(); symbolTableDebugger->debugIdentifierInfo(categoryTypeName); symbolTableDebugger->debugIdentifierInfoAttribute("Identifier", this->getIdentifier()); symbolTableDebugger->debugIdentifierInfoAttribute("Type", typeName); symbolTableDebugger->debugIdentifierInfoAttribute("Scope Level", scopeLevelStr.str().c_str()); symbolTableDebugger->newLine(); }
void FunctionNode::debug(ASTDebugger * astDebugger, int nodeLevel) { astDebugger->openParentNode("Function/Procedure", nodeLevel); string functionIdentifier = "Identifier: "; functionIdentifier += getIdentifier(); string functionReturnType = "Return Type: "; functionReturnType += getDataTypeName( getReturnType() ); astDebugger->insertLeafNode(functionIdentifier.c_str(), nodeLevel + 1); astDebugger->insertLeafNode(functionReturnType.c_str(), nodeLevel + 1); this->declarations_->debug(astDebugger, nodeLevel + 1); this->statements_->debug(astDebugger, nodeLevel + 1); astDebugger->closeParentNode("Function/Procedure", nodeLevel); }
/// override the default display just so we can overlay a bit more text void TerrainDemo::renderme(void) { // give base class a shot DemoApplication::renderme(); // overlay any debug information if (m_dynamicsWorld) m_dynamicsWorld->debugDrawWorld(); // switch to orthographic setOrthographicProjection(); // we'll draw on the right top of the screen const int lineWidth = 200; const int lineHeight = 16; char buffer[256]; int xStart = m_glutScreenWidth - lineWidth; int yStart = lineHeight; sprintf(buffer, "Terrain Type: %s", getTerrainTypeName(m_model)); doPrint(xStart, yStart, lineHeight, buffer); doPrint(xStart, yStart, lineHeight, "Press ',' to cycle terrain types"); doPrint(xStart, yStart, lineHeight, ""); sprintf(buffer, "Data Type: %s", getDataTypeName(m_type)); doPrint(xStart, yStart, lineHeight, buffer); doPrint(xStart, yStart, lineHeight, "Press '/' to cycle data types"); doPrint(xStart, yStart, lineHeight, ""); sprintf(buffer, "'up' axis: %s", getUpAxisName(m_upAxis)); doPrint(xStart, yStart, lineHeight, buffer); doPrint(xStart, yStart, lineHeight, "Press '\\' to cycle 'up' axes"); doPrint(xStart, yStart, lineHeight, ""); if (eRadial == m_model) { sprintf(buffer, "Dynamic: %s", m_isDynamic ? "yes" : "no"); doPrint(xStart, yStart, lineHeight, buffer); doPrint(xStart, yStart, lineHeight, "Press '[' to toggle dynamics"); } }
PropertyHelper<Font*>::return_type PropertyHelper<Font*>::fromString(const String& str) { // handle empty string case if (str.empty()) return 0; PropertyHelper<Font*>::return_type image; try { image = &FontManager::getSingleton().get(str); } catch (UnknownObjectException&) { image = 0; throwParsingException(getDataTypeName(), str); } return image; }
void FunctionNode::typeCheck(SemanticDebugger *semanticDebugger) { DataType returnType = this->getReturnType(); bool inRepetition = false; this->declarations_->typeCheck(semanticDebugger); this->statements_->typeCheck(semanticDebugger); this->statements_->checkRepetition(inRepetition, semanticDebugger); if(!this->statements_->checkReturn(returnType, semanticDebugger)) { if(returnType != DATA_TYPE_VOID) { semanticDebugger->debugMissingReturnError(this->getIdentifier(), getDataTypeName(returnType), this->getFirstLine()); } } }
PropertyHelper<ColourRect>::return_type PropertyHelper<ColourRect>::fromString(const String& str) { ColourRect val(Colour(0xFF000000)); if (str.empty()) return val; std::stringstream& sstream = SharedStringstream::GetPreparedStream(str); if (str.length() == 8) { CEGUI::Colour colourForEntireRect(0xFF000000); sstream >> colourForEntireRect; if (sstream.fail()) throwParsingException(getDataTypeName(), str); val = ColourRect(colourForEntireRect); return val; }
DataType FunctionCallNode::typeCheck(SemanticDebugger *semanticDebugger) { list<ExpressionNode *> &expList = this->actualParameterList_->getActualParameterList(); list<FormalParameterInformation *> &parList = this->functionInfo_->getFormalParameterList(); if(expList.size() != parList.size()) { string paramListStr = ""; size_t paramIndex = 0; list<FormalParameterInformation *>::iterator formalIt = parList.begin(); while(paramIndex < parList.size() - 1) { paramListStr += getDataTypeName( (*formalIt)->getType() ); paramListStr += ", "; formalIt++; paramIndex++; } paramListStr += getDataTypeName( (*formalIt)->getType() ); const char *returnTypeName = getDataTypeName(this->getReturnType()); //Incorrect number of arguments calling the function 'data_type name(arg_list)' semanticDebugger->debugIncorrectArgumentNumberError(this->getIdentifier(), paramListStr.c_str(),returnTypeName, this->getFirstLine()); setDataType(DATA_TYPE_ERROR); return DATA_TYPE_ERROR; } else { list<ExpressionNode *>::iterator actualIt = expList.begin(); list<FormalParameterInformation *>::iterator formalIt = parList.begin(); size_t paramNum = 1; while(actualIt != expList.end()) { DataType actualType = (*actualIt)->typeCheck(semanticDebugger); DataType expectedType = (*formalIt)->getType(); if(actualType != expectedType) { if(actualType != DATA_TYPE_ERROR) { //Type mismatch while calling the function 'F' in the parameter // of number #. Expected XXX instead of YY. const char *expectedTypeName = getDataTypeName(expectedType); const char *actualTypeName = getDataTypeName(actualType); const char *returnTypeName = getDataTypeName(this->getReturnType()); semanticDebugger->debugFunctionArgumentMismatchError( this->getIdentifier(), paramNum, expectedTypeName, actualTypeName, returnTypeName, this->getFirstLine()); } setDataType(DATA_TYPE_ERROR); return DATA_TYPE_ERROR; } else { if((*actualIt)->isConstant()) { *actualIt = (*actualIt)->getConstantExpression(); } } formalIt++; actualIt++; paramNum++; } setDataType(this->getReturnType()); return this->getReturnType(); } }
static ShaderLoopCase* createGenericLoopCase (Context& context, const char* caseName, const char* description, bool isVertexCase, LoopType loopType, LoopCountType loopCountType, Precision loopCountPrecision, DataType loopCountDataType) { std::ostringstream vtx; std::ostringstream frag; std::ostringstream& op = isVertexCase ? vtx : frag; vtx << "#version 300 es\n"; frag << "#version 300 es\n"; vtx << "in highp vec4 a_position;\n"; vtx << "in highp vec4 a_coords;\n"; frag << "layout(location = 0) out mediump vec4 o_color;\n"; if (loopCountType == LOOPCOUNT_DYNAMIC) vtx << "in mediump float a_one;\n"; if (isVertexCase) { vtx << "out mediump vec3 v_color;\n"; frag << "in mediump vec3 v_color;\n"; } else { vtx << "out mediump vec4 v_coords;\n"; frag << "in mediump vec4 v_coords;\n"; if (loopCountType == LOOPCOUNT_DYNAMIC) { vtx << "out mediump float v_one;\n"; frag << "in mediump float v_one;\n"; } } // \todo [petri] Pass numLoopIters from outside? int numLoopIters = 3; bool isIntCounter = isDataTypeIntOrIVec(loopCountDataType); if (isIntCounter) { if (loopCountType == LOOPCOUNT_UNIFORM || loopCountType == LOOPCOUNT_DYNAMIC) op << "uniform ${COUNTER_PRECISION} int " << getIntUniformName(numLoopIters) << ";\n"; } else { if (loopCountType == LOOPCOUNT_UNIFORM || loopCountType == LOOPCOUNT_DYNAMIC) op << "uniform ${COUNTER_PRECISION} float " << getFloatFractionUniformName(numLoopIters) << ";\n"; if (numLoopIters != 1) op << "uniform ${COUNTER_PRECISION} float uf_one;\n"; } vtx << "\n"; vtx << "void main()\n"; vtx << "{\n"; vtx << " gl_Position = a_position;\n"; frag << "\n"; frag << "void main()\n"; frag << "{\n"; if (isVertexCase) vtx << " ${PRECISION} vec4 coords = a_coords;\n"; else frag << " ${PRECISION} vec4 coords = v_coords;\n"; if (loopCountType == LOOPCOUNT_DYNAMIC) { if (isIntCounter) { if (isVertexCase) vtx << " ${COUNTER_PRECISION} int one = int(a_one + 0.5);\n"; else frag << " ${COUNTER_PRECISION} int one = int(v_one + 0.5);\n"; } else { if (isVertexCase) vtx << " ${COUNTER_PRECISION} float one = a_one;\n"; else frag << " ${COUNTER_PRECISION} float one = v_one;\n"; } } // Read array. op << " ${PRECISION} vec4 res = coords;\n"; // Loop iteration count. string iterMaxStr; if (isIntCounter) { if (loopCountType == LOOPCOUNT_CONSTANT) iterMaxStr = de::toString(numLoopIters); else if (loopCountType == LOOPCOUNT_UNIFORM) iterMaxStr = getIntUniformName(numLoopIters); else if (loopCountType == LOOPCOUNT_DYNAMIC) iterMaxStr = string(getIntUniformName(numLoopIters)) + "*one"; else DE_ASSERT(false); } else { if (loopCountType == LOOPCOUNT_CONSTANT) iterMaxStr = "1.0"; else if (loopCountType == LOOPCOUNT_UNIFORM) iterMaxStr = "uf_one"; else if (loopCountType == LOOPCOUNT_DYNAMIC) iterMaxStr = "uf_one*one"; else DE_ASSERT(false); } // Loop operations. string initValue = isIntCounter ? "0" : "0.05"; string loopCountDeclStr = "${COUNTER_PRECISION} ${LOOP_VAR_TYPE} ndx = " + initValue; string loopCmpStr = ("ndx < " + iterMaxStr); string incrementStr; if (isIntCounter) incrementStr = "ndx++"; else { if (loopCountType == LOOPCOUNT_CONSTANT) incrementStr = string("ndx += ") + de::toString(1.0f / numLoopIters); else if (loopCountType == LOOPCOUNT_UNIFORM) incrementStr = string("ndx += ") + getFloatFractionUniformName(numLoopIters); else if (loopCountType == LOOPCOUNT_DYNAMIC) incrementStr = string("ndx += ") + getFloatFractionUniformName(numLoopIters) + "*one"; else DE_ASSERT(false); } // Loop body. string loopBody; loopBody = " res = res.yzwx;\n"; if (loopType == LOOPTYPE_FOR) { op << " for (" + loopCountDeclStr + "; " + loopCmpStr + "; " + incrementStr + ")\n"; op << " {\n"; op << loopBody; op << " }\n"; } else if (loopType == LOOPTYPE_WHILE) { op << "\t" << loopCountDeclStr + ";\n"; op << " while (" + loopCmpStr + ")\n"; op << " {\n"; op << loopBody; op << "\t\t" + incrementStr + ";\n"; op << " }\n"; } else if (loopType == LOOPTYPE_DO_WHILE) { op << "\t" << loopCountDeclStr + ";\n"; op << " do\n"; op << " {\n"; op << loopBody; op << "\t\t" + incrementStr + ";\n"; op << " } while (" + loopCmpStr + ");\n"; } else DE_ASSERT(false); if (isVertexCase) { vtx << " v_color = res.rgb;\n"; frag << " o_color = vec4(v_color.rgb, 1.0);\n"; } else { vtx << " v_coords = a_coords;\n"; frag << " o_color = vec4(res.rgb, 1.0);\n"; if (loopCountType == LOOPCOUNT_DYNAMIC) vtx << " v_one = a_one;\n"; } vtx << "}\n"; frag << "}\n"; // Fill in shader templates. map<string, string> params; params.insert(pair<string, string>("LOOP_VAR_TYPE", getDataTypeName(loopCountDataType))); params.insert(pair<string, string>("PRECISION", "mediump")); params.insert(pair<string, string>("COUNTER_PRECISION", getPrecisionName(loopCountPrecision))); StringTemplate vertTemplate(vtx.str().c_str()); StringTemplate fragTemplate(frag.str().c_str()); string vertexShaderSource = vertTemplate.specialize(params); string fragmentShaderSource = fragTemplate.specialize(params); // Create the case. ShaderEvalFunc evalFunc = getLoopEvalFunc(numLoopIters); return new ShaderLoopCase(context, caseName, description, isVertexCase, evalFunc, vertexShaderSource.c_str(), fragmentShaderSource.c_str()); }
void ShaderLoopTests::init (void) { // Loop cases. static const ShaderType s_shaderTypes[] = { SHADERTYPE_VERTEX, SHADERTYPE_FRAGMENT }; static const DataType s_countDataType[] = { TYPE_INT, TYPE_FLOAT }; for (int loopType = 0; loopType < LOOPTYPE_LAST; loopType++) { const char* loopTypeName = getLoopTypeName((LoopType)loopType); for (int loopCountType = 0; loopCountType < LOOPCOUNT_LAST; loopCountType++) { const char* loopCountName = getLoopCountTypeName((LoopCountType)loopCountType); string groupName = string(loopTypeName) + "_" + string(loopCountName) + "_iterations"; string groupDesc = string("Loop tests with ") + loopCountName + " loop counter."; TestCaseGroup* group = new TestCaseGroup(m_context, groupName.c_str(), groupDesc.c_str()); addChild(group); // Generic cases. for (int precision = 0; precision < PRECISION_LAST; precision++) { const char* precisionName = getPrecisionName((Precision)precision); for (int dataTypeNdx = 0; dataTypeNdx < DE_LENGTH_OF_ARRAY(s_countDataType); dataTypeNdx++) { DataType loopDataType = s_countDataType[dataTypeNdx]; const char* dataTypeName = getDataTypeName(loopDataType); for (int shaderTypeNdx = 0; shaderTypeNdx < DE_LENGTH_OF_ARRAY(s_shaderTypes); shaderTypeNdx++) { ShaderType shaderType = s_shaderTypes[shaderTypeNdx]; const char* shaderTypeName = getShaderTypeName(shaderType); bool isVertexCase = (shaderType == SHADERTYPE_VERTEX); string name = string("basic_") + precisionName + "_" + dataTypeName + "_" + shaderTypeName; string desc = string(loopTypeName) + " loop with " + precisionName + dataTypeName + " " + loopCountName + " iteration count in " + shaderTypeName + " shader."; group->addChild(createGenericLoopCase(m_context, name.c_str(), desc.c_str(), isVertexCase, (LoopType)loopType, (LoopCountType)loopCountType, (Precision)precision, loopDataType)); } } } // Special cases. for (int loopCase = 0; loopCase < LOOPCASE_LAST; loopCase++) { const char* loopCaseName = getLoopCaseName((LoopCase)loopCase); // no-iterations not possible with do-while. if ((loopCase == LOOPCASE_NO_ITERATIONS) && (loopType == LOOPTYPE_DO_WHILE)) continue; for (int shaderTypeNdx = 0; shaderTypeNdx < DE_LENGTH_OF_ARRAY(s_shaderTypes); shaderTypeNdx++) { ShaderType shaderType = s_shaderTypes[shaderTypeNdx]; const char* shaderTypeName = getShaderTypeName(shaderType); bool isVertexCase = (shaderType == SHADERTYPE_VERTEX); string name = string(loopCaseName) + "_" + shaderTypeName; string desc = string(loopCaseName) + " loop with " + loopTypeName + " iteration count in " + shaderTypeName + " shader."; group->addChild(createSpecialLoopCase(m_context, name.c_str(), desc.c_str(), isVertexCase, (LoopCase)loopCase, (LoopType)loopType, (LoopCountType)loopCountType)); } } } } }