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);
}
