void readMatrix(const std::string& filename, std::vector<T>& A, size_t& m, size_t& n) { std::ifstream f; f.exceptions(std::ofstream::failbit | std::ofstream::badbit); const char* type = getTypeString(A); f.open(filename.c_str(), std::ios::in | std::ios::binary); // header (size and type) f.read(reinterpret_cast<char*>(&m), sizeof(m)); f.read(reinterpret_cast<char*>(&n), sizeof(n)); char type2[17]; f.read(type2, 16); type2[16] = 0; if (std::string(type) != std::string(type2)) { throw std::invalid_argument( "The type of the entries in the file " "differ from the type of the " "entries of A."); } A.empty(); // entries for (size_t i = 0; i < m * n; i++) { T entry; readEntry(f, entry); A.push_back(entry); } }
inline static std::string toJson(const Item& item) { json::JsonObjectStreamWriter writer; const auto type = item.getType(); writer << std::make_pair("type", getTypeString(type)); if (type != Item::INVALID) { writer << std::make_pair("filename", item.filename.c_str()); if (type != Item::SINGLE) writer << std::make_pair("padding", (int) item.padding); switch (type) { case Item::INDICED: { json::JsonArrayStreamWriter indices; for (const auto index : item.indices) indices << index; writer << std::make_pair("indices", indices.build()); break; } case Item::PACKED: writer << std::make_pair("start", item.start); writer << std::make_pair("end", item.end); writer << std::make_pair("step", (int) item.step); break; default: break; } } return writer.build(); }
QString pki_key::getMsg(msg_type msg) { /* * We do not construct english sentences (just a little bit) * from fragments to allow proper translations. * The drawback are all the slightly different duplicated messages * * %1 will be replaced by "RSA", "DSA", "EC" * %2 is the internal name of the key */ QString ktype = getTypeString(); if (isPubKey()) { switch (msg) { case msg_import: return tr("Successfully imported the %1 public key '%2'").arg(ktype); case msg_delete: return tr("Delete the %1 public key '%2'?").arg(ktype); default: break; } } else { switch (msg) { case msg_import: return tr("Successfully imported the %1 private key '%2'").arg(ktype); case msg_delete: return tr("Delete the %1 private key '%2'?").arg(ktype); case msg_create: return tr("Successfully created the %1 private key '%2'").arg(ktype); default: break; } } if (msg == msg_delete_multi) { /* %1: Number of keys; %2: list of keynames */ return tr("Delete the %1 keys: %2?"); } return pki_base::getMsg(msg); }
bool CrossfireBreakpoint::toValueObject(Value** _value) { Value* result = new Value(); result->addObjectValue(KEY_HANDLE, &Value((double)m_handle)); result->addObjectValue(KEY_TYPE, &Value(getTypeString())); if (!m_contextId) { Value value_null; value_null.setType(TYPE_NULL); result->addObjectValue(KEY_CONTEXTID, &value_null); } else { result->addObjectValue(KEY_CONTEXTID, &Value(m_contextId)); } Value value_attributes; value_attributes.setType(TYPE_OBJECT); std::map<std::wstring, Value*>::iterator iterator = m_attributes->begin(); while (iterator != m_attributes->end()) { value_attributes.addObjectValue((std::wstring*)&iterator->first, iterator->second); iterator++; } result->addObjectValue(KEY_ATTRIBUTES, &value_attributes); Value* value_location = NULL; if (!getLocationAsValue(&value_location)) { delete result; return false; } result->addObjectValue(KEY_LOCATION, value_location); delete value_location; *_value = result; return true; }
TString buildArrayConstructorString(const TType& type) { std::stringstream constructor; constructor << getTypeString(translateType(&type)) << '[' << type.getArraySize() << ']'; return TString(constructor.str().c_str()); }
static int l_Message_getType(lua_State *L) { auto message = lua_tomessage(L, 1); enumMessageType messageType = message->getType(); lua_pushstring(L, message->getTypeString().c_str()); return 1; }
bool DumpWrapper<T>::CompareData(void * data, float threshold, OutputFormat output, size_t length , size_t stride ,size_t start) { size_t size = getSize()/sizeof(T); T * ptrA = (T*)getData(); T * ptrB = (T*)data; size_t n = 0; double stddev = 0; size_t cnt = 0; size_t i = start; size_t l = 0; size_t block = 0; if(length > stride) size = ( length+start <= size)?(length+start):(size); while(i < size){ T diff = abs(ptrA[i] - ptrB[i]); double error = abs((double)diff/((ptrA[i] != 0)?(ptrA[i]):(1))); if(error>threshold || error != error ){//&& diff > 0.01 ){ if(output > MIN) cout << i <<" " <<block << " " << l <<" " << ptrA[i] << " " << ptrB[i] << " " << (100.0*error) << "%" << " F" << endl; n++; if(error == error) stddev += diff*diff; }else{ if(output==ALL) cout << i << " " <<block << " " << l <<" " << ptrA[i] << " " << ptrB[i] << " " << (100.0*error) << "%" << endl; stddev += diff*diff; } cnt++; l++; if(length == l){ l = 0; block ++; if(stride > length){ i += stride - length; // cout << endl; } if(stride == length){ // cout << endl; } } i++; } stddev = sqrt(stddev/cnt); cout << "compare " << getName()<< " as " << getTypeString() << " relative error threshold of " << threshold << " failed for "<< n << " out of " << cnt << " ( " << (100.0 *n)/((double)(cnt)) << "% ), standard deviation: "<< stddev << endl; if(n==0){ cout << _name << " correctness check PASSED" << endl; return true; } return false; }
/** * Update the displayed table of column definitions. */ void DBEditor::updateTable() { table->clear(); c4_View temp = info.SortOn(ceNewIndex); int size = temp.GetSize(); QTreeWidgetItem *last = 0; for (int i = 0; i < size; i++) { QString name = QString::fromUtf8(ceName (temp[i])); int type = ceType (temp[i]); QString typeString = getTypeString(type); QString defaultVal = QString::fromUtf8(ceDefault (temp[i])); if (type == NOTE) { defaultVal = defaultVal.replace(QRegExp("\n"), " "); } if (i == 0) { last = new QTreeWidgetItem(table); } else { last = new QTreeWidgetItem(table, last); } last->setText(0, name); last->setText(1, typeString); last->setText(2, defaultVal); if (type == BOOLEAN) { last->setText(2, ""); int checked = defaultVal.toInt(); last->setCheckState(2, checked ? Qt::Checked : Qt::Unchecked); // remove the ability to toggle the checkbox last->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled); } else if (type == NOTE) { last->setIcon(2, QIcon(":/icons/note.png")); } else if (type == DATE) { if (defaultVal == "0") { last->setText(2, ColumnEditor::tr("Today")); } else { last->setText(2, ColumnEditor::tr("None")); } } else if (type == TIME) { if (defaultVal == "0") { last->setText(2, ColumnEditor::tr("Now")); } else { last->setText(2, ColumnEditor::tr("None")); } } } if (size == 0) { stack->setCurrentWidget(noColumns); } else { stack->setCurrentWidget(table); } }
size_t DumpBuffer::PrintHeader() { size_t size = getSize(); cout << _name << "\t " << size << " Bytes of type " << getTypeString() << " (Buffer not tempalted)"<< endl; return size; }
size_t DumpWrapper<T>::PrintHeader() { size_t size = getSize()/sizeof(T); cout << _name << "\t " << size << " elements of type " << getTypeString() << endl; return size; }
void SqlApiBindStmt::dump( FILE *f ) const { size_t i; const HostVarDescription *var; m_stmtHead.dump(f); for(i = 0,var = m_inHost; i < m_stmtHead.m_ninput; i++, var++) { _ftprintf(f,_T("%-20s %4d\n") ,getTypeString(var->getType()) ,var->sqllen ); } for(i = 0, var = m_outHost; i < m_stmtHead.m_noutput; i++, var++) { _ftprintf(f,_T("%-20s %4d\n") ,getTypeString(var->getType()) ,var->sqllen ); } _ftprintf(f, _T("%s\n"), m_stmt); }
String ColumnDefinition::toString() const { String result = format(_T("%-13s %-8s %8s %4d %4d") , m_name.cstr() , getTypeString(getType()) , m_nullAllowed ? _T("NULL") : _T("NOT NULL") , m_offset , m_len ); if(m_defaultValue.length() > 0) { result += _T(" <") + m_defaultValue + _T(">"); } return result; }
bool HlslLinker::emitReturnValue(const EGlslSymbolType retType, GlslFunction* funcMain, EShLanguage lang, std::stringstream& varying, std::stringstream& postamble) { // void return type if (retType == EgstVoid) { if (lang == EShLangFragment) // fragment shader { // If no return type, close off the output postamble << ";\n"; } return true; } // non-struct return type assert (retType != EgstVoid); if (retType != EgstStruct) { std::string name, ctor; int pad; GlslSymbolOrStructMemberBase fakedMainSym("", funcMain->getSemantic(), retType, EqtNone, EbpMedium, 0); if (!getArgumentData2(&fakedMainSym, lang==EShLangVertex ? EClassVarOut : EClassRes, name, ctor, pad, -1)) { assert(0); infoSink.info << (lang==EShLangVertex ? "Unsupported type for shader return value (" : "Unsupported return type for shader entry function ("); infoSink.info << getTypeString(retType) << ")\n"; return true; //@TODO: real error and return false? } postamble << " "; postamble << name << " = "; emitSymbolWithPad (postamble, ctor, "xl_retval", pad); postamble << ";\n"; // In vertex shader, add to varyings if (lang == EShLangVertex) AddToVaryings (varying, lang, m_Target, funcMain->getPrecision(), ctor, name); return true; } // struct return type assert (retType == EgstStruct); GlslStruct *retStruct = funcMain->getStruct(); assert (retStruct); return emitReturnStruct(retStruct, std::string("xl_retval."), lang, varying, postamble); }
/////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////// // // // Returns the record's type (enum) // // /////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////// directoryRecord::tDirectoryRecordType directoryRecord::getType() { std::wstring typeString(getTypeString()); for(size_t scanTypes(0); typesList[scanTypes].m_type != endOfDirectoryRecordTypes; ++scanTypes) { if(typesList[scanTypes].m_name == typeString) { return typesList[scanTypes].m_type; } } // Invalid value found . Throw an exception /////////////////////////////////////////////////////////// throw dicomDirUnknownDirectoryRecordType("Unknown directory record type"); }
void writeMatrix(const std::string& filename, const std::vector<T>& A, size_t m, size_t n) { std::ofstream f; f.exceptions(std::ofstream::failbit | std::ofstream::badbit); const char* type = getTypeString(A); f.open(filename.c_str(), std::ios::out | std::ios::binary); // header (size and type) f.write(reinterpret_cast<const char*>(&m), sizeof(m)); f.write(reinterpret_cast<const char*>(&n), sizeof(n)); f.write(type, 16); // entries for (size_t i = 0; i < m * n; i++) { writeEntry(f, A[i]); } }
std::string GEntity::getInfoString() { std::ostringstream sstream; sstream << getTypeString() << " " << tag(); std::string info = getAdditionalInfoString(); if(info.size()) sstream << " " << info; if(physicals.size()){ sstream << " (Physical:"; for(unsigned int i = 0; i < physicals.size(); i++) sstream << " " << physicals[i]; sstream << ")"; } return sstream.str(); }
void HlslLinker::emitOutputNonStructParam(GlslSymbol* sym, EShLanguage lang, bool usePrecision, EAttribSemantic attrSem, std::stringstream& varying, std::stringstream& preamble, std::stringstream& postamble, std::stringstream& call) { std::string name, ctor; int pad; if (!getArgumentData( sym, lang==EShLangVertex ? EClassVarOut : EClassRes, name, ctor, pad)) { //should deal with fall through cases here assert(0); infoSink.info << "Unsupported type for shader entry parameter ("; infoSink.info << getTypeString(sym->getType()) << ")\n"; return; } // For "inout" parameters, the preamble was already written so no need to do it here. if (sym->getQualifier() != EqtInOut) { preamble << " "; // UNITY CUSTOM: for vprog output with position semantic - force highp TPrecision prec = usePrecision ? sym->getPrecision() : EbpUndefined; if(sym->hasSemantic() && usePrecision) { const char* str = sym->getSemantic().c_str(); int len = sym->getSemantic().length(); extern bool IsPositionSemantics(const char* sem, int len); if(IsPositionSemantics(str, len)) prec = EbpHigh; } writeType (preamble, sym->getType(), NULL,prec); preamble << " xlt_" << sym->getName() << ";\n"; } // In vertex shader, add to varyings if (lang == EShLangVertex) AddVertexOutput (varying, m_Target, sym->getPrecision(), ctor, name); call << "xlt_" << sym->getName(); postamble << " "; postamble << name << " = "; emitSymbolWithPad (postamble, ctor, "xlt_"+sym->getName(), pad); postamble << ";\n"; }
void MaterialObject::build() { check(); if (!debugInactivate_()) { // for (auto& currentSensor : sensorNode_) { // ReferenceSensor temporarySensor; // temporarySensor.store(currentSensor.second); // temporarySensor.check(); // temporarySensor.cleanup(); // std::cout << "[" << currentSensor.first << "]=" << temporarySensor.numChannels() << "; "; // sensorChannels[currentSensor.first] = temporarySensor.numChannels(); // } // std::cout << "}" << std::endl; static std::map<MaterialObjectKey, Materials*> materialsMap_; //for saving memory for (auto& currentMaterialNode : materialsNode_) { store(currentMaterialNode.second); check(); if (type_().compare(getTypeString()) == 0) { MaterialObjectKey myKey(currentMaterialNode.first, sensorChannels, destination_.state()? destination_() : std::string("")); if (materialsMap_.count(myKey) == 0) { Materials * newMaterials = new Materials(materialType_); newMaterials->store(currentMaterialNode.second); //pass destination to newMaterials if(destination_.state()) { PropertyTree destinationPt; destinationPt.add(destination_.name(), destination_()); newMaterials->store(destinationPt); } newMaterials->build(sensorChannels); materialsMap_[myKey] = newMaterials; } materials_ = materialsMap_[myKey]; break; } } } cleanup(); }
UINT ColumnInfo::getMaxStringLen() const { switch(getType()) { case DBTYPE_CSTRING : case DBTYPE_CSTRINGN : return m_len / sizeof(char); case DBTYPE_WSTRING : case DBTYPE_WSTRINGN : return m_len / sizeof(wchar_t); case DBTYPE_VARCHAR : case DBTYPE_VARCHARN : return m_len / sizeof(TCHAR); default : throwSqlError(SQL_FATAL_ERROR,_T("%s:Type not String or varchar (=%s)") ,__TFUNCTION__, getTypeString(getType())); return 0; } }
SIPTransaction::SIPTransaction(SIPTransaction::Ptr pParent) : _type(pParent->getType()), _owner(0), _transportService(0), _state(TRN_STATE_IDLE), _localAddress(), _remoteAddress(), _sendAddress(), _dialogTarget(), _isXOREncrypted(false), _pParent(pParent), _isParent(false) { _id = pParent->getId(); _logId = pParent->getLogId(); std::ostringstream logMsg; logMsg << _logId << getTypeString() << " " << _id << " CREATED"; OSS::log_debug(logMsg.str()); }
void FSFloaterWSAssetBlacklist::addElementToList(const LLUUID& id, const LLSD& data) { LLSD element; element["id"] = id; element["columns"][0]["column"] = "name"; element["columns"][0]["type"] = "text"; element["columns"][0]["value"] = !data["asset_name"].asString().empty() ? data["asset_name"].asString() : getString("unknown_object"); element["columns"][1]["column"] = "region"; element["columns"][1]["type"] = "text"; element["columns"][1]["value"] = !data["asset_region"].asString().empty() ? data["asset_region"].asString() : getString("unknown_region"); element["columns"][2]["column"] = "type"; element["columns"][2]["type"] = "text"; element["columns"][2]["value"] = getTypeString(data["asset_type"].asInteger()); element["columns"][3]["column"] = "date"; element["columns"][3]["type"] = "text"; element["columns"][3]["value"] = data["asset_date"].asString(); mResultList->addElement(element, ADD_BOTTOM); }
void HlslLinker::emitOutputStructParam(GlslSymbol* sym, EShLanguage lang, bool usePrecision, EAttribSemantic attrSem, std::stringstream& varying, std::stringstream& preamble, std::stringstream& postamble, std::stringstream& call) { //structs must pass the struct, then process per element GlslStruct *Struct = sym->getStruct(); assert(Struct); //first create the temp std::string tempVar = "xlt_" + sym->getName(); // For "inout" parmaeters the preamble and call were already written, no need to do it here if ( sym->getQualifier() != EqtInOut ) { preamble << " " << Struct->getName() << " "; preamble << tempVar <<";\n"; call << tempVar; } const int elem = Struct->memberCount(); for (int ii=0; ii<elem; ii++) { const StructMember ¤t = Struct->getMember(ii); std::string name, ctor; int pad; if (!getArgumentData2( ¤t, lang==EShLangVertex ? EClassVarOut : EClassRes, name, ctor, pad, -1)) { //should deal with fall through cases here assert(0); infoSink.info << "Unsupported type in struct element for shader entry parameter ("; infoSink.info << getTypeString(current.type) << ")\n"; continue; } postamble << " "; postamble << name << " = "; emitSymbolWithPad (postamble, ctor, tempVar+"."+current.name, pad); postamble << ";\n"; // In vertex shader, add to varyings if (lang == EShLangVertex) AddVertexOutput (varying, m_Target, current.precision, ctor, name); } }
void Shader::printActiveAttribs() const { GLint numAttribs; glGetProgramInterfaceiv(id_, GL_PROGRAM_INPUT, GL_ACTIVE_RESOURCES, &numAttribs); GLenum properties[] = { GL_NAME_LENGTH, GL_TYPE, GL_LOCATION }; printf("Active attributes:\n"); for (int i = 0; i < numAttribs; ++i) { GLint results[3]; glGetProgramResourceiv(id_, GL_PROGRAM_INPUT, i, 3, properties, 3, NULL, results); GLint nameBufSize = results[0] + 1; char *name = new char[nameBufSize]; glGetProgramResourceName(id_, GL_PROGRAM_INPUT, i, nameBufSize, NULL, name); printf("%-5d %s (%s)\n", results[2], name, getTypeString(results[1])); delete[] name; } }
QVariant pki_key::column_data(dbheader *hd) { QStringList sl; sl << tr("Common") << tr("Private") << tr("Bogus") << tr("PIN"); switch (hd->id) { case HD_key_type: return QVariant(getTypeString()); case HD_key_size: return QVariant(length()); case HD_key_use: return QVariant(getUcount()); case HD_key_passwd: if (isPubKey()) return QVariant(tr("No password")); if (ownPass<0 || ownPass>3) return QVariant("Holla die Waldfee"); return QVariant(sl[ownPass]); } return pki_base::column_data(hd); }
void Shader::printActiveUniformBlocks() const { GLint numBlocks = 0; glGetProgramInterfaceiv(id_, GL_UNIFORM_BLOCK, GL_ACTIVE_RESOURCES, &numBlocks); GLenum blockProps[] = { GL_NUM_ACTIVE_VARIABLES, GL_NAME_LENGTH }; GLenum blockIndex[] = { GL_ACTIVE_VARIABLES }; GLenum props[] = { GL_NAME_LENGTH, GL_TYPE, GL_BLOCK_INDEX }; for (int block = 0; block < numBlocks; ++block) { GLint blockInfo[2]; glGetProgramResourceiv(id_, GL_UNIFORM_BLOCK, block, 2, blockProps, 2, NULL, blockInfo); GLint numUnis = blockInfo[0]; char *blockName = new char[blockInfo[1] + 1]; glGetProgramResourceName(id_, GL_UNIFORM_BLOCK, block, blockInfo[1] + 1, NULL, blockName); printf("Uniform block \"%s\":\n", blockName); delete[] blockName; GLint *unifIndexes = new GLint[numUnis]; glGetProgramResourceiv(id_, GL_UNIFORM_BLOCK, block, 1, blockIndex, numUnis, NULL, unifIndexes); for (int unif = 0; unif < numUnis; ++unif) { GLint uniIndex = unifIndexes[unif]; GLint results[3]; glGetProgramResourceiv(id_, GL_UNIFORM, uniIndex, 3, props, 3, NULL, results); GLint nameBufSize = results[0] + 1; char *name = new char[nameBufSize]; glGetProgramResourceName(id_, GL_UNIFORM, uniIndex, nameBufSize, NULL, name); printf(" %s (%s)\n", name, getTypeString(results[1])); delete[] name; } delete[] unifIndexes; } }
void HlslLinker::emitInputNonStructParam(GlslSymbol* sym, EShLanguage lang, bool usePrecision, EAttribSemantic attrSem, std::stringstream& attrib, std::stringstream& varying, std::stringstream& preamble, std::stringstream& call) { std::string name, ctor; int pad; if (!getArgumentData (sym, lang==EShLangVertex ? EClassAttrib : EClassVarIn, name, ctor, pad)) { // should deal with fall through cases here assert(0); infoSink.info << "Unsupported type for shader entry parameter ("; infoSink.info << getTypeString(sym->getType()) << ")\n"; return; } // In fragment shader, pass zero for POSITION inputs if (lang == EShLangFragment && attrSem == EAttrSemPosition) { call << ctor << "(0.0)"; return; // noting more to do } // For "in" parameters, just call directly to the main else if ( sym->getQualifier() != EqtInOut ) { emitSymbolWithPad (call, ctor, name, pad); } // For "inout" parameters, declare a temp and initialize it else { preamble << " "; writeType (preamble, sym->getType(), NULL, usePrecision?sym->getPrecision():EbpUndefined); preamble << " xlt_" << sym->getName() << " = "; emitSymbolWithPad (preamble, ctor, name, pad); preamble << ";\n"; } if (!sym->outputSuppressedBy()) emitSingleInputVariable (lang, m_Target, name, ctor, sym->getType(), sym->getPrecision(), attrib, varying); }
LPWSTR getTypeUString (WORD id, LPWSTR lpText, DWORD size) { ItemTypesBIN* itemTypeData = D2GetItemTypesBIN(id); if (!itemTypeData) { mbstowcs(lpText, "Bad Type", size); return lpText; } const char* string = getTypeString(itemTypeData->code); if (!string) { struct { DWORD code; BYTE zero; } code; code.code = itemTypeData->code; code.zero = 0; mbstowcs(lpText, (char*)&code, size); } else mbstowcs(lpText, string, size); return lpText; }
void Shader::printActiveUniforms() const { GLint numUniforms = 0; glGetProgramInterfaceiv(id_, GL_UNIFORM, GL_ACTIVE_RESOURCES, &numUniforms); GLenum properties[] = { GL_NAME_LENGTH, GL_TYPE, GL_LOCATION, GL_BLOCK_INDEX }; printf("Active uniforms:\n"); for (int i = 0; i < numUniforms; ++i) { GLint results[4]; glGetProgramResourceiv(id_, GL_UNIFORM, i, 4, properties, 4, NULL, results); if (results[3] != -1) continue; GLint nameBufSize = results[0] + 1; char *name = new char[nameBufSize]; glGetProgramResourceName(id_, GL_UNIFORM, i, nameBufSize, NULL, name); printf("%-5d %s (%s)\n", results[2], name, getTypeString(results[1])); delete[] name; } }
void CGLSLProgram::loadUniformVariables(){ GLenum uniformVariableType; GLint uniformMaxLength, numberOfUniforms, uniformVariableSize; glGetProgramiv(mProgram, GL_ACTIVE_UNIFORMS, &numberOfUniforms); glGetProgramiv(mProgram, GL_ACTIVE_UNIFORM_MAX_LENGTH, &uniformMaxLength); GLchar *uniformName = new GLchar[uniformMaxLength]; printf("\nActive Uniforms\n---------------------------------------------\nID - Name - Type\n\n"); for (int k = 0; k < numberOfUniforms; ++k){ glGetActiveUniform(mProgram, k, uniformMaxLength + 1, NULL, &uniformVariableSize, &uniformVariableType, uniformName); addUniform(uniformName); printf("%d | %s (%s)\n", mUniformsList[uniformName], uniformName, getTypeString(uniformVariableType).c_str()); } printf("\n---------------------------------------------\n"); }
GLuint Shader::load(ShaderType type, const char *path) { GLuint shaderID = glCreateShader(type); std::string vertSourceString = util::readFile(path); const char *source = vertSourceString.c_str(); glShaderSource(shaderID, 1, &source, NULL); glCompileShader(shaderID); GLint result; glGetShaderiv(shaderID, GL_COMPILE_STATUS, &result); if (result == GL_FALSE) { GLint length; glGetShaderiv(shaderID, GL_INFO_LOG_LENGTH, &length); char *error = new char[length]; glGetShaderInfoLog(shaderID, length, &length, error); error[length - 2] = '\0'; //delete double \n at end of report LOG(Error, "GLSL", "Compiling %s as %s Shader: \n\t%s", path, getTypeString(type), error); delete error; glDeleteShader(shaderID); } else { LOG(Success, "Shader", "ID: %d | Path: %s", shaderID, path); glAttachShader(m_ProgramID, shaderID); } return shaderID; }