void Bank::createFromXml( istringstream& is, ProgramList& list ) { Document doc; try { doc.Parse( is.str(), true ); Node* moduleNode = doc.FirstChild( "Module", false ); if( moduleNode != NULL ) { Program* program = new Program(); createFromXml( is, *program ); list.push_back( program ); } else { Iterator< Element > it( "Program" ); for( it = it.begin( &doc ); it != it.end(); it++ ) { Program* program = new Program(); Element* programElement = it.Get(); readProgram( programElement, program ); list.push_back( program ); } } } catch( const exception& e ) { TRACE( e.what() ); } }
std::unique_ptr<UnitEmitter> compile( const char* filename, const MD5& md5, folly::StringPiece code, AsmCallbacks* callbacks ) { if (RuntimeOption::EvalHackCompilerReset && m_compilations > RuntimeOption::EvalHackCompilerReset) { stop(); } if (!isRunning()) { start(); } std::string prog; std::unique_ptr<Unit> u; try { m_compilations++; writeProgram(filename, md5, code); prog = readProgram(); return assemble_string( prog.data(), prog.length(), filename, md5, false /* swallow errors */, callbacks ); } catch (CompileException& ex) { stop(); if (m_options.verboseErrors) { Logger::FError("ExternCompiler Error: {}", ex.what()); } throw; } catch (std::runtime_error& ex) { if (m_options.verboseErrors) { auto const msg = folly::sformat( "{}\n" "========== PHP Source ==========\n" "{}\n" "========== ExternCompiler Result ==========\n" "{}\n", ex.what(), code, prog); Logger::FError("ExternCompiler Generated a bad unit: {}", msg); // Throw the extended message to ensure the fataling unit contains the // additional context throw std::runtime_error(msg); } throw; } }
int VirtualMachine::LoadProgram(std::vector<char> data) { /*class vectorwrapbuf : public std::basic_streambuf<char, std::char_traits<char> > { public: vectorwrapbuf(std::vector<char> &vec) { setg(vec.data(), vec.data(), vec.data() + vec.size()); } }; vectorwrapbuf databuf(data); std::istream is(&databuf); return readProgram(is);*/ std::stringstream ss(std::string(data.begin(), data.end())); return readProgram((std::istream &)ss); }
void Bank::load( const string& path, bool append ) { if( path.empty() ) return; if( append == false ) { clear(); path_ = path; } try { Document doc = Document( path ); doc.LoadFile(); Element* bankElement = doc.FirstChildElement( "Bank", true ); if( append == false ) { bankElement->GetAttribute( "name", &name_ ); bankElement->GetAttribute( "program", &programNum_ ); } Iterator< Element > it( "Program" ); for( it = it.begin( bankElement ); it != it.end(); it++ ) { Element* programElement = it.Get(); Program* program = new Program(); try { readProgram( programElement, program ); push_back( program ); } catch( const exception& e ) { // parse error, skip program TRACE( e.what() ); } } if( programNum_ >= (INT32)size() ) programNum_ = 0; if( append == false && programNum_ < (INT32)size() ) // create current program currentProgram_ = *at( programNum_ ); } catch( const exception& e ) // file error, use default program { TRACE( e.what() ); newBank( "New Bank.nexus", "New Bank", false ); } }
bool ComputeShaderChunk::readProgram( std::string &szTarget, const Char8 *szFilename) { std::ifstream s(szFilename); if(s.good()) { return readProgram(szTarget, s); } else { FWARNING(("ShaderChunk::readProgram: couldn't open '%s' " "for reading!\n", szFilename)); return false; } }
Program* Bank::generateDefaultProgram( INT32 programNum ) { Program* program = NULL; try { Document doc; doc.Parse( defaultProgramXml_, false ); program = new Program(); readProgram( doc, program ); ostringstream os; os << programNum << " [Default]"; program->name_ = os.str(); } catch( const exception& e ) { TRACE( e.what() ); } return program; }
// load_vertex_program: loading a vertex program void GPUVolRTV0::load_vertex_program(GLuint &v_program, const char *shader_path) { std::ifstream s(shader_path); std::string szTmp; if(readProgram(szTmp, s) == true) { v_program = glCreateShader(GL_CG_VERTEX_SHADER_EXT); const char *source = szTmp.c_str(); glShaderSource(v_program, 1, static_cast<const char **>(&source), 0); glCompileShader(v_program); check_shader_status(v_program); } }
// load_fragment_program: loading a fragment program void GPUVolRTV0::load_fragment_program(GLuint &f_program, const char *shader_path) { std::ifstream s(shader_path); std::string szTmp; if(readProgram(szTmp, s) == true) { f_program = glCreateShader(GL_CG_FRAGMENT_SHADER_EXT); const char *source = szTmp.c_str(); glShaderSource(f_program, 1, static_cast<const char **>(&source), 0); glCompileShader(f_program); check_shader_status(f_program); } }
void Bank::readProgram( const Document& doc, Program* program ) { Element* programElement = doc.FirstChildElement( "Program", true ); readProgram( programElement, program ); }
bool ComputeShaderChunk::readComputeProgram(const Char8 *file) { return readProgram(editSFComputeProgram()->getValue(), file); }
bool ShaderProgram::readProgram(const Char8 *file) { return readProgram(editSFProgram()->getValue(), file); }