void makePlots_perf_triggered_ring()
{
gROOT->ProcessLine(" .L style.cc+");
style();
{
TFile* file2 = TFile::Open("histos.root");
TFile* file = TFile::Open("histos.root");
TH1D* a=(TH1D*)file2->Get("data210885/data210885_h_hf_triggered_ring_single");
TH1D* a2=(TH1D*)file2->Get("data210885/data210885_h_hf_triggered_ring_noise_single");
TH1D* b=(TH1D*)file->Get("Hijing/Hijing_h_hf_triggered_ring_single");
TH1D* c=(TH1D*)file->Get("Epos/Epos_h_hf_triggered_ring_single");
//TH1D* c=(TH1D*)file->Get("Epos_SL/Epos_SL_h_hf_triggered_ring_single");
TH1D* d=(TH1D*)file->Get("QGSJetII/QGSJetII_h_hf_triggered_ring_single");
TH1D* e=(TH1D*)file->Get("Starlight_DPMJet/Starlight_DPMJet_h_hf_triggered_ring_single");
TH1D* f=(TH1D*)file->Get("Starlight_Pythia/Starlight_Pythia_h_hf_triggered_ring_single");
ShowStack(a,a2,b,c,d,e,f,"single");
}
{
TFile* file2 = TFile::Open("histos.root");
TFile* file = TFile::Open("histos.root");
TH1D* a=(TH1D*)file2->Get("data210885/data210885_h_hf_triggered_ring_double");
TH1D* a2=(TH1D*)file2->Get("data210885/data210885_h_hf_triggered_ring_noise_double");
TH1D* b=(TH1D*)file->Get("Hijing/Hijing_h_hf_triggered_ring_double");
TH1D* c=(TH1D*)file->Get("Epos/Epos_h_hf_triggered_ring_double");
//TH1D* c=(TH1D*)file->Get("Epos_SL/Epos_SL_h_hf_triggered_ring_double");
TH1D* d=(TH1D*)file->Get("QGSJetII/QGSJetII_h_hf_triggered_ring_double");
TH1D* e=(TH1D*)file->Get("Starlight_DPMJet/Starlight_DPMJet_h_hf_triggered_ring_double");
TH1D* f=(TH1D*)file->Get("Starlight_Pythia/Starlight_Pythia_h_hf_triggered_ring_double");
ShowStack(a,a2,b,c,d,e,f,"double");
}
}
bool YacasPatternPredicateBase::CheckPredicates(LispEnvironment& aEnvironment)
{
const std::size_t n = iPredicates.size();
for (std::size_t i = 0; i < n; ++i)
{
LispPtr pred;
aEnvironment.iEvaluator->Eval(aEnvironment, pred, iPredicates[i]);
if (IsFalse(aEnvironment, pred))
{
return false;
}
// If the result is not False, it should be True, else probably something is wrong (the expression returned unevaluated)
bool isTrue = IsTrue(aEnvironment, pred);
if (!isTrue)
{
#define LIM_AL 60
LispString strout;
aEnvironment.iErrorOutput << "The predicate\n\t";
PrintExpression(strout, iPredicates[i], aEnvironment, LIM_AL);
aEnvironment.iErrorOutput << strout;
aEnvironment.iErrorOutput << "\nevaluated to\n\t";
PrintExpression(strout, pred, aEnvironment, LIM_AL);
aEnvironment.iErrorOutput << strout << '\n';
ShowStack(aEnvironment);
throw LispErrMaxRecurseDepthReached();
}
}
return true;
}
void CheckSecure(LispEnvironment& env, int stack_top)
{
if (env.secure) {
ShowStack(env);
ShowFunctionError(env.iStack[stack_top], env);
throw LispErrSecurityBreach();
}
}
void CheckNrArgs(int n, LispPtr& aArguments,
LispEnvironment& aEnvironment)
{
const int nrArguments = InternalListLength(aArguments);
if (nrArguments == n)
return;
const int needed = n-1;
const int passed = nrArguments-1;
ShowStack(aEnvironment);
ShowFunctionError(aArguments, aEnvironment);
aEnvironment.iErrorOutput << "expected " << needed << " arguments, got " << passed << "\n";
throw LispErrWrongNumberOfArgs();
}
void ShowArgTypeErrorInfo(int aArgNr, LispPtr& aArguments, LispEnvironment& aEnvironment)
{
ShowStack(aEnvironment);
ShowFunctionError(aArguments, aEnvironment);
aEnvironment.iErrorOutput << "bad argument number " << aArgNr << " (counting from 1)\n";
const int LIM_AL = 60;
LispPtr& arg = Argument(aArguments,aArgNr);
LispString strout;
PrintExpression(strout, arg, aEnvironment, LIM_AL);
aEnvironment.iErrorOutput << "The offending argument " << strout;
LispPtr eval;
aEnvironment.iEvaluator->Eval(aEnvironment, eval, arg);
PrintExpression(strout, eval, aEnvironment, LIM_AL);
aEnvironment.iErrorOutput << " evaluated to " << strout << '\n';
}
int main(int argc, char **argv)
{
//printf("nazwa: %s \n",argv[1]);
FILE *file;
file = fopen(argv[1],"rb");
if(file!=NULL) printf("Działa \n");
else fprintf(stderr,"Błąd \n");
char c = fgetc(file);
int i =0;
char * a= malloc(sizeof(char));
while(c!=EOF) {
if(c=='\n' )
{
a[i]='\0';
i =0;
//printf("%s\n",a);
NewElement(a);
free(a);
a= malloc(sizeof(char));
c = fgetc(file);
continue;
}
a[i]=c;
c = fgetc(file);
a = realloc(a,sizeof(char) * (i+2));
i++;
}
free(a);
//printf("Add \n");
//for(i=0;i<=w;i++)pointer =
printf("Show \n");
ShowStack();
printf("Delete stack\n");
DeleteAll();
fclose(file);
return 0;
}
/* Execute - execute the main code */
int Execute(System *sys, ObjHeap *heap, VMHANDLE main)
{
size_t stackSize;
Interpreter *i;
VMVALUE tmp, tmp2, ind;
VMHANDLE obj, htmp;
int8_t tmpb;
/* allocate the interpreter state */
if (!(i = (Interpreter *)AllocateFreeSpace(sys, sizeof(Interpreter))))
return VMFALSE;
/* make sure there is space left for the stack */
if ((stackSize = (sys->freeTop - sys->freeNext) / sizeof(VMVALUE)) <= 0)
return VMFALSE;
/* setup the heap before/after compact functions */
heap->beforeCompact = NULL;
heap->afterCompact = AfterCompact;
heap->compactCookie = i;
/* initialize the interpreter state */
i->sys = sys;
i->heap = heap;
i->stack = (VMVALUE *)((uint8_t *)i + sizeof(Interpreter));
i->stackTop = i->stack + stackSize;
/* setup to execute the main function */
i->code = main;
ObjAddRef(i->code);
i->cbase = i->pc = GetCodePtr(main);
i->sp = i->fp = i->stackTop;
i->hsp = i->hfp = (VMHANDLE *)i->stack - 1;
if (setjmp(i->sys->errorTarget)) {
while (i->hsp > (VMHANDLE *)i->stack)
ObjRelease(i->heap, PopH(i));
ObjRelease(i->heap, i->code);
return VMFALSE;
}
for (;;) {
#if 0
ShowStack(i);
DecodeInstruction(0, 0, i->pc);
#endif
switch (VMCODEBYTE(i->pc++)) {
case OP_HALT:
return VMTRUE;
case OP_BRT:
get_VMVALUE(tmp, VMCODEBYTE(i->pc++));
if (Pop(i))
i->pc += tmp;
break;
case OP_BRTSC:
get_VMVALUE(tmp, VMCODEBYTE(i->pc++));
if (*i->sp)
i->pc += tmp;
else
Drop(i, 1);
break;
case OP_BRF:
get_VMVALUE(tmp, VMCODEBYTE(i->pc++));
if (!Pop(i))
i->pc += tmp;
break;
case OP_BRFSC:
get_VMVALUE(tmp, VMCODEBYTE(i->pc++));
if (!*i->sp)
i->pc += tmp;
else
Drop(i, 1);
break;
case OP_BR:
get_VMVALUE(tmp, VMCODEBYTE(i->pc++));
i->pc += tmp;
break;
case OP_NOT:
*i->sp = (*i->sp ? VMFALSE : VMTRUE);
break;
case OP_NEG:
*i->sp = -*i->sp;
break;
case OP_ADD:
tmp = Pop(i);
*i->sp += tmp;
break;
case OP_SUB:
tmp = Pop(i);
*i->sp -= tmp;
break;
case OP_MUL:
tmp = Pop(i);
*i->sp *= tmp;
break;
case OP_DIV:
tmp = Pop(i);
*i->sp = (tmp == 0 ? 0 : *i->sp / tmp);
break;
case OP_REM:
tmp = Pop(i);
*i->sp = (tmp == 0 ? 0 : *i->sp % tmp);
break;
case OP_CAT:
StringCat(i);
break;
case OP_BNOT:
*i->sp = ~*i->sp;
break;
case OP_BAND:
tmp = Pop(i);
*i->sp &= tmp;
break;
case OP_BOR:
tmp = Pop(i);
*i->sp |= tmp;
break;
case OP_BXOR:
tmp = Pop(i);
*i->sp ^= tmp;
break;
case OP_SHL:
tmp = Pop(i);
*i->sp <<= tmp;
break;
case OP_SHR:
tmp = Pop(i);
*i->sp >>= tmp;
break;
case OP_LT:
tmp = Pop(i);
*i->sp = (*i->sp < tmp ? VMTRUE : VMFALSE);
break;
case OP_LE:
tmp = Pop(i);
*i->sp = (*i->sp <= tmp ? VMTRUE : VMFALSE);
break;
case OP_EQ:
tmp = Pop(i);
*i->sp = (*i->sp == tmp ? VMTRUE : VMFALSE);
break;
case OP_NE:
tmp = Pop(i);
*i->sp = (*i->sp != tmp ? VMTRUE : VMFALSE);
break;
case OP_GE:
tmp = Pop(i);
*i->sp = (*i->sp >= tmp ? VMTRUE : VMFALSE);
break;
case OP_GT:
tmp = Pop(i);
*i->sp = (*i->sp > tmp ? VMTRUE : VMFALSE);
break;
case OP_LIT:
get_VMVALUE(tmp, VMCODEBYTE(i->pc++));
CPush(i, tmp);
break;
case OP_GREF:
get_VMVALUE(tmp, VMCODEBYTE(i->pc++));
obj = (VMHANDLE)tmp;
CPush(i, GetSymbolPtr(obj)->v.iValue);
break;
case OP_GSET:
get_VMVALUE(tmp, VMCODEBYTE(i->pc++));
obj = (VMHANDLE)tmp;
GetSymbolPtr(obj)->v.iValue = Pop(i);
break;
case OP_LREF:
tmpb = (int8_t)VMCODEBYTE(i->pc++);
CPush(i, i->fp[(int)tmpb]);
break;
case OP_LSET:
tmpb = (int8_t)VMCODEBYTE(i->pc++);
i->fp[(int)tmpb] = Pop(i);
break;
case OP_VREF:
ind = *i->sp;
obj = *i->hsp;
if (ind < 0 || ind >= GetHeapObjSize(obj))
Abort(i->sys, str_subscript_err, ind);
*i->sp = GetIntegerVectorBase(obj)[ind];
DropH(i, 1);
break;
case OP_VSET:
tmp2 = Pop(i);
ind = Pop(i);
obj = *i->hsp;
if (ind < 0 || ind >= GetHeapObjSize(obj))
Abort(i->sys, str_subscript_err, ind);
GetIntegerVectorBase(obj)[ind] = tmp2;
DropH(i, 1);
break;
case OP_LITH:
get_VMVALUE(tmp, VMCODEBYTE(i->pc++));
CPushH(i, (VMHANDLE)tmp);
ObjAddRef(*i->hsp);
break;
case OP_GREFH:
get_VMVALUE(tmp, VMCODEBYTE(i->pc++));
CPushH(i, GetSymbolPtr((VMHANDLE)tmp)->v.hValue);
ObjAddRef(*i->hsp);
break;
case OP_GSETH:
get_VMVALUE(tmp, VMCODEBYTE(i->pc++));
ObjRelease(i->heap, GetSymbolPtr((VMHANDLE)tmp)->v.hValue);
GetSymbolPtr((VMHANDLE)tmp)->v.hValue = PopH(i);
break;
case OP_LREFH:
tmpb = (int8_t)VMCODEBYTE(i->pc++);
CPushH(i, i->hfp[(int)tmpb]);
ObjAddRef(*i->hsp);
break;
case OP_LSETH:
tmpb = (int8_t)VMCODEBYTE(i->pc++);
ObjRelease(i->heap, i->hfp[(int)tmpb]);
i->hfp[(int)tmpb] = PopH(i);
break;
case OP_VREFH:
ind = Pop(i);
obj = *i->hsp;
if (ind < 0 || ind >= GetHeapObjSize(obj))
Abort(i->sys, str_subscript_err, ind);
*i->hsp = GetStringVectorBase(obj)[ind];
ObjAddRef(*i->hsp);
break;
case OP_VSETH:
htmp = PopH(i);
ind = Pop(i);
obj = *i->hsp;
if (ind < 0 || ind >= GetHeapObjSize(obj))
Abort(i->sys, str_subscript_err, ind);
ObjRelease(i->heap, GetStringVectorBase(obj)[ind]);
GetStringVectorBase(obj)[ind] = htmp;
DropH(i, 1);
break;
case OP_RESERVE:
tmp = VMCODEBYTE(i->pc++);
tmp2 = VMCODEBYTE(i->pc++);
Reserve(i, tmp);
ReserveH(i, tmp2);
break;
case OP_CALL:
StartCode(i);
break;
case OP_RETURN:
tmp = *i->sp;
PopFrame(i);
Push(i, tmp);
break;
case OP_RETURNH:
htmp = *i->hsp;
PopFrame(i);
PushH(i, htmp);
break;
case OP_RETURNV:
PopFrame(i);
break;
case OP_DROP:
Drop(i, 1);
break;
case OP_DROPH:
ObjRelease(i->heap, *i->hsp);
DropH(i, 1);
break;
default:
Abort(i->sys, str_opcode_err, VMCODEBYTE(i->pc - 1));
break;
}
}
}
