void
doprof1(void)
{
#if 0
Sym *s;
int32 n;
Prog *p, *q;
if(debug['v'])
Bprint(&bso, "%5.2f profile 1\n", cputime());
Bflush(&bso);
s = lookup("__mcount", 0);
n = 1;
for(cursym = textp; cursym != nil; cursym = cursym->next) {
p = cursym->text;
q = prg();
q->line = p->line;
q->link = datap;
datap = q;
q->as = ADATA;
q->from.type = D_EXTERN;
q->from.offset = n*4;
q->from.sym = s;
q->from.scale = 4;
q->to = p->from;
q->to.type = D_CONST;
q = prg();
q->line = p->line;
q->pc = p->pc;
q->link = p->link;
p->link = q;
p = q;
p->as = AADDL;
p->from.type = D_CONST;
p->from.offset = 1;
p->to.type = D_EXTERN;
p->to.sym = s;
p->to.offset = n*4 + 4;
n += 2;
}
q = prg();
q->line = 0;
q->link = datap;
datap = q;
q->as = ADATA;
q->from.type = D_EXTERN;
q->from.sym = s;
q->from.scale = 4;
q->to.type = D_CONST;
q->to.offset = n;
s->type = SBSS;
s->size = n*4;
#endif
}
static PyObject* py_glIsProgram(PyObject *, PyObject *args) {
CHECK_ARG_COUNT(args, 1);
Uint prg(PyTuple_GetItem(args, 0));
PyObject *rv = (glIsProgram(prg) == GL_TRUE ? Py_True : Py_False);
Py_INCREF(rv);
return rv;
}
void testSingleFact() {
std::stringstream prg("1 1 0 0 \n0\n1 a\n0\nB+\n0\nB-\n0\n1\n");
CPPUNIT_ASSERT_EQUAL(true, parseLparse(prg, api));
api.endProgram();
CPPUNIT_ASSERT_EQUAL(0u, ctx.numVars());
CPPUNIT_ASSERT_EQUAL('a', ctx.symTab()[1].name[0]);
}
bool SociContainer::begin(void)
{
mRecordCount = 0;
Progress prg("Open database", "Connecting ...");
prg->setMaximum(prg->maximum()+2);
if(!getSession())
{
prg->setValue(prg->value()+2);
ErrorMessage(spt::logging::LoggingItem::LOG_ERROR, MODULENAME, "Unable to open database.");
return false;
}
prg->setValue(prg->value()+1);
if(isReader())
{
if(!prepareStatement(selectorToQuery()))
return false;
}
prg->setValue(prg->value()+1);
if(mSQLToFile)
{
mSQLFile.open(mSQLFilename, std::ios::out | std::ios::trunc);
if(!mSQLFile.is_open())
{
ErrorMessage(spt::logging::LoggingItem::LOG_ERROR, MODULENAME, StdString("Unable to open the file: ")+mSQLFilename);
return false;
}
}
return true;
}
void CMtbRobotDialog::refresh()
{
inRefreshRoutine=true;
// Get handle of last selected object:
int lastSel=simGetObjectLastSelection();
updateObjectsInList();
// Now initialized other dialog elements:
CMtbRobot* taggedObj=NULL;
ui->qqRobotProgram->setPlainText("");
ui->qqAutomatic->setChecked(false);
if (lastSel!=-1)
{
taggedObj=CAccess::mtbRobotContainer->getFromAssociatedObject(lastSel);
if (taggedObj==NULL)
selectObjectInList(-1);
else
{ // The last selected object is the base object of a MTB model!
selectObjectInList(taggedObj->getID());
std::string prg(taggedObj->getProgram());
ui->qqRobotProgram->setPlainText(prg.c_str());
ui->qqAutomatic->setChecked((taggedObj->getOptions()&1)!=0);
}
}
else
selectObjectInList(-1);
ui->qqRobotProgram->setEnabled((taggedObj!=NULL)&&(simGetSimulationState()==sim_simulation_stopped));
ui->qqAutomatic->setEnabled((taggedObj!=NULL)&&(simGetSimulationState()==sim_simulation_stopped));
inRefreshRoutine=false;
}
blargg_err_t Nes_Cart::load_ines( Auto_File_Reader in )
{
RETURN_ERR( in.open() );
ines_header_t h;
RETURN_ERR( in->read( &h, sizeof h ) );
if ( 0 != memcmp( h.signature, "NES\x1A", 4 ) )
return not_ines_file;
if ( h.zero [7] ) // handle header defaced by a f*****g idiot's handle
h.flags2 = 0;
set_mapper( h.flags, h.flags2 );
if ( h.flags & 0x04 ) // skip trainer
RETURN_ERR( in->skip( 512 ) );
RETURN_ERR( resize_prg( h.prg_count * 16 * 1024L ) );
RETURN_ERR( resize_chr( h.chr_count * 8 * 1024L ) );
RETURN_ERR( in->read( prg(), prg_size() ) );
RETURN_ERR( in->read( chr(), chr_size() ) );
return 0;
}
void SociContainer::handleNotification(Dispatcher<SQLPreview::ActionEvent, QVariant, int> *oSource, SQLPreview::ActionEvent nEvent, QVariant oData, int nRows)
{
UNUSED(oSource);
Progress prg("Fetch columns...");
StdString query;
if(nEvent == SQLPreview::ActionEvent::EVENT_SQL_EXECUTE)
{
setTablename("");
query = oData.value<StdString>();
mPreviewLimit = nRows;
setQuery(query);
refreshPreview(query, mPreviewLimit);
}
else if(nEvent == SQLPreview::ActionEvent::EVENT_SQL_TOGGLE)
{
bool enabled = oData.value<bool>();
if(enabled)
{
setTablename("");
mPreviewLimit = mPreviewPanel->getPreviewLimit();
query = mPreviewPanel->getQuery();
setQuery(query);
refreshPreview(query, mPreviewLimit);
}
}
}
static PyObject* py_glGetVertexAttribPointer(PyObject *, PyObject *args) {
CHECK_ARG_COUNT(args, 2);
Uint prg(PyTuple_GetItem(args, 0));
Enum param(PyTuple_GetItem(args, 1));
GLvoid *ptr = 0;
glGetVertexAttribPointerv(prg, param, &ptr);
return PyCObject_FromVoidPtr(ptr, NULL);
}
Prog*
copyp(Prog *q)
{
Prog *p;
p = prg();
*p = *q;
return p;
}
static PyObject* py_glGetProgramInfoLog(PyObject *, PyObject *args) {
CHECK_ARG_COUNT(args, 1);
Uint prg(PyTuple_GetItem(args, 0));
GLint len=0;
glGetProgramiv(prg, GL_INFO_LOG_LENGTH, &len);
//GLchar *log = new GLchar[len+1];
Array1D<Char> log(len+1);
glGetProgramInfoLog(prg, len, NULL, log);
return PyString_FromString(log);
//delete[] log;
}
Prog*
appendp(Prog *q)
{
Prog *p;
p = prg();
p->link = q->link;
q->link = p;
p->line = q->line;
return p;
}
Prog*
byteq(int v)
{
Prog *p;
p = prg();
p->as = ABYTE;
p->from.type = D_CONST;
p->from.offset = v&0xff;
return p;
}
void SociContainer::refreshPreview(StdString const &oQuery, int nLimit)
{
if(!mPreviewPanel)
return;
Progress prg("Updating preview...");
prg->setLabelText("Updating preview...");
std::vector<DatabaseColumn *>columns = getColumns();
bool ex;
std::vector<std::vector<StdString>> rows = fetchRows(columns, oQuery, ex, nLimit);
mPreviewPanel->setPreview(columns, rows);
}
blargg_err_t Nes_Cart::apply_ips_to_prg( Auto_File_Reader patch )
{
RETURN_ERR( patch.open() );
long size = prg_size();
byte* prg_copy = (byte*) malloc( size );
CHECK_ALLOC( prg_copy );
memcpy( prg_copy, prg(), size );
const char* err = apply_ips_patch( *patch, &prg_copy, &size );
if ( !err )
{
resize_prg( size );
memcpy( prg(), prg_copy, size );
}
free( prg_copy );
return err;
}
static PyObject* py_glGetAttachedShaders(PyObject *, PyObject *args) {
CHECK_ARG_COUNT(args, 1);
Uint prg(PyTuple_GetItem(args, 0));
GLint count=0;
glGetProgramiv(prg, GL_ATTACHED_SHADERS, &count);
if (count == 0) {
return PyList_New(0);
} else {
Array1D<Uint> shaders(count);
glGetAttachedShaders(prg, count, NULL, shaders);
return shaders.toPy();
}
}
void
follow(void)
{
if(debug['v'])
Bprint(&bso, "%5.2f follow\n", cputime());
Bflush(&bso);
firstp = prg();
lastp = firstp;
xfol(textp);
lastp->link = P;
firstp = firstp->link;
}
CLWProgram CLWProgram::CreateFromSource(char const* sourcecode, size_t sourcesize, CLWContext context)
{
cl_int status = CL_SUCCESS;
cl_program program = clCreateProgramWithSource(context, 1, (const char**)&sourcecode, &sourcesize, &status);
ThrowIf(status != CL_SUCCESS, status, "clCreateProgramWithSource failed");
std::vector<cl_device_id> deviceIds(context.GetDeviceCount());
for(unsigned int i = 0; i < context.GetDeviceCount(); ++i)
{
deviceIds[i] = context.GetDevice(i);
}
char const* buildopts =
#if defined(__APPLE__)
"-D APPLE -cl-mad-enable -cl-fast-relaxed-math -cl-std=CL1.2 -I ."
#elif defined(_WIN32) || defined (WIN32)
"-D WIN32 -cl-mad-enable -cl-std=CL1.2 -I."
#elif defined(__linux__)
"-D __linux__ -I."
#else
nullptr
#endif
;
status = clBuildProgram(program, context.GetDeviceCount(), &deviceIds[0], buildopts, nullptr, nullptr);
if(status != CL_SUCCESS)
{
std::vector<char> buildLog;
size_t logSize;
clGetProgramBuildInfo(program, deviceIds[0], CL_PROGRAM_BUILD_LOG, 0, nullptr, &logSize);
buildLog.resize(logSize);
clGetProgramBuildInfo(program, deviceIds[0], CL_PROGRAM_BUILD_LOG, logSize, &buildLog[0], nullptr);
#ifdef _DEBUG
std::cout << &buildLog[0] << "\n";
#endif
throw CLWException(status, std::string(&buildLog[0]));
}
CLWProgram prg(program);
clReleaseProgram(program);
return prg;
}
void SociContainer::setSelector(StdString const &oId)
{
Progress prg("Loading from Table ...");
if(oId.length() > 0 && oId[0] == '{') // If it is a table we select it
{
mTablename = oId.substr(1, oId.length()-2);
selectTable(mTablename, false);
}
else
mTablename = "";
super::setSelector(oId);
refreshPreview(selectorToQuery(), mPreviewLimit);
}
void
addnop(Prog *p)
{
Prog *q;
q = prg();
q->as = ANOR;
q->line = p->line;
q->from.type = D_REG;
q->from.reg = REGZERO;
q->to.type = D_REG;
q->to.reg = REGZERO;
q->link = p->link;
p->link = q;
}
void
follow(void)
{
Prog *firstp, *lastp;
if(debug['v'])
Bprint(&bso, "%5.2f follow\n", cputime());
Bflush(&bso);
for(cursym = textp; cursym != nil; cursym = cursym->next) {
firstp = prg();
lastp = firstp;
xfol(cursym->text, &lastp);
lastp->link = nil;
cursym->text = firstp->link;
}
}
bool SociContainer::connect(StdString const &oConnectString)
{
StdString con = getConnectString();
if(oConnectString.length() > 0)
{
if(con != oConnectString)
{
disconnect();
con = oConnectString;
}
}
if(mSession != NULL) // Same connect string and session already exists.
return true;
if(con.length() == 0)
return false;
setConnectString(con);
bool rc = true;
Progress prg("Connecting to database");
prg->setLabelText("Connecting to database ...");
prg->setMaximum(prg->maximum()+1);
QApplication::processEvents();
StdString connectStr = sociConnectString(con);
try
{
mSession = new soci::session(sociFactory(), connectStr);
mSociConnectString = connectStr;
refreshTables();
}
catch(std::runtime_error const &e)
{
mSociConnectString = "";
ErrorMessage(spt::logging::LoggingItem::LOG_ERROR, MODULENAME, e.what());
rc = false;
}
prg->setValue(prg->value()+1);
return rc;
}
/**
* Public function which begins the parsing
*/
void RecursiveDescentParser::start() {
token = scanner->getToken();
prg();
#if DEBUG_PARSER
if(errorCondition) {
std::cout << "Parsing did not complete successfully." << std::endl;
} else {
std::cout << "Parsing completed successfully!" << std::endl;
}
#endif
if( errorCount == 0 ) { // don't attempt to generate target code unless everything went well
codeGenerator->setCharacterConsts( litTab.getCharacterConstants() );
codeGenerator->setNumericalConsts( litTab.getNumericalConstants() );
codeGenerator->generateTargetCode();
}
}
static PyObject* py_glGetActiveUniform(PyObject *, PyObject *args) {
CHECK_ARG_COUNT(args, 2);
Uint prg(PyTuple_GetItem(args, 0));
Uint idx(PyTuple_GetItem(args, 1));
GLint len = 0;
glGetProgramiv(prg, GL_ACTIVE_UNIFORM_MAX_LENGTH, &len);
//GLchar *name = new GLchar[len+1];
Array1D<Char> name(len+1);
GLint size;
GLenum type;
glGetActiveUniform(prg, idx, len, NULL, &size, &type, name);
PyObject *rv = PyTuple_New(3);
PyTuple_SetItem(rv, 0, PyInt_FromLong(size));
PyTuple_SetItem(rv, 1, PyInt_FromLong(type));
PyTuple_SetItem(rv, 2, PyString_FromString(name));
//delete[] name;
return rv;
}
static Prog*
newdata(Sym *s, int o, int w, int t)
{
Prog *p;
p = prg();
p->link = datap;
datap = p;
p->as = ADATA;
p->reg = w;
p->from.type = D_OREG;
p->from.name = t;
p->from.sym = s;
p->from.offset = o;
p->to.type = D_CONST;
p->to.name = D_NONE;
return p;
}
static PyObject* py_glGetShader(PyObject *, PyObject *args) {
CHECK_ARG_COUNT(args, 2);
PyObject *rv = 0;
Uint prg(PyTuple_GetItem(args, 0));
Enum pname(PyTuple_GetItem(args, 1));
GLint dim = PyGL::Instance().getParamDim(PyGL::Shaderiv, pname);
if (dim > 0) {
Array1D<Int> param(dim);
glGetShaderiv(prg, pname, param);
if (dim == 1) {
rv = PyInt_FromLong(param[0]);
} else {
rv = param.toPy();
}
}
if (dim == 0) {
PyErr_SetString(PyExc_RuntimeError, "gl.GetShader: invalid parameter name");
}
return rv;
}
static Prog*
newdata(Sym *s, int o, int w, int t)
{
Prog *p;
p = prg();
if(edatap == P)
datap = p;
else
edatap->link = p;
edatap = p;
p->as = ADATA;
p->width = w;
p->from.scale = w;
p->from.type = t;
p->from.sym = s;
p->from.offset = o;
p->to.type = D_CONST;
return p;
}
Prog*
newtext(Prog *p, Sym *s)
{
if(p == P) {
p = prg();
p->as = ATEXT;
p->from.sym = s;
}
s->type = STEXT;
s->text = p;
s->value = pc;
lastp->link = p;
lastp = p;
p->pc = pc++;
if(textp == P)
textp = p;
else
etextp->pcond = p;
etextp = p;
return p;
}
CLWProgram CLWProgram::CreateFromSource(char const* sourcecode, size_t sourcesize, char const* buildopts, CLWContext context)
{
cl_int status = CL_SUCCESS;
cl_program program = clCreateProgramWithSource(context, 1, (const char**)&sourcecode, &sourcesize, &status);
ThrowIf(status != CL_SUCCESS, status, "clCreateProgramWithSource failed");
std::vector<cl_device_id> deviceIds(context.GetDeviceCount());
for(unsigned int i = 0; i < context.GetDeviceCount(); ++i)
{
deviceIds[i] = context.GetDevice(i);
}
status = clBuildProgram(program, context.GetDeviceCount(), &deviceIds[0], buildopts, nullptr, nullptr);
if(status != CL_SUCCESS)
{
std::vector<char> buildLog;
size_t logSize;
clGetProgramBuildInfo(program, deviceIds[0], CL_PROGRAM_BUILD_LOG, 0, nullptr, &logSize);
buildLog.resize(logSize);
clGetProgramBuildInfo(program, deviceIds[0], CL_PROGRAM_BUILD_LOG, logSize, &buildLog[0], nullptr);
#ifdef _DEBUG
std::cout << &buildLog[0] << "\n";
#endif
throw CLWException(status, std::string(&buildLog[0]));
}
CLWProgram prg(program);
clReleaseProgram(program);
return prg;
}
TGraph2DErrors* GenerateRegionIntegratedSurface(TGraph2DErrors *gr,
const ROOT::Math::IMultiGenFunction& func,
std::vector<Regions>& regions)
{
RegionIntegratorMultiDim Integrator;
Integrator.SetFunction(func);
TGraph2DErrors* mygr = new TGraph2DErrors(gr->GetN());
mygr->SetDirectory(0);
Double_t *fX = gr->GetX();
Double_t *fY = gr->GetY();
Double_t *fZ = gr->GetZ();
Double_t v=0, err=0;
Int_t n = std::count_if(fZ, fZ + gr->GetN(), std::bind2nd(std::greater<Double_t>(),0));
std::cout << n << std::endl;
UInt_t count = 0;
std::cout << "\nGenerating the integrated surface";
std::cout << "\n";
boost::progress_display prg(n);
for (Int_t i=0; i<gr->GetN() && i<regions.size(); i++)
{
if (fZ[i]==0) continue;
regions[i] *= CLHEP::deg;
v = Integrator.RegionIntegral(regions[i]);
mygr->SetPoint(count,fX[i],fY[i],v);
count++;
++prg;
}
std::cout << std::endl;
return mygr;
}
bool CSVContainer::connect(StdString const &oFilename)
{
StdString fn = oFilename;
if(fn.length() == 0)
fn = getConnectString();
if(fn.length() == 0)
return false;
bool rc = super::connect(fn);
if(rc == false)
return false;
Progress prg("Open CSV", "Opening File");
setRownum(0);
CSV &csv = getCSV();
if(fn.length() > 0)
{
CSV::ErrorCode rc;
disconnect();
csv.setFilename(fn);
CSV::Openmode md = getOpenmode();
if((rc = csv.open(md)) != CSV::ErrorCode::CSV_OK)
{
ErrorMessage(spt::logging::LoggingItem::LOG_ERROR, "CSV", "Unable to open "+fn);
csv.setFilename("");
return false;
}
}
else
return false;
csv.rewind();
return true;
}
