int main() {
int tid;
if ((tid = fork()) == 0)
while(1) {
slow();
lprintf("child: %d", gettid());
}
else
while(1) {
slow();
lprintf("parent: %d\t\tchild:%d", gettid(), tid);
}
}
TreeNode *sortedListToBST(ListNode *head) {
if (NULL == head)
{
return NULL;
}
// special case for a single node
if (NULL == head->next)
{
return new TreeNode(head->val);
}
ListNode *fast(head), *slow(head);
while (slow && fast && fast->next && fast->next->next && fast->next->next->next)
{
fast = fast->next->next;
slow = slow->next;
}
TreeNode *root(new TreeNode(0));
if (slow && slow->next)
{
root->val = slow->next->val;
if (slow->next)
{
root->right = sortedListToBST(slow->next->next);
}
slow->next = NULL;
root->left = sortedListToBST(head);
}
else
{
return NULL;
}
return root;
}
void AstCFunc::dump(ostream& str) {
this->AstNode::dump(str);
if (slow()) str<<" [SLOW]";
if (pure()) str<<" [PURE]";
if (dpiImport()) str<<" [DPII]";
if (dpiExport()) str<<" [DPIX]";
if (dpiExportWrapper()) str<<" [DPIXWR]";
}
int main (int argc, char *argv[])
{
int i;
double x;
for ( i = 0; i < 30000000; i++)
{
x = 100.0;
x = slow(x);
x = slower(x);
x = slowest(x);
}
return 0;
}
ListNode *detectCycle(ListNode *head) {
if(!head) return nullptr;
ListNode *slow(head), *fast(head);
while(fast && fast->next) {
slow = slow->next;
fast = fast->next->next;
if(slow == fast) break;
}
if(!fast || !fast->next) return nullptr;
slow = head;
while(slow != fast) {
slow = slow->next;
fast = fast->next;
}
return slow;
}
//___________________________________________________________________
bool StackedWidgetData::initializeAnimation( void ) {
// check enability
if ( !( target_ && target_.data()->isVisible() ) ) {
return false;
}
// check index
if ( target_.data()->currentIndex() == index_ ) {
return false;
}
// do not animate if either index or currentIndex is not valid
// but update index_ none the less
if ( target_.data()->currentIndex() < 0 || index_ < 0 ) {
index_ = target_.data()->currentIndex();
return false;
}
// get old widget (matching index_) and initialize transition
if ( QWidget* widget = target_.data()->widget( index_ ) ) {
transition().data()->setOpacity( 0 );
startClock();
transition().data()->setGeometry( widget->geometry() );
transition().data()->setStartPixmap( transition().data()->grab( widget ) );
index_ = target_.data()->currentIndex();
return !slow();
}
else {
index_ = target_.data()->currentIndex();
return false;
}
}
bool hasCycle(ListNode *head) {
if (NULL == head)
{
return false;
}
ListNode *slow(head), *fast(head->next);
bool has_cycle = false;
while (NULL != slow && NULL != fast)
{
if (slow == fast)
{
has_cycle = true;
break;
}
slow = slow->next;
fast = fast->next;
if (NULL == fast)
{
break;
}
fast = fast->next;
}
return has_cycle;
}
void AstCFile::dump(ostream& str) {
this->AstNode::dump(str);
if (source()) str<<" [SRC]";
if (slow()) str<<" [SLOW]";
}
double
SECTION
__sin (double x)
{
double xx, res, t, cor, y, s, c, sn, ssn, cs, ccs, xn, a, da, db, eps, xn1,
xn2;
mynumber u, v;
int4 k, m, n;
double retval = 0;
SET_RESTORE_ROUND_53BIT (FE_TONEAREST);
u.x = x;
m = u.i[HIGH_HALF];
k = 0x7fffffff & m; /* no sign */
if (k < 0x3e500000) /* if x->0 =>sin(x)=x */
{
math_check_force_underflow (x);
retval = x;
}
/*---------------------------- 2^-26 < |x|< 0.25 ----------------------*/
else if (k < 0x3fd00000)
{
xx = x * x;
/* Taylor series. */
t = POLYNOMIAL (xx) * (xx * x);
res = x + t;
cor = (x - res) + t;
retval = (res == res + 1.07 * cor) ? res : slow (x);
} /* else if (k < 0x3fd00000) */
/*---------------------------- 0.25<|x|< 0.855469---------------------- */
else if (k < 0x3feb6000)
{
u.x = (m > 0) ? big + x : big - x;
y = (m > 0) ? x - (u.x - big) : x + (u.x - big);
xx = y * y;
s = y + y * xx * (sn3 + xx * sn5);
c = xx * (cs2 + xx * (cs4 + xx * cs6));
SINCOS_TABLE_LOOKUP (u, sn, ssn, cs, ccs);
if (m <= 0)
{
sn = -sn;
ssn = -ssn;
}
cor = (ssn + s * ccs - sn * c) + cs * s;
res = sn + cor;
cor = (sn - res) + cor;
retval = (res == res + 1.096 * cor) ? res : slow1 (x);
} /* else if (k < 0x3feb6000) */
/*----------------------- 0.855469 <|x|<2.426265 ----------------------*/
else if (k < 0x400368fd)
{
y = (m > 0) ? hp0 - x : hp0 + x;
if (y >= 0)
{
u.x = big + y;
y = (y - (u.x - big)) + hp1;
}
else
{
u.x = big - y;
y = (-hp1) - (y + (u.x - big));
}
res = do_cos (u, y, &cor);
retval = (res == res + 1.020 * cor) ? ((m > 0) ? res : -res) : slow2 (x);
} /* else if (k < 0x400368fd) */
/*-------------------------- 2.426265<|x|< 105414350 ----------------------*/
else if (k < 0x419921FB)
{
t = (x * hpinv + toint);
xn = t - toint;
v.x = t;
y = (x - xn * mp1) - xn * mp2;
n = v.i[LOW_HALF] & 3;
da = xn * mp3;
a = y - da;
da = (y - a) - da;
eps = fabs (x) * 1.2e-30;
switch (n)
{ /* quarter of unit circle */
case 0:
case 2:
xx = a * a;
if (n)
{
a = -a;
da = -da;
}
if (xx < 0.01588)
{
/* Taylor series. */
res = TAYLOR_SIN (xx, a, da, cor);
cor = (cor > 0) ? 1.02 * cor + eps : 1.02 * cor - eps;
retval = (res == res + cor) ? res : sloww (a, da, x);
}
else
{
if (a > 0)
m = 1;
else
{
m = 0;
a = -a;
da = -da;
}
u.x = big + a;
y = a - (u.x - big);
res = do_sin (u, y, da, &cor);
cor = (cor > 0) ? 1.035 * cor + eps : 1.035 * cor - eps;
retval = ((res == res + cor) ? ((m) ? res : -res)
: sloww1 (a, da, x, m));
}
break;
case 1:
case 3:
if (a < 0)
{
a = -a;
da = -da;
}
u.x = big + a;
y = a - (u.x - big) + da;
res = do_cos (u, y, &cor);
cor = (cor > 0) ? 1.025 * cor + eps : 1.025 * cor - eps;
retval = ((res == res + cor) ? ((n & 2) ? -res : res)
: sloww2 (a, da, x, n));
break;
}
} /* else if (k < 0x419921FB ) */
/*---------------------105414350 <|x|< 281474976710656 --------------------*/
else if (k < 0x42F00000)
{
t = (x * hpinv + toint);
xn = t - toint;
v.x = t;
xn1 = (xn + 8.0e22) - 8.0e22;
xn2 = xn - xn1;
y = ((((x - xn1 * mp1) - xn1 * mp2) - xn2 * mp1) - xn2 * mp2);
n = v.i[LOW_HALF] & 3;
da = xn1 * pp3;
t = y - da;
da = (y - t) - da;
da = (da - xn2 * pp3) - xn * pp4;
a = t + da;
da = (t - a) + da;
eps = 1.0e-24;
switch (n)
{
case 0:
case 2:
xx = a * a;
if (n)
{
a = -a;
da = -da;
}
if (xx < 0.01588)
{
/* Taylor series. */
res = TAYLOR_SIN (xx, a, da, cor);
cor = (cor > 0) ? 1.02 * cor + eps : 1.02 * cor - eps;
retval = (res == res + cor) ? res : bsloww (a, da, x, n);
}
else
{
double t;
if (a > 0)
{
m = 1;
t = a;
db = da;
}
else
{
m = 0;
t = -a;
db = -da;
}
u.x = big + t;
y = t - (u.x - big);
res = do_sin (u, y, db, &cor);
cor = (cor > 0) ? 1.035 * cor + eps : 1.035 * cor - eps;
retval = ((res == res + cor) ? ((m) ? res : -res)
: bsloww1 (a, da, x, n));
}
break;
case 1:
case 3:
if (a < 0)
{
a = -a;
da = -da;
}
u.x = big + a;
y = a - (u.x - big) + da;
res = do_cos (u, y, &cor);
cor = (cor > 0) ? 1.025 * cor + eps : 1.025 * cor - eps;
retval = ((res == res + cor) ? ((n & 2) ? -res : res)
: bsloww2 (a, da, x, n));
break;
}
} /* else if (k < 0x42F00000 ) */
/* -----------------281474976710656 <|x| <2^1024----------------------------*/
else if (k < 0x7ff00000)
retval = reduce_and_compute (x, 0);
/*--------------------- |x| > 2^1024 ----------------------------------*/
else
{
if (k == 0x7ff00000 && u.i[LOW_HALF] == 0)
__set_errno (EDOM);
retval = x / x;
}
return retval;
}
double __sin(double x){
double xx,res,t,cor,y,s,c,sn,ssn,cs,ccs,xn,a,da,db,eps,xn1,xn2;
#if 0
double w[2];
#endif
mynumber u,v;
int4 k,m,n;
#if 0
int4 nn;
#endif
u.x = x;
m = u.i[HIGH_HALF];
k = 0x7fffffff&m; /* no sign */
if (k < 0x3e500000) /* if x->0 =>sin(x)=x */
return x;
/*---------------------------- 2^-26 < |x|< 0.25 ----------------------*/
else if (k < 0x3fd00000){
xx = x*x;
/*Taylor series */
t = ((((s5.x*xx + s4.x)*xx + s3.x)*xx + s2.x)*xx + s1.x)*(xx*x);
res = x+t;
cor = (x-res)+t;
return (res == res + 1.07*cor)? res : slow(x);
} /* else if (k < 0x3fd00000) */
/*---------------------------- 0.25<|x|< 0.855469---------------------- */
else if (k < 0x3feb6000) {
u.x=(m>0)?big.x+x:big.x-x;
y=(m>0)?x-(u.x-big.x):x+(u.x-big.x);
xx=y*y;
s = y + y*xx*(sn3 +xx*sn5);
c = xx*(cs2 +xx*(cs4 + xx*cs6));
k=u.i[LOW_HALF]<<2;
sn=(m>0)?sincos.x[k]:-sincos.x[k];
ssn=(m>0)?sincos.x[k+1]:-sincos.x[k+1];
cs=sincos.x[k+2];
ccs=sincos.x[k+3];
cor=(ssn+s*ccs-sn*c)+cs*s;
res=sn+cor;
cor=(sn-res)+cor;
return (res==res+1.025*cor)? res : slow1(x);
} /* else if (k < 0x3feb6000) */
/*----------------------- 0.855469 <|x|<2.426265 ----------------------*/
else if (k < 0x400368fd ) {
y = (m>0)? hp0.x-x:hp0.x+x;
if (y>=0) {
u.x = big.x+y;
y = (y-(u.x-big.x))+hp1.x;
}
else {
u.x = big.x-y;
y = (-hp1.x) - (y+(u.x-big.x));
}
xx=y*y;
s = y + y*xx*(sn3 +xx*sn5);
c = xx*(cs2 +xx*(cs4 + xx*cs6));
k=u.i[LOW_HALF]<<2;
sn=sincos.x[k];
ssn=sincos.x[k+1];
cs=sincos.x[k+2];
ccs=sincos.x[k+3];
cor=(ccs-s*ssn-cs*c)-sn*s;
res=cs+cor;
cor=(cs-res)+cor;
return (res==res+1.020*cor)? ((m>0)?res:-res) : slow2(x);
} /* else if (k < 0x400368fd) */
/*-------------------------- 2.426265<|x|< 105414350 ----------------------*/
else if (k < 0x419921FB ) {
t = (x*hpinv.x + toint.x);
xn = t - toint.x;
v.x = t;
y = (x - xn*mp1.x) - xn*mp2.x;
n =v.i[LOW_HALF]&3;
da = xn*mp3.x;
a=y-da;
da = (y-a)-da;
eps = ABS(x)*1.2e-30;
switch (n) { /* quarter of unit circle */
case 0:
case 2:
xx = a*a;
if (n) {a=-a;da=-da;}
if (xx < 0.01588) {
/*Taylor series */
t = (((((s5.x*xx + s4.x)*xx + s3.x)*xx + s2.x)*xx + s1.x)*a - 0.5*da)*xx+da;
res = a+t;
cor = (a-res)+t;
cor = (cor>0)? 1.02*cor+eps : 1.02*cor -eps;
return (res == res + cor)? res : sloww(a,da,x);
}
else {
if (a>0)
{m=1;t=a;db=da;}
else
{m=0;t=-a;db=-da;}
u.x=big.x+t;
y=t-(u.x-big.x);
xx=y*y;
s = y + (db+y*xx*(sn3 +xx*sn5));
c = y*db+xx*(cs2 +xx*(cs4 + xx*cs6));
k=u.i[LOW_HALF]<<2;
sn=sincos.x[k];
ssn=sincos.x[k+1];
cs=sincos.x[k+2];
ccs=sincos.x[k+3];
cor=(ssn+s*ccs-sn*c)+cs*s;
res=sn+cor;
cor=(sn-res)+cor;
cor = (cor>0)? 1.035*cor+eps : 1.035*cor-eps;
return (res==res+cor)? ((m)?res:-res) : sloww1(a,da,x);
}
break;
case 1:
case 3:
if (a<0)
{a=-a;da=-da;}
u.x=big.x+a;
y=a-(u.x-big.x)+da;
xx=y*y;
k=u.i[LOW_HALF]<<2;
sn=sincos.x[k];
ssn=sincos.x[k+1];
cs=sincos.x[k+2];
ccs=sincos.x[k+3];
s = y + y*xx*(sn3 +xx*sn5);
c = xx*(cs2 +xx*(cs4 + xx*cs6));
cor=(ccs-s*ssn-cs*c)-sn*s;
res=cs+cor;
cor=(cs-res)+cor;
cor = (cor>0)? 1.025*cor+eps : 1.025*cor-eps;
return (res==res+cor)? ((n&2)?-res:res) : sloww2(a,da,x,n);
break;
}
} /* else if (k < 0x419921FB ) */
/*---------------------105414350 <|x|< 281474976710656 --------------------*/
else if (k < 0x42F00000 ) {
t = (x*hpinv.x + toint.x);
xn = t - toint.x;
v.x = t;
xn1 = (xn+8.0e22)-8.0e22;
xn2 = xn - xn1;
y = ((((x - xn1*mp1.x) - xn1*mp2.x)-xn2*mp1.x)-xn2*mp2.x);
n =v.i[LOW_HALF]&3;
da = xn1*pp3.x;
t=y-da;
da = (y-t)-da;
da = (da - xn2*pp3.x) -xn*pp4.x;
a = t+da;
da = (t-a)+da;
eps = 1.0e-24;
switch (n) {
case 0:
case 2:
xx = a*a;
if (n) {a=-a;da=-da;}
if (xx < 0.01588) {
/* Taylor series */
t = (((((s5.x*xx + s4.x)*xx + s3.x)*xx + s2.x)*xx + s1.x)*a - 0.5*da)*xx+da;
res = a+t;
cor = (a-res)+t;
cor = (cor>0)? 1.02*cor+eps : 1.02*cor -eps;
return (res == res + cor)? res : bsloww(a,da,x,n);
}
else {
if (a>0) {m=1;t=a;db=da;}
else {m=0;t=-a;db=-da;}
u.x=big.x+t;
y=t-(u.x-big.x);
xx=y*y;
s = y + (db+y*xx*(sn3 +xx*sn5));
c = y*db+xx*(cs2 +xx*(cs4 + xx*cs6));
k=u.i[LOW_HALF]<<2;
sn=sincos.x[k];
ssn=sincos.x[k+1];
cs=sincos.x[k+2];
ccs=sincos.x[k+3];
cor=(ssn+s*ccs-sn*c)+cs*s;
res=sn+cor;
cor=(sn-res)+cor;
cor = (cor>0)? 1.035*cor+eps : 1.035*cor-eps;
return (res==res+cor)? ((m)?res:-res) : bsloww1(a,da,x,n);
}
break;
case 1:
case 3:
if (a<0)
{a=-a;da=-da;}
u.x=big.x+a;
y=a-(u.x-big.x)+da;
xx=y*y;
k=u.i[LOW_HALF]<<2;
sn=sincos.x[k];
ssn=sincos.x[k+1];
cs=sincos.x[k+2];
ccs=sincos.x[k+3];
s = y + y*xx*(sn3 +xx*sn5);
c = xx*(cs2 +xx*(cs4 + xx*cs6));
cor=(ccs-s*ssn-cs*c)-sn*s;
res=cs+cor;
cor=(cs-res)+cor;
cor = (cor>0)? 1.025*cor+eps : 1.025*cor-eps;
return (res==res+cor)? ((n&2)?-res:res) : bsloww2(a,da,x,n);
break;
}
} /* else if (k < 0x42F00000 ) */
/* -----------------281474976710656 <|x| <2^1024----------------------------*/
else if (k < 0x7ff00000) {
n = __branred(x,&a,&da);
switch (n) {
case 0:
if (a*a < 0.01588) return bsloww(a,da,x,n);
else return bsloww1(a,da,x,n);
break;
case 2:
if (a*a < 0.01588) return bsloww(-a,-da,x,n);
else return bsloww1(-a,-da,x,n);
break;
case 1:
case 3:
return bsloww2(a,da,x,n);
break;
}
} /* else if (k < 0x7ff00000 ) */
/*--------------------- |x| > 2^1024 ----------------------------------*/
else return x / x;
return 0; /* unreachable */
}
static void
make_player_info(struct nh_player_info *pi)
{
int cap, advskills, i;
memset(pi, 0, sizeof (struct nh_player_info));
pi->moves = moves;
strncpy(pi->plname, u.uplname, sizeof (pi->plname));
pi->align = u.ualign.type;
/* This function could be called before the game is fully inited. Test
youmonst.data as it is required for near_capacity().
program_state.game_running is no good, as we need this data before
game_running is set.
TODO: Wow this is hacky. */
if (!youmonst.data)
return;
API_ENTRY_CHECKPOINT_RETURN_VOID_ON_ERROR();
pi->x = youmonst.mx;
pi->y = youmonst.my;
pi->z = u.uz.dlevel;
if (Upolyd) {
strncpy(pi->rank, msgtitlecase(mons[u.umonnum].mname),
sizeof (pi->rank));
} else
strncpy(pi->rank, rank(), sizeof (pi->rank));
strncpy(pi->rolename, (u.ufemale && urole.name.f) ?
urole.name.f : urole.name.m, sizeof (pi->rolename));
strncpy(pi->racename, urace.noun, sizeof (pi->racename));
strncpy(pi->gendername, genders[u.ufemale].adj,
sizeof(pi->gendername));
pi->max_rank_sz = mrank_sz;
/* abilities */
pi->st = ACURR(A_STR);
pi->st_extra = 0;
if (pi->st > 118) {
pi->st = pi->st - 100;
pi->st_extra = 0;
} else if (pi->st > 18) {
pi->st_extra = pi->st - 18;
pi->st = 18;
}
pi->dx = ACURR(A_DEX);
pi->co = ACURR(A_CON);
pi->in = ACURR(A_INT);
pi->wi = ACURR(A_WIS);
pi->ch = ACURR(A_CHA);
pi->score = botl_score();
/* hp and energy */
pi->hp = Upolyd ? u.mh : u.uhp;
pi->hpmax = Upolyd ? u.mhmax : u.uhpmax;
if (pi->hp < 0)
pi->hp = 0;
pi->en = u.uen;
pi->enmax = u.uenmax;
pi->ac = find_mac(&youmonst);
pi->gold = money_cnt(invent);
pi->coinsym = def_oc_syms[COIN_CLASS];
describe_level(pi->level_desc);
pi->monnum = u.umonster;
pi->cur_monnum = u.umonnum;
/* level and exp points */
if (Upolyd)
pi->level = mons[u.umonnum].mlevel;
else
pi->level = youmonst.m_lev;
pi->xp = youmonst.exp;
cap = near_capacity();
/* check if any skills could be anhanced */
advskills = 0;
for (i = 0; i < P_NUM_SKILLS; i++) {
if (P_RESTRICTED(i))
continue;
if (can_advance(i, FALSE))
advskills++;
}
pi->can_enhance = advskills > 0;
/* add status items for various problems there can be at most 24 items here
at any one time or we overflow the buffer */
if (hu_stat[u.uhs]) /* 1 */
strncpy(pi->statusitems[pi->nr_items++], hu_stat[u.uhs], ITEMLEN);
if (Confusion) /* 2 */
strncpy(pi->statusitems[pi->nr_items++], "Conf", ITEMLEN);
if (sick(&youmonst)) { /* 3 */
if (u.usick_type & SICK_VOMITABLE)
strncpy(pi->statusitems[pi->nr_items++], "FoodPois", ITEMLEN);
if (u.usick_type & SICK_NONVOMITABLE)
strncpy(pi->statusitems[pi->nr_items++], "Ill", ITEMLEN);
}
if (Blind) /* 4 */
strncpy(pi->statusitems[pi->nr_items++], "Blind", ITEMLEN);
if (slippery_fingers(&youmonst)) /* 5 */
strncpy(pi->statusitems[pi->nr_items++], "Greasy", ITEMLEN);
if (leg_hurt(&youmonst)) /* 6 */
strncpy(pi->statusitems[pi->nr_items++], "Lame", ITEMLEN);
if (stunned(&youmonst)) /* 7 */
strncpy(pi->statusitems[pi->nr_items++], "Stun", ITEMLEN);
if (hallucinating(&youmonst)) /* 8 */
strncpy(pi->statusitems[pi->nr_items++], "Hallu", ITEMLEN);
if (strangled(&youmonst)) /* 9 */
strncpy(pi->statusitems[pi->nr_items++], "Strangle", ITEMLEN);
if (sliming(&youmonst)) /* 10 */
strncpy(pi->statusitems[pi->nr_items++], "Slime", ITEMLEN);
if (petrifying(&youmonst)) /* 11 */
strncpy(pi->statusitems[pi->nr_items++], "Petrify", ITEMLEN);
if (u.ustuck && !Engulfed && !sticks(youmonst.data)) /* 12 */
strncpy(pi->statusitems[pi->nr_items++], "Held", ITEMLEN);
if (enc_stat[cap] ) /* 13 */
strncpy(pi->statusitems[pi->nr_items++], enc_stat[cap], ITEMLEN);
if (cancelled(&youmonst))
strncpy(pi->statusitems[pi->nr_items++], "Cancelled", ITEMLEN);
if (slow(&youmonst))
strncpy(pi->statusitems[pi->nr_items++], "Slow", ITEMLEN);
if (Levitation) /* 14 */
strncpy(pi->statusitems[pi->nr_items++], "Lev", ITEMLEN);
else if (Flying)
strncpy(pi->statusitems[pi->nr_items++], "Fly", ITEMLEN);
if (uwep && is_pick(uwep)) /* 15 (first case) */
strncpy(pi->statusitems[pi->nr_items++], "Dig", ITEMLEN);
else if (uwep && is_launcher(uwep))
strncpy(pi->statusitems[pi->nr_items++], "Ranged", ITEMLEN);
else if (uwep && (uwep->otyp == CORPSE) && (touch_petrifies(&mons[uwep->corpsenm])))
strncpy(pi->statusitems[pi->nr_items++], "cWielded", ITEMLEN);
else if (!uwep)
strncpy(pi->statusitems[pi->nr_items++], "Unarmed", ITEMLEN);
else if (!is_wep(uwep))
strncpy(pi->statusitems[pi->nr_items++], "NonWeap", ITEMLEN);
else {
/* strncpy(pi->statusitems[pi->nr_items++], "Melee", ITEMLEN); */
/* Don't show the default Melee status light, as that's the most common case. */
/* 15 (last case) */
}
if (u.utrap) /* 16 */
strncpy(pi->statusitems[pi->nr_items++], trap_stat[u.utraptype],
ITEMLEN);
API_EXIT();
}
/*
- matcher - the actual matching engine
*/
static int /* 0 success, R_REGEX_NOMATCH failure */
matcher(struct re_guts *g, char *string, size_t nmatch, RRegexMatch pmatch[],
int eflags)
{
char *endp;
int i;
struct match mv;
struct match *m = &mv;
char *dp;
const sopno gf = g->firststate+1; /* +1 for OEND */
const sopno gl = g->laststate;
char *start;
char *stop;
/* simplify the situation where possible */
if (g->cflags&R_REGEX_NOSUB)
nmatch = 0;
if (eflags&R_REGEX_STARTEND) {
start = string + pmatch[0].rm_so;
stop = string + pmatch[0].rm_eo;
} else {
start = string;
stop = start + strlen(start);
}
if (stop < start)
return(R_REGEX_INVARG);
/* prescreening; this does wonders for this rather slow code */
if (g->must != NULL) {
for (dp = start; dp < stop; dp++)
if (*dp == g->must[0] && stop - dp >= g->mlen &&
memcmp(dp, g->must, (size_t)g->mlen) == 0)
break;
if (dp == stop) /* we didn't find g->must */
return(R_REGEX_NOMATCH);
}
/* match struct setup */
m->g = g;
m->eflags = eflags;
m->pmatch = NULL;
m->lastpos = NULL;
m->offp = string;
m->beginp = start;
m->endp = stop;
STATESETUP(m, 4);
SETUP(m->st);
SETUP(m->fresh);
SETUP(m->tmp);
SETUP(m->empty);
CLEAR(m->empty);
/* this loop does only one repetition except for backrefs */
for (;;) {
endp = fast(m, start, stop, gf, gl);
if (endp == NULL) { /* a miss */
free(m->pmatch);
free(m->lastpos);
STATETEARDOWN(m);
return(R_REGEX_NOMATCH);
}
if (nmatch == 0 && !g->backrefs)
break; /* no further info needed */
/* where? */
assert(m->coldp != NULL);
for (;;) {
NOTE("finding start");
endp = slow(m, m->coldp, stop, gf, gl);
if (endp != NULL)
break;
assert(m->coldp < m->endp);
m->coldp++;
}
if (nmatch == 1 && !g->backrefs)
break; /* no further info needed */
/* oh my, he wants the subexpressions... */
if (m->pmatch == NULL)
m->pmatch = (RRegexMatch *)malloc((m->g->nsub + 1) *
sizeof(RRegexMatch));
if (m->pmatch == NULL) {
STATETEARDOWN(m);
return(R_REGEX_ESPACE);
}
for (i = 1; i <= m->g->nsub; i++)
m->pmatch[i].rm_so = m->pmatch[i].rm_eo = -1;
if (!g->backrefs && !(m->eflags&R_REGEX_BACKR)) {
NOTE("dissecting");
dp = dissect(m, m->coldp, endp, gf, gl);
} else {
if (g->nplus > 0 && m->lastpos == NULL)
m->lastpos = (char **)malloc((g->nplus+1) *
sizeof(char *));
if (g->nplus > 0 && m->lastpos == NULL) {
free(m->pmatch);
STATETEARDOWN(m);
return(R_REGEX_ESPACE);
}
NOTE("backref dissect");
dp = backref(m, m->coldp, endp, gf, gl, (sopno)0, 0);
}
if (dp != NULL)
break;
/* uh-oh... we couldn't find a subexpression-level match */
assert(g->backrefs); /* must be back references doing it */
assert(g->nplus == 0 || m->lastpos != NULL);
for (;;) {
if (dp != NULL || endp <= m->coldp)
break; /* defeat */
NOTE("backoff");
endp = slow(m, m->coldp, endp-1, gf, gl);
if (endp == NULL)
break; /* defeat */
/* try it on a shorter possibility */
#ifndef NDEBUG
for (i = 1; i <= m->g->nsub; i++) {
assert(m->pmatch[i].rm_so == -1);
assert(m->pmatch[i].rm_eo == -1);
}
#endif
NOTE("backoff dissect");
dp = backref(m, m->coldp, endp, gf, gl, (sopno)0, 0);
}
assert(dp == NULL || dp == endp);
if (dp != NULL) /* found a shorter one */
break;
/* despite initial appearances, there is no match here */
NOTE("false alarm");
if (m->coldp == stop)
break;
start = m->coldp + 1; /* recycle starting later */
}
/* fill in the details if requested */
if (nmatch > 0) {
pmatch[0].rm_so = m->coldp - m->offp;
pmatch[0].rm_eo = endp - m->offp;
}
if (nmatch > 1) {
assert(m->pmatch != NULL);
for (i = 1; i < nmatch; i++)
if (i <= m->g->nsub)
pmatch[i] = m->pmatch[i];
else {
pmatch[i].rm_so = -1;
pmatch[i].rm_eo = -1;
}
}
if (m->pmatch != NULL)
free((char *)m->pmatch);
if (m->lastpos != NULL)
free((char *)m->lastpos);
STATETEARDOWN(m);
return(0);
}
void Ship::run(float deltaTime)
{
if(Distance(this->loc, Vec2D()) > getGame()->arena->radius && GetTickCount()%100 == 0)
{
Vec2D projection = loc;
projection.scale(1.5f);
getGame()->insertObject(new hostileDrone(getGame()->getNextIndex(), NULL, _hostileDrone, projection, Vec2D(0.0f, 1.0f), this));
}
InputData* id = &getGame()->inputdata;
//special abilitiy timers
if(abilityTimer > 0.0f)
{
abilityTimer -= deltaTime;
if(abilityTimer <= 0.0f && EndSpecialAbility != NULL) //ability just ended its time
EndSpecialAbility(this);
}
else if(abilityCooldownTimer > 0.0f)
abilityCooldownTimer -= deltaTime;
if(hitpoints <= 0)
{
getGame()->debug.AddEvent("Ship died");
die();
//explosion
getGame()->insertObject(new ShipExplosion(getGame()->getNextIndex(), this->loc, (int)this->mesh->radius));
//debris
getGame()->insertObject(new Debris(this, this->owner, this->loc, this->dir, false, true));
}
if(this->owner == getGame()->pc)
{
if(!dead)
{
if(id->up.downState || id->w.downState)
{
if(SpecialAbility == &Cloak && abilityTimer > 0.0f)
thrusting = false;
else
thrusting = true; //for turning on thruster particle effects
thrust(deltaTime);
}
else
{
thrusting = false;
acc.zero(); // resec accel to 0
}
if(id->down.downState || id->s.downState || id->r.downState)
slow(deltaTime);
if(id->left.downState || id->a.downState)
turnLeft(deltaTime);
if(id->right.downState || id->d.downState)
turnRight(deltaTime);
if(id->enter.hitEvent)
{
if(abilityCooldownTimer <= 0.0f && SpecialAbility != NULL)
SpecialAbility(this);
else if(SpecialAbility == NULL)
getGame()->messages.addMessage("No special ability for this ship!");
else
{
if(abilityTimer > 0.0f)
getGame()->messages.addMessage("Special ability is running!");
else
getGame()->messages.addMessage("Special ability is cooling down!");
}
id->enter.ResetEvent();
}
}
}
vel += acc;
if(abilityTimer > 0.0f) //special ability is active
vel.limit(abilityVelLimit);
else
vel.limit(maxSpeed);
//if(this->owner == getGame()->pc)
//{
// if(id->h.downState) //devhax
// {
// vel.zero();
// }
//}
loc += vel * deltaTime;
bb->Update(loc.x - mesh->radius, loc.y + mesh->radius);
if(targetObj)
target = targetObj->loc;
if(this->owner == getGame()->pc)
{
if ((id->space.downState || id->mouse.left.downState) && weapon)
weapon->shoot();
if(id->y.downState)
targetObj = NULL;
if(!targetObj && getGame()->cursortarget)
target = getGame()->cursortarget->loc;
}
}
void easeStop() {
slow();
__delay_cycles(2000000);
stop();
}
/*
- matcher - the actual matching engine
== static int matcher(struct re_guts *g, const char *string, \
== size_t nmatch, regmatch_t pmatch[], int eflags);
*/
static int /* 0 success, REG_NOMATCH failure */
matcher(struct re_guts *g,
const char *string,
size_t nmatch,
regmatch_t pmatch[],
int eflags)
{
const char *endp;
int i;
struct match mv;
struct match *m = &mv;
const char *dp;
const sopno gf = g->firststate+1; /* +1 for OEND */
const sopno gl = g->laststate;
const char *start;
const char *stop;
/* Boyer-Moore algorithms variables */
const char *pp;
int cj, mj;
const char *mustfirst;
const char *mustlast;
int *matchjump;
int *charjump;
/* simplify the situation where possible */
if (g->cflags®_NOSUB)
nmatch = 0;
if (eflags®_STARTEND) {
start = string + pmatch[0].rm_so;
stop = string + pmatch[0].rm_eo;
} else {
start = string;
stop = start + strlen(start);
}
if (stop < start)
return(REG_INVARG);
/* prescreening; this does wonders for this rather slow code */
if (g->must != NULL) {
if (g->charjump != NULL && g->matchjump != NULL) {
mustfirst = g->must;
mustlast = g->must + g->mlen - 1;
charjump = g->charjump;
matchjump = g->matchjump;
pp = mustlast;
for (dp = start+g->mlen-1; dp < stop;) {
/* Fast skip non-matches */
while (dp < stop && charjump[(int)*dp])
dp += charjump[(int)*dp];
if (dp >= stop)
break;
/* Greedy matcher */
/* We depend on not being used for
* for strings of length 1
*/
while (*--dp == *--pp && pp != mustfirst);
if (*dp == *pp)
break;
/* Jump to next possible match */
mj = matchjump[pp - mustfirst];
cj = charjump[(int)*dp];
dp += (cj < mj ? mj : cj);
pp = mustlast;
}
if (pp != mustfirst)
return(REG_NOMATCH);
} else {
for (dp = start; dp < stop; dp++)
if (*dp == g->must[0] &&
stop - dp >= g->mlen &&
memcmp(dp, g->must, (size_t)g->mlen) == 0)
break;
if (dp == stop) /* we didn't find g->must */
return(REG_NOMATCH);
}
}
/* match struct setup */
m->g = g;
m->eflags = eflags;
m->pmatch = NULL;
m->lastpos = NULL;
m->offp = string;
m->beginp = start;
m->endp = stop;
STATESETUP(m, 4);
SETUP(m->st);
SETUP(m->fresh);
SETUP(m->tmp);
SETUP(m->empty);
CLEAR(m->empty);
ZAPSTATE(&m->mbs);
/* Adjust start according to moffset, to speed things up */
if (g->moffset > -1)
start = ((dp - g->moffset) < start) ? start : dp - g->moffset;
/* this loop does only one repetition except for backrefs */
for (;;) {
endp = fast(m, start, stop, gf, gl);
if (endp == NULL) { /* a miss */
if (m->pmatch != NULL)
free((char *)m->pmatch);
if (m->lastpos != NULL)
free((char *)m->lastpos);
STATETEARDOWN(m);
return(REG_NOMATCH);
}
if (nmatch == 0 && !g->backrefs)
break; /* no further info needed */
/* where? */
assert(m->coldp != NULL);
for (;;) {
NOTE("finding start");
endp = slow(m, m->coldp, stop, gf, gl);
if (endp != NULL)
break;
assert(m->coldp < m->endp);
m->coldp += XMBRTOWC(NULL, m->coldp,
m->endp - m->coldp, &m->mbs, 0);
}
if (nmatch == 1 && !g->backrefs)
break; /* no further info needed */
/* oh my, he wants the subexpressions... */
if (m->pmatch == NULL)
m->pmatch = (regmatch_t *)malloc((m->g->nsub + 1) *
sizeof(regmatch_t));
if (m->pmatch == NULL) {
STATETEARDOWN(m);
return(REG_ESPACE);
}
for (i = 1; i <= m->g->nsub; i++)
m->pmatch[i].rm_so = m->pmatch[i].rm_eo = -1;
if (!g->backrefs && !(m->eflags®_BACKR)) {
NOTE("dissecting");
dp = dissect(m, m->coldp, endp, gf, gl);
} else {
if (g->nplus > 0 && m->lastpos == NULL)
m->lastpos = malloc((g->nplus+1) *
sizeof(const char *));
if (g->nplus > 0 && m->lastpos == NULL) {
free(m->pmatch);
STATETEARDOWN(m);
return(REG_ESPACE);
}
NOTE("backref dissect");
dp = backref(m, m->coldp, endp, gf, gl, (sopno)0, 0);
}
if (dp != NULL)
break;
/* uh-oh... we couldn't find a subexpression-level match */
assert(g->backrefs); /* must be back references doing it */
assert(g->nplus == 0 || m->lastpos != NULL);
for (;;) {
if (dp != NULL || endp <= m->coldp)
break; /* defeat */
NOTE("backoff");
endp = slow(m, m->coldp, endp-1, gf, gl);
if (endp == NULL)
break; /* defeat */
/* try it on a shorter possibility */
#ifndef NDEBUG
for (i = 1; i <= m->g->nsub; i++) {
assert(m->pmatch[i].rm_so == -1);
assert(m->pmatch[i].rm_eo == -1);
}
#endif
NOTE("backoff dissect");
dp = backref(m, m->coldp, endp, gf, gl, (sopno)0, 0);
}
assert(dp == NULL || dp == endp);
if (dp != NULL) /* found a shorter one */
break;
/* despite initial appearances, there is no match here */
NOTE("false alarm");
/* recycle starting later */
start = m->coldp + XMBRTOWC(NULL, m->coldp,
stop - m->coldp, &m->mbs, 0);
assert(start <= stop);
}
/* fill in the details if requested */
if (nmatch > 0) {
pmatch[0].rm_so = m->coldp - m->offp;
pmatch[0].rm_eo = endp - m->offp;
}
if (nmatch > 1) {
assert(m->pmatch != NULL);
for (i = 1; i < nmatch; i++)
if (i <= m->g->nsub)
pmatch[i] = m->pmatch[i];
else {
pmatch[i].rm_so = -1;
pmatch[i].rm_eo = -1;
}
}
if (m->pmatch != NULL)
free((char *)m->pmatch);
if (m->lastpos != NULL)
free((char *)m->lastpos);
STATETEARDOWN(m);
return(0);
}
/*
- dissect - figure out what matched what, no back references
== static const char *dissect(struct match *m, const char *start, \
== const char *stop, sopno startst, sopno stopst);
*/
static const char * /* == stop (success) always */
dissect(struct match *m,
const char *start,
const char *stop,
sopno startst,
sopno stopst)
{
int i;
sopno ss; /* start sop of current subRE */
sopno es; /* end sop of current subRE */
const char *sp; /* start of string matched by it */
const char *stp; /* string matched by it cannot pass here */
const char *rest; /* start of rest of string */
const char *tail; /* string unmatched by rest of RE */
sopno ssub; /* start sop of subsubRE */
sopno esub; /* end sop of subsubRE */
const char *ssp; /* start of string matched by subsubRE */
const char *sep; /* end of string matched by subsubRE */
const char *oldssp; /* previous ssp */
const char *dp __unused; /* actually used for assert checks */
AT("diss", start, stop, startst, stopst);
sp = start;
for (ss = startst; ss < stopst; ss = es) {
/* identify end of subRE */
es = ss;
switch (OP(m->g->strip[es])) {
case OPLUS_:
case OQUEST_:
es += OPND(m->g->strip[es]);
break;
case OCH_:
while (OP(m->g->strip[es]) != O_CH)
es += OPND(m->g->strip[es]);
break;
}
es++;
/* figure out what it matched */
switch (OP(m->g->strip[ss])) {
case OEND:
assert(nope);
break;
case OCHAR:
sp += XMBRTOWC(NULL, sp, stop - start, &m->mbs, 0);
break;
case OBOL:
case OEOL:
case OBOW:
case OEOW:
break;
case OANY:
case OANYOF:
sp += XMBRTOWC(NULL, sp, stop - start, &m->mbs, 0);
break;
case OBACK_:
case O_BACK:
assert(nope);
break;
/* cases where length of match is hard to find */
case OQUEST_:
stp = stop;
for (;;) {
/* how long could this one be? */
rest = slow(m, sp, stp, ss, es);
assert(rest != NULL); /* it did match */
/* could the rest match the rest? */
tail = slow(m, rest, stop, es, stopst);
if (tail == stop)
break; /* yes! */
/* no -- try a shorter match for this one */
stp = rest - 1;
assert(stp >= sp); /* it did work */
}
ssub = ss + 1;
esub = es - 1;
/* did innards match? */
if (slow(m, sp, rest, ssub, esub) != NULL) {
dp = dissect(m, sp, rest, ssub, esub);
assert(dp == rest);
} else /* no */
assert(sp == rest);
sp = rest;
break;
case OPLUS_:
stp = stop;
for (;;) {
/* how long could this one be? */
rest = slow(m, sp, stp, ss, es);
assert(rest != NULL); /* it did match */
/* could the rest match the rest? */
tail = slow(m, rest, stop, es, stopst);
if (tail == stop)
break; /* yes! */
/* no -- try a shorter match for this one */
stp = rest - 1;
assert(stp >= sp); /* it did work */
}
ssub = ss + 1;
esub = es - 1;
ssp = sp;
oldssp = ssp;
for (;;) { /* find last match of innards */
sep = slow(m, ssp, rest, ssub, esub);
if (sep == NULL || sep == ssp)
break; /* failed or matched null */
oldssp = ssp; /* on to next try */
ssp = sep;
}
if (sep == NULL) {
/* last successful match */
sep = ssp;
ssp = oldssp;
}
assert(sep == rest); /* must exhaust substring */
assert(slow(m, ssp, sep, ssub, esub) == rest);
dp = dissect(m, ssp, sep, ssub, esub);
assert(dp == sep);
sp = rest;
break;
case OCH_:
stp = stop;
for (;;) {
/* how long could this one be? */
rest = slow(m, sp, stp, ss, es);
assert(rest != NULL); /* it did match */
/* could the rest match the rest? */
tail = slow(m, rest, stop, es, stopst);
if (tail == stop)
break; /* yes! */
/* no -- try a shorter match for this one */
stp = rest - 1;
assert(stp >= sp); /* it did work */
}
ssub = ss + 1;
esub = ss + OPND(m->g->strip[ss]) - 1;
assert(OP(m->g->strip[esub]) == OOR1);
for (;;) { /* find first matching branch */
if (slow(m, sp, rest, ssub, esub) == rest)
break; /* it matched all of it */
/* that one missed, try next one */
assert(OP(m->g->strip[esub]) == OOR1);
esub++;
assert(OP(m->g->strip[esub]) == OOR2);
ssub = esub + 1;
esub += OPND(m->g->strip[esub]);
if (OP(m->g->strip[esub]) == OOR2)
esub--;
else
assert(OP(m->g->strip[esub]) == O_CH);
}
dp = dissect(m, sp, rest, ssub, esub);
assert(dp == rest);
sp = rest;
break;
case O_PLUS:
case O_QUEST:
case OOR1:
case OOR2:
case O_CH:
assert(nope);
break;
case OLPAREN:
i = OPND(m->g->strip[ss]);
assert(0 < i && i <= m->g->nsub);
m->pmatch[i].rm_so = sp - m->offp;
break;
case ORPAREN:
i = OPND(m->g->strip[ss]);
assert(0 < i && i <= m->g->nsub);
m->pmatch[i].rm_eo = sp - m->offp;
break;
default: /* uh oh */
assert(nope);
break;
}
}
assert(sp == stop);
return(sp);
}
void Looper::Loop()
{
unsigned long nEntries = tree_->GetEntries();
//ostringstream os; os<<"Running on "<<nEntries<<" entries" ;
Log(__FUNCTION__,"INFO", Form("Running on %d entries",nEntries) );
sw_. Reset();
try{
for(unsigned long iEntry = 0 ;iEntry< nEntries ;++iEntry)
{
if(iEntry %10000 == 0 ) {
sw_.Stop();
Log(__FUNCTION__,"INFO",Form("Getting Entry %lu / %lu in (Cpu) %.4f (Real) %.4f",iEntry,nEntries, sw_.CpuTime(),sw_.RealTime()) );
//LogErr(__FUNCTION__,"INFO",Form("Getting Entry %lu / %lu in (Cpu) %.4f (Real) %.4f",iEntry,nEntries, sw_.CpuTime(),sw_.RealTime()) );
static int slow_machine=0;
// min entries per second
if (iEntry >30000 and minEntries_>0 and 10000./sw_.RealTime() < minEntries_){
Log(__FUNCTION__,"WARNING",Form("Machine is too slow e/s=%.3f",10000./sw_.RealTime()));
++slow_machine;
if (slow_machine> 3)throw slow();
}
// check that real time is within a ord of magn of cpu time
else if (iEntry >30000 and minEntries_>0 and sw_.RealTime() > 100* sw_.CpuTime()){
Log(__FUNCTION__,"WARNING","Real time too big wrt cpu time. I/O Problems?");
++slow_machine;
if(slow_machine>3)throw slow();
}
else
{
slow_machine=0;
}
sw_ .Reset();
sw_ .Start();
}
#ifdef VERBOSE
if (VERBOSE > 1) cout <<"[Looper]::[Loop] Getting Entry "<<iEntry << " of "<<nEntries<<endl;
#endif
ClearEvent();
// load tree
tree_ -> GetEntry(iEntry);
fEntry=iEntry;
//move content into the event
FillEvent();
// for each smearing
for(auto s : systs_)
{
#ifdef VERBOSE
if (VERBOSE > 1) cout <<"[Looper]::[Loop] Doing syst "<< s -> name() <<endl;
#endif
for(int i=-1; i<=1 ;++i)
{
if ( s->name().find("NONE") != string::npos and i!=0) continue;
if ( s->name().find("NONE") == string::npos and i==0) continue; // for the
#ifdef VERBOSE
if (VERBOSE > 1) cout <<"[Looper]::[Loop] Doing syst "<< s -> name() <<" : (Up,Down)"<<i <<endl;
#endif
//reset
event_->clearSyst();
//
s->SetSyst(i);
//smear
s->smear(event_);
//do the corrections on top
for(auto& c : correctors_)
{
#ifdef VERBOSE
if (VERBOSE > 1) Log(__FUNCTION__,"DEBUG", string("Doing Corrector: ") + c->name());
#endif
s->smear(c);
c->correct(event_);
}
//do the analysis
for(auto a : analysis_)
{
#ifdef VERBOSE
if (VERBOSE > 1) Log(__FUNCTION__,"DEBUG", string("Doing Analysis: ") + a->name());
#endif
//event_->validate(); // validate the objects -- after setting cuts now in doAnalyze
// each analysis step will apply the SF accordingly to the object it is using
event_ -> GetWeight() -> clearSF() ;
event_ -> GetWeight() -> clearPU() ; // for target
if ( a->doAnalyze(event_,s->name()) > 0 ) break; // go on analyzing event, if no analysis returns >0
#ifdef VERBOSE
if (VERBOSE > 1) Log(__FUNCTION__,"DEBUG", string("Done: ") + a->name());
#endif
}
}
// necessary for corrector smearer!
s->SetSyst(0); // not necessary, but cleaner in this way
}
}
}
catch( sigint_exception &e)
{
Log(__FUNCTION__,"SIGNAL"," Caught SIGINT/SIGTERM: exiting! ");
Write();
Close();
dump_->Close();
throw e;
}
//call end procedures for the analyis
for(auto a : analysis_)
a->doEnd();
// save output
dump_->Close();
Write();
Close();
return;
}