// copy
ART_ACTION(action4__copy, ActorInstance_RVC_decoder__texture_V__IAP) {
int32_t ac;
int32_t h;
bool_t top_edge;
int32_t pred;
int32_t v;
int32_t index;
bool_t left_edge;
ART_ACTION_ENTER(action4__copy, 4);
ac = pinRead_int32_t(IN0_PQF_AC);
h = bitand(rshift(thisActor->count, 3), 7);
top_edge = (h == 0);
pred = ac;
v = bitand(thisActor->count, 7);
index = ((top_edge) ? (v):(bitor(h, 8)));
left_edge = (v == 0);
if ((thisActor->acpred_flag && ((thisActor->top && top_edge) || ((!(thisActor->top)) && left_edge)))) {
if ((thisActor->s_prev_quant == thisActor->s_quant)) {
pred = (pred + thisActor->buf[bitor(lshift(thisActor->pred_ptr, 4), index)]);
} else {
pred = (pred + RVC_decoder__texture_V__IAPdivroundnearest(thisActor, (thisActor->buf[bitor(lshift(thisActor->pred_ptr, 4), index)] * thisActor->s_prev_quant), thisActor->s_quant));
}
}
if ((left_edge || top_edge)) {
thisActor->buf[bitor(lshift(thisActor->ptr, 4), index)] = pred;
}
thisActor->count = (thisActor->count + 1);
pinWrite_int32_t(OUT0_QF_AC, pred);
ART_ACTION_EXIT(action4__copy, 4);
}
vector<long long> BigNum::kmul(vector<long long>& numbers, IPos begin, IPos end, vector<long long>& o_numbers, IPos o_begin, IPos o_end, long long base)
{
if ( (end - begin) <= 1 && (o_end - o_begin) <= 1 )
{
vector<long long> res_numbers;
long long m1 = (end - begin) == 1 ? (*begin) : 0;
long long m2 = (o_end - o_begin) == 1 ? (*o_begin) : 0;
res_numbers.push_back(m1 * m2);
long long div = res_numbers[0] / base;
long i = 0;
while ( div != 0 )
{
res_numbers[i] %= base;
res_numbers.push_back(div);
++i;
div = res_numbers[i] / base;
}
return res_numbers;
}
long size = max(end - begin, o_end - o_begin);
long count = size / 2;
if ( size % 2 == 1 )
count++;
IPos middle, o_middle;
split_number(begin, end, numbers, &middle, count);
split_number(o_begin, o_end, o_numbers, &o_middle, count);
vector<long long> u1mv1 = kmul(numbers, middle, end, o_numbers, o_middle, o_end, base);
vector<long long> u0mv0 = kmul(numbers, begin, middle, o_numbers, o_begin, o_middle, base);
vector<long long> u1au0 = add(numbers, middle, end, numbers, begin, middle, base);
trim_num_zeroes(u1au0);
vector<long long> v1av0 = add(o_numbers, o_middle, o_end, o_numbers, o_begin, o_middle, base);
trim_num_zeroes(v1av0);
vector<long long> umv = full_kmul(u1au0, v1av0, base);
vector<long long> sum2 = full_sub(umv, u0mv0, base);
sum2 = full_sub(sum2, u1mv1, base);
lshift(&u1mv1, count * 2);
lshift(&sum2, count);
vector<long long> res = full_add(u1mv1, sum2, base);
res = full_add(res, u0mv0, base);
trim_num_zeroes(res);
return res;
}
value_t Bignum::rshift(Bignum *obj, intptr_t shift)
{
if(shift < 0)
return lshift(obj, -shift);
return obj->number.rshift(shift).to_value();
}
void iwt_ref(SchroFrameData *p, int filter)
{
int16_t tmp1[100], *hi;
int16_t tmp2[100], *lo;
int16_t tmp3[100], *tmpbuf;
int16_t *data;
int i;
hi = tmp1 + 4;
lo = tmp2 + 4;
tmpbuf = tmp3 + 8;
lshift(p, filtershift[filter]);
for(i=0;i<p->height;i++){
data = OFFSET(p->data,i*p->stride);
copy(tmpbuf, sizeof(int16_t), data, sizeof(int16_t), p->width);
split (tmpbuf, p->width, filter);
orc_deinterleave2_s16 (lo, hi, tmpbuf, p->width/2);
copy(data, sizeof(int16_t), lo, sizeof(int16_t), p->width/2);
copy(data + p->width/2, sizeof(int16_t), hi, sizeof(int16_t), p->width/2);
}
for(i=0;i<p->width;i++){
data = OFFSET(p->data,i*sizeof(int16_t));
copy(tmpbuf, sizeof(int16_t), data, p->stride, p->height);
split (tmpbuf, p->height, filter);
copy(data, p->stride, tmpbuf, sizeof(int16_t), p->height);
}
}
/*ARGSUSED*/
void
douniverse(Char **v, struct command *c)
{
Char *cp = v[1];
Char *cp2; /* dunno how many elements v comes in with */
char ubuf[100];
if (cp == 0) {
(void) getuniverse(ubuf);
xprintf("%s\n", ubuf);
}
else {
cp2 = v[2];
if (cp2 == 0) {
if (*cp == '\0' || setuniverse(short2str(cp)) != 0)
stderror(ERR_NAME | ERR_STRING, CGETS(23, 12, "Illegal universe"));
}
else {
(void) getuniverse(ubuf);
if (*cp == '\0' || setuniverse(short2str(cp)) != 0)
stderror(ERR_NAME | ERR_STRING, CGETS(23, 12, "Illegal universe"));
cleanup_push(ubuf, setuniverse_cleanup);
if (setintr) {
pintr_disabled++;
cleanup_push(&pintr_disabled, disabled_cleanup);
}
lshift(v, 2);
if (setintr)
cleanup_until(&pintr_disabled);
reexecute(c);
cleanup_until(ubuf);
}
}
}
static mrb_value
fix_rshift(mrb_state *mrb, mrb_value x)
{
mrb_int width;
mrb_value result;
fix_shift_get_width(mrb, &width);
if (width == 0) {
result = x;
}
else {
mrb_int val;
val = mrb_fixnum(x);
if (width < 0) {
result = lshift(mrb, val, -width);
}
else {
result = rshift(val, width);
}
}
return result;
}
// read_mv
ART_ACTION(action4__read_mv, ActorInstance_RVC_decoder__motion_V__framebuf) {
int32_t x;
int32_t y;
int32_t flag_x;
int32_t flags;
int32_t flag_y;
ART_ACTION_ENTER(action4__read_mv, 4);
x = pinRead_int32_t(IN0_MV);
y = pinRead_int32_t(IN0_MV);
flag_x = (((bitand(x, 1) == 1)) ? (4):(0));
flags = ((lshift(bitand(x, 1), 2) + lshift(bitand(y, 1), 1)) + thisActor->vop_rounding_mode);
flag_y = (((bitand(y, 1) == 1)) ? (2):(0));
thisActor->mvx = rshift(x, 1);
thisActor->mvy = rshift(y, 1);
pinWrite_int32_t(OUT0_halfpel, flags);
ART_ACTION_EXIT(action4__read_mv, 4);
}
// getdc.inter
ART_ACTION(action6__getdc__inter, ActorInstance_RVC_decoder__texture_V__DCRecontruction__invpred) {
int32_t dc;
int32_t v;
ART_ACTION_ENTER(action6__getdc__inter, 6);
dc = pinRead_int32_t(IN4_QFS_DC);
v = ((thisActor->s_qp * (lshift(RVC_decoder__texture_V__DCRecontruction__invpredabs(thisActor, dc), 1) + 1)) - thisActor->round);
thisActor->dc_val = (((dc == 0)) ? (0):((((!(thisActor->is_signed))) ? (dc):((((dc < 0)) ? ((-(v))):(v))))));
ART_ACTION_EXIT(action6__getdc__inter, 6);
}
void
ocb::setkey (const void *key, u_int keylen)
{
k.setkey (key, keylen);
blkclear (&l[0]);
k.encipher_bytes (l[0].c);
rshift (&l[-1], l[0]);
for (u_int i = 0; i < l_size; i++)
lshift (&l[i+1], l[i]);
}
const char* StringStore::GetStringForID (ID id)
{
uint32 crc, binAndID;
UI64Split (id, crc, binAndID);
const uint binNumberMask = (1 << storageBinBits) - 1;
uint bin = rshift (binAndID, (32 - storageBinBits)) & (binNumberMask);
BinID binId = binAndID & (lshift (1, (32 - storageBinBits))-1);
return bins[bin].GetStringForID (currentCacheTime, binId, crc);
}
StringStore::ID StringStore::GetIDForString (const char* str)
{
HashedStr hashStr (str);
const uint binNumberMask = (1 << storageBinBits) - 1;
uint bin = hashStr.hash & binNumberMask;
BinID binID;
uint32 crc;
flushNeeded |= bins[bin].GetIDForString (hashStr, currentCacheTime, binID, crc);
uint32 binAndID = binID | lshift (bin, (32 - storageBinBits));
return UI64Merge (crc, binAndID);
}
void emit(int tt, unsigned int tval)
{
if(tt == UNKNOWN)
error("Unknown token");
else if(tt == DONE)
error("Unexpected end of expression");
else if(tt == NONE)
error("No token in expression");
else if(tt == EOS)
error("End of string in expression");
else if(tt == NUM)
push(tt, tval);
else if(tt == STRING) {
if(tval <= 0)
error("Unrecognized expression");
else
push(tt, tval);
}
else {
/* apply operator */
switch(tt) {
case 1: l_orr(); break;
case 2: l_and(); break;
case 3: b_orr(); break;
case 4: b_xor(); break;
case 5: b_and(); break;
case 6: l_equ(); break;
case 7: l_neq(); break;
case 8: l_leq(); break;
case 9: l_geq(); break;
case 10: l_ltt(); break;
case 11: l_gtt(); break;
case 12: lshift(); break;
case 13: l_rshift(); break;
case 14: rshift(); break;
case 15: plus(); break;
case 16: minus(); break;
case 17: multiply(); break;
case 18: divide(); break;
case 19: modulo(); break;
case 20: l_not(); break;
case 21: b_not(); break;
case 22: unaryminus(); break;
case 23: unaryplus(); break;
default:
error("Unknown operator");
}
}
}
/*ARGSUSED*/
void
execash(tchar **t, struct command *kp)
{
#ifdef TRACE
tprintf("TRACE- execash()\n");
#endif
rechist();
(void) signal(SIGINT, parintr);
(void) signal(SIGQUIT, parintr);
(void) signal(SIGTERM, parterm); /* if doexec loses, screw */
lshift(kp->t_dcom, 1);
exiterr++;
doexec(kp);
/*NOTREACHED*/
}
static mrb_value
fix_lshift(mrb_state *mrb, mrb_value x)
{
mrb_int width, val;
fix_shift_get_width(mrb, &width);
if (width == 0) {
return x;
}
val = mrb_fixnum(x);
if (width < 0) {
return rshift(val, -width);
}
return lshift(mrb, val, width);
}
/* result = a * b */
static void mult(BigNum a, BigNum b, BigNum result)
{
int i;
BigNum temp1;
clear(result);
for (i = 0; i < MAX_DIGIT; i++) {
if (b[i] != 0) {
copy(temp1, a);
lshift(temp1, i);
mult_digit(temp1, b[i], temp1);
add(temp1, result, result);
}
}
}
void decrypt_bit()
{
int i,j,x,x1,k,temp=0,s1,c,num[8],p2,sum;
for(c=times-1;c>=0;c--)
{
bit_wise_xor();
lshift(c);
}
s1=255;
for(i=siz-1;i>=0;i--)
{
for(j=siz-1;j>=0;j--)
{
x=(int)mat[i][j];
temp=data[s1];
data[s1]=data[x];
data[x]=temp;
s1=s1-1;
x=0;
}
}
for(i=0;i<256;i=i+8)
{
j=0;
k=0;
num[j]=data[i];
num[j+1]=data[i+1];
num[j+2]=data[i+2];
num[j+3]=data[i+3];
num[j+4]=data[i+4];
num[j+5]=data[i+5];
num[j+6]=data[i+6];
num[j+7]=data[i+7];
sum=0;
p2=1;
for(k=7;k>=0;k--)
{
if(num[k]!=0)
sum=sum+p2;
p2=p2*2;
}
/*printf("%c",sum);*/
fprintf(fp2,"%c",sum);
}
}
void
/*ARGSUSED*/
shift(Char **v, struct command *t)
{
struct varent *argv;
Char *name;
v++;
name = *v;
if (name == 0)
name = STRargv;
else
(void) strip(name);
argv = adrof(name);
if (argv == 0)
udvar(name);
if (argv->vec[0] == 0)
stderror(ERR_NAME | ERR_NOMORE);
lshift(argv->vec, 1);
}
/*ARGSUSED*/
void
shift(Char **v, struct command *c)
{
struct varent *argv;
Char *name;
USE(c);
v++;
name = *v;
if (name == 0)
name = STRargv;
else
(void) strip(name);
argv = adrof(name);
if (argv == NULL || argv->vec == NULL)
udvar(name);
if (argv->vec[0] == 0)
stderror(ERR_NAME | ERR_NOMORE);
lshift(argv->vec, 1);
update_vars(name);
}
/*ARGSUSED*/
void
doucb(Char **v, struct command *c)
{
Char *cp = v[1];
char ubuf[100];
if (cp == 0)
(void) setuniverse("ucb");
else {
(void) getuniverse(ubuf);
(void) setuniverse("ucb");
cleanup_push(ubuf, setuniverse_cleanup);
if (setintr) {
pintr_disabled++;
cleanup_push(&pintr_disabled, disabled_cleanup);
}
lshift(v, 1);
if (setintr)
cleanup_until(&pintr_disabled);
reexecute(c);
cleanup_until(ubuf);
}
}
/*ARGSUSED*/
void
execash(Char **t, struct command *kp)
{
jmp_buf osetexit;
sig_t osigint, osigquit, osigterm;
int my_reenter, odidfds, oOLDSTD, oSHERR, oSHIN, oSHOUT;
int saveDIAG, saveIN, saveOUT, saveSTD;
if (chkstop == 0 && setintr)
panystop(0);
/*
* Hmm, we don't really want to do that now because we might
* fail, but what is the choice
*/
rechist();
osigint = signal(SIGINT, parintr);
osigquit = signal(SIGQUIT, parintr);
osigterm = signal(SIGTERM, parterm);
odidfds = didfds;
oSHIN = SHIN;
oSHOUT = SHOUT;
oSHERR = SHERR;
oOLDSTD = OLDSTD;
saveIN = dcopy(SHIN, -1);
saveOUT = dcopy(SHOUT, -1);
saveDIAG = dcopy(SHERR, -1);
saveSTD = dcopy(OLDSTD, -1);
lshift(kp->t_dcom, 1);
getexit(osetexit);
if ((my_reenter = setexit()) == 0) {
SHIN = dcopy(0, -1);
SHOUT = dcopy(1, -1);
SHERR = dcopy(2, -1);
didfds = 0;
doexec(t, kp);
}
(void)signal(SIGINT, osigint);
(void)signal(SIGQUIT, osigquit);
(void)signal(SIGTERM, osigterm);
doneinp = 0;
didfds = odidfds;
(void)close(SHIN);
(void)close(SHOUT);
(void)close(SHERR);
(void)close(OLDSTD);
SHIN = dmove(saveIN, oSHIN);
SHOUT = dmove(saveOUT, oSHOUT);
SHERR = dmove(saveDIAG, oSHERR);
OLDSTD = dmove(saveSTD, oOLDSTD);
resexit(osetexit);
if (my_reenter)
stderror(ERR_SILENT);
}
void
execute(struct command *t, int wtty, int *pipein, int *pipeout)
{
static sigset_t csigset, ocsigset;
static int nosigchld = 0, onosigchld = 0;
volatile int wanttty = wtty;
struct biltins * volatile bifunc;
int pv[2], pid;
sigset_t nsigset;
int forked;
UNREGISTER(forked);
UNREGISTER(bifunc);
UNREGISTER(wanttty);
forked = 0;
pid = 0;
if (t == 0)
return;
if (t->t_dflg & F_AMPERSAND)
wanttty = 0;
switch (t->t_dtyp) {
case NODE_COMMAND:
if ((t->t_dcom[0][0] & (QUOTE | TRIM)) == QUOTE)
(void)Strcpy(t->t_dcom[0], t->t_dcom[0] + 1);
if ((t->t_dflg & F_REPEAT) == 0)
Dfix(t); /* $ " ' \ */
if (t->t_dcom[0] == 0)
return;
/* FALLTHROUGH */
case NODE_PAREN:
if (t->t_dflg & F_PIPEOUT)
mypipe(pipeout);
/*
* Must do << early so parent will know where input pointer should be.
* If noexec then this is all we do.
*/
if (t->t_dflg & F_READ) {
(void)close(0);
heredoc(t->t_dlef);
if (noexec)
(void)close(0);
}
set(STRstatus, Strsave(STR0));
/*
* This mess is the necessary kludge to handle the prefix builtins:
* nice, nohup, time. These commands can also be used by themselves,
* and this is not handled here. This will also work when loops are
* parsed.
*/
while (t->t_dtyp == NODE_COMMAND)
if (eq(t->t_dcom[0], STRnice)) {
if (t->t_dcom[1]) {
if (strchr("+-", t->t_dcom[1][0])) {
if (t->t_dcom[2]) {
setname("nice");
t->t_nice =
getn(t->t_dcom[1]);
lshift(t->t_dcom, 2);
t->t_dflg |= F_NICE;
}
else
break;
} else {
t->t_nice = 4;
lshift(t->t_dcom, 1);
t->t_dflg |= F_NICE;
}
} else
break;
} else if (eq(t->t_dcom[0], STRnohup)) {
if (t->t_dcom[1]) {
t->t_dflg |= F_NOHUP;
lshift(t->t_dcom, 1);
}
else
break;
} else if (eq(t->t_dcom[0], STRtime)) {
if (t->t_dcom[1]) {
t->t_dflg |= F_TIME;
lshift(t->t_dcom, 1);
}
else
break;
} else
break;
/* is it a command */
if (t->t_dtyp == NODE_COMMAND) {
/*
* Check if we have a builtin function and remember which one.
*/
bifunc = isbfunc(t);
if (noexec && bifunc != NULL) {
/*
* Continue for builtins that are part of the scripting language
*/
if (bifunc->bfunct != dobreak && bifunc->bfunct != docontin &&
bifunc->bfunct != doelse && bifunc->bfunct != doend &&
bifunc->bfunct != doforeach && bifunc->bfunct != dogoto &&
bifunc->bfunct != doif && bifunc->bfunct != dorepeat &&
bifunc->bfunct != doswbrk && bifunc->bfunct != doswitch &&
bifunc->bfunct != dowhile && bifunc->bfunct != dozip)
break;
}
}
else { /* not a command */
bifunc = NULL;
if (noexec)
break;
}
/*
* We fork only if we are timed, or are not the end of a parenthesized
* list and not a simple builtin function. Simple meaning one that is
* not pipedout, niced, nohupped, or &'d. It would be nice(?) to not
* fork in some of these cases.
*/
/*
* Prevent forking cd, pushd, popd, chdir cause this will cause the
* shell not to change dir!
*/
if (bifunc && (bifunc->bfunct == dochngd ||
bifunc->bfunct == dopushd ||
bifunc->bfunct == dopopd))
t->t_dflg &= ~(F_NICE);
if (((t->t_dflg & F_TIME) || ((t->t_dflg & F_NOFORK) == 0 &&
(!bifunc || t->t_dflg &
(F_PIPEOUT | F_AMPERSAND | F_NICE | F_NOHUP)))) ||
/*
* We have to fork for eval too.
*/
(bifunc && (t->t_dflg & (F_PIPEIN | F_PIPEOUT)) != 0 &&
bifunc->bfunct == doeval)) {
if (t->t_dtyp == NODE_PAREN ||
t->t_dflg & (F_REPEAT | F_AMPERSAND) || bifunc) {
forked++;
/*
* We need to block SIGCHLD here, so that if the process does
* not die before we can set the process group
*/
if (wanttty >= 0 && !nosigchld) {
sigemptyset(&nsigset);
(void)sigaddset(&nsigset, SIGCHLD);
(void)sigprocmask(SIG_BLOCK, &nsigset, &csigset);
nosigchld = 1;
}
pid = pfork(t, wanttty);
if (pid == 0 && nosigchld) {
(void)sigprocmask(SIG_SETMASK, &csigset, NULL);
nosigchld = 0;
}
else if (pid != 0 && (t->t_dflg & F_AMPERSAND))
backpid = pid;
}
else {
int ochild, osetintr, ohaderr, odidfds;
int oSHIN, oSHOUT, oSHERR, oOLDSTD, otpgrp;
sigset_t osigset;
/*
* Prepare for the vfork by saving everything that the child
* corrupts before it exec's. Note that in some signal
* implementations which keep the signal info in user space
* (e.g. Sun's) it will also be necessary to save and restore
* the current sigaction's for the signals the child touches
* before it exec's.
*/
if (wanttty >= 0 && !nosigchld && !noexec) {
sigemptyset(&nsigset);
(void)sigaddset(&nsigset, SIGCHLD);
(void)sigprocmask(SIG_BLOCK, &nsigset, &csigset);
nosigchld = 1;
}
sigemptyset(&nsigset);
(void)sigaddset(&nsigset, SIGCHLD);
(void)sigaddset(&nsigset, SIGINT);
(void)sigprocmask(SIG_BLOCK, &nsigset, &osigset);
ochild = child;
osetintr = setintr;
ohaderr = haderr;
odidfds = didfds;
oSHIN = SHIN;
oSHOUT = SHOUT;
oSHERR = SHERR;
oOLDSTD = OLDSTD;
otpgrp = tpgrp;
ocsigset = csigset;
onosigchld = nosigchld;
Vsav = Vdp = 0;
Vexpath = 0;
Vt = 0;
pid = vfork();
if (pid < 0) {
(void)sigprocmask(SIG_SETMASK, &osigset, NULL);
stderror(ERR_NOPROC);
}
forked++;
if (pid) { /* parent */
child = ochild;
setintr = osetintr;
haderr = ohaderr;
didfds = odidfds;
SHIN = oSHIN;
SHOUT = oSHOUT;
SHERR = oSHERR;
OLDSTD = oOLDSTD;
tpgrp = otpgrp;
csigset = ocsigset;
nosigchld = onosigchld;
xfree((ptr_t) Vsav);
Vsav = 0;
xfree((ptr_t) Vdp);
Vdp = 0;
xfree((ptr_t) Vexpath);
Vexpath = 0;
blkfree((Char **) Vt);
Vt = 0;
/* this is from pfork() */
palloc(pid, t);
(void)sigprocmask(SIG_SETMASK, &osigset, NULL);
}
else { /* child */
/* this is from pfork() */
int pgrp;
int ignint = 0;
if (nosigchld) {
(void)sigprocmask(SIG_SETMASK, &csigset, NULL);
nosigchld = 0;
}
if (setintr)
ignint =
(tpgrp == -1 &&
(t->t_dflg & F_NOINTERRUPT))
|| (gointr && eq(gointr, STRminus));
pgrp = pcurrjob ? pcurrjob->p_jobid : getpid();
child++;
if (setintr) {
setintr = 0;
if (ignint) {
(void)signal(SIGINT, SIG_IGN);
(void)signal(SIGQUIT, SIG_IGN);
}
else {
(void)signal(SIGINT, vffree);
(void)signal(SIGQUIT, SIG_DFL);
}
if (wanttty >= 0) {
(void)signal(SIGTSTP, SIG_DFL);
(void)signal(SIGTTIN, SIG_DFL);
(void)signal(SIGTTOU, SIG_DFL);
}
(void)signal(SIGTERM, parterm);
}
else if (tpgrp == -1 &&
(t->t_dflg & F_NOINTERRUPT)) {
(void)signal(SIGINT, SIG_IGN);
(void)signal(SIGQUIT, SIG_IGN);
}
pgetty(wanttty, pgrp);
if (t->t_dflg & F_NOHUP)
(void)signal(SIGHUP, SIG_IGN);
if (t->t_dflg & F_NICE)
(void)setpriority(PRIO_PROCESS, 0, t->t_nice);
}
}
}
if (pid != 0) {
/*
* It would be better if we could wait for the whole job when we
* knew the last process had been started. Pwait, in fact, does
* wait for the whole job anyway, but this test doesn't really
* express our intentions.
*/
if (didfds == 0 && t->t_dflg & F_PIPEIN) {
(void)close(pipein[0]);
(void)close(pipein[1]);
}
if ((t->t_dflg & F_PIPEOUT) == 0) {
if (nosigchld) {
(void)sigprocmask(SIG_SETMASK, &csigset, NULL);
nosigchld = 0;
}
if ((t->t_dflg & F_AMPERSAND) == 0)
pwait();
}
break;
}
doio(t, pipein, pipeout);
if (t->t_dflg & F_PIPEOUT) {
(void)close(pipeout[0]);
(void)close(pipeout[1]);
}
/*
* Perform a builtin function. If we are not forked, arrange for
* possible stopping
*/
if (bifunc) {
func(t, bifunc);
if (forked)
exitstat();
break;
}
if (t->t_dtyp != NODE_PAREN)
doexec(NULL, t);
/*
* For () commands must put new 0,1,2 in FSH* and recurse
*/
(void) ioctl(OLDSTD = dcopy(0, FOLDSTD), FIOCLEX, NULL);
(void) ioctl(SHOUT = dcopy(1, FSHOUT), FIOCLEX, NULL);
(void) ioctl(SHERR = dcopy(2, FSHERR), FIOCLEX, NULL);
(void) close(SHIN);
SHIN = -1;
didfds = 0;
wanttty = -1;
t->t_dspr->t_dflg |= t->t_dflg & F_NOINTERRUPT;
execute(t->t_dspr, wanttty, NULL, NULL);
exitstat();
/* NOTREACHED */
case NODE_PIPE:
t->t_dcar->t_dflg |= F_PIPEOUT |
(t->t_dflg & (F_PIPEIN | F_AMPERSAND | F_STDERR | F_NOINTERRUPT));
execute(t->t_dcar, wanttty, pipein, pv);
t->t_dcdr->t_dflg |= F_PIPEIN | (t->t_dflg &
(F_PIPEOUT | F_AMPERSAND | F_NOFORK | F_NOINTERRUPT));
if (wanttty > 0)
wanttty = 0; /* got tty already */
execute(t->t_dcdr, wanttty, pv, pipeout);
break;
case NODE_LIST:
if (t->t_dcar) {
t->t_dcar->t_dflg |= t->t_dflg & F_NOINTERRUPT;
execute(t->t_dcar, wanttty, NULL, NULL);
/*
* In strange case of A&B make a new job after A
*/
if (t->t_dcar->t_dflg & F_AMPERSAND && t->t_dcdr &&
(t->t_dcdr->t_dflg & F_AMPERSAND) == 0)
pendjob();
}
if (t->t_dcdr) {
t->t_dcdr->t_dflg |= t->t_dflg &
(F_NOFORK | F_NOINTERRUPT);
execute(t->t_dcdr, wanttty, NULL, NULL);
}
break;
case NODE_OR:
case NODE_AND:
if (t->t_dcar) {
t->t_dcar->t_dflg |= t->t_dflg & F_NOINTERRUPT;
execute(t->t_dcar, wanttty, NULL, NULL);
if ((getn(value(STRstatus)) == 0) !=
(t->t_dtyp == NODE_AND))
return;
}
if (t->t_dcdr) {
t->t_dcdr->t_dflg |= t->t_dflg &
(F_NOFORK | F_NOINTERRUPT);
execute(t->t_dcdr, wanttty, NULL, NULL);
}
break;
}
/*
* Fall through for all breaks from switch
*
* If there will be no more executions of this command, flush all file
* descriptors. Places that turn on the F_REPEAT bit are responsible for
* doing donefds after the last re-execution
*/
if (didfds && !(t->t_dflg & F_REPEAT))
donefds();
}
n -= nbits;
if (any_on(b,n)) {
lostbits = 1;
k = n - 1;
if (x[k>>kshift] & 1 << (k & kmask)) {
lostbits = 2;
if (k > 0 && any_on(b,k))
lostbits = 3;
}
}
rshift(b, n);
e += n;
}
else if (n < nbits) {
n = nbits - n;
b = lshift(b, n);
e -= n;
x = b->x;
}
if (e > fpi->emax) {
ovfl:
Bfree(b);
ovfl1:
#ifndef NO_ERRNO
errno = ERANGE;
#endif
return STRTOG_Infinite | STRTOG_Overflow | STRTOG_Inexhi;
}
irv = STRTOG_Normal;
if (e < fpi->emin) {
irv = STRTOG_Denormal;
g_ddfmt(char *buf, double *dd0, int ndig, size_t bufsize)
#endif
{
FPI fpi;
char *b, *s, *se;
ULong *L, bits0[4], *bits, *zx;
int bx, by, decpt, ex, ey, i, j, mode;
Bigint *x, *y, *z;
U *dd, ddx[2];
#ifdef Honor_FLT_ROUNDS /*{{*/
int Rounding;
#ifdef Trust_FLT_ROUNDS /*{{ only define this if FLT_ROUNDS really works! */
Rounding = Flt_Rounds;
#else /*}{*/
Rounding = 1;
switch(fegetround()) {
case FE_TOWARDZERO: Rounding = 0; break;
case FE_UPWARD: Rounding = 2; break;
case FE_DOWNWARD: Rounding = 3;
}
#endif /*}}*/
#else /*}{*/
#define Rounding FPI_Round_near
#endif /*}}*/
if (bufsize < 10 || bufsize < ndig + 8)
return 0;
dd = (U*)dd0;
L = dd->L;
if ((L[_0] & 0x7ff00000L) == 0x7ff00000L) {
/* Infinity or NaN */
if (L[_0] & 0xfffff || L[_1]) {
nanret:
return strcp(buf, "NaN");
}
if ((L[2+_0] & 0x7ff00000) == 0x7ff00000) {
if (L[2+_0] & 0xfffff || L[2+_1])
goto nanret;
if ((L[_0] ^ L[2+_0]) & 0x80000000L)
goto nanret; /* Infinity - Infinity */
}
infret:
b = buf;
if (L[_0] & 0x80000000L)
*b++ = '-';
return strcp(b, "Infinity");
}
if ((L[2+_0] & 0x7ff00000) == 0x7ff00000) {
L += 2;
if (L[_0] & 0xfffff || L[_1])
goto nanret;
goto infret;
}
if (dval(&dd[0]) + dval(&dd[1]) == 0.) {
b = buf;
#ifndef IGNORE_ZERO_SIGN
if (L[_0] & L[2+_0] & 0x80000000L)
*b++ = '-';
#endif
*b++ = '0';
*b = 0;
return b;
}
if ((L[_0] & 0x7ff00000L) < (L[2+_0] & 0x7ff00000L)) {
dval(&ddx[1]) = dval(&dd[0]);
dval(&ddx[0]) = dval(&dd[1]);
dd = ddx;
L = dd->L;
}
z = d2b(dval(&dd[0]), &ex, &bx);
if (dval(&dd[1]) == 0.)
goto no_y;
x = z;
y = d2b(dval(&dd[1]), &ey, &by);
if ( (i = ex - ey) !=0) {
if (i > 0) {
x = lshift(x, i);
ex = ey;
}
else
y = lshift(y, -i);
}
if ((L[_0] ^ L[2+_0]) & 0x80000000L) {
z = diff(x, y);
if (L[_0] & 0x80000000L)
z->sign = 1 - z->sign;
}
else {
z = sum(x, y);
if (L[_0] & 0x80000000L)
z->sign = 1;
}
Bfree(x);
Bfree(y);
no_y:
bits = zx = z->x;
for(i = 0; !*zx; zx++)
i += 32;
i += lo0bits(zx);
if (i) {
rshift(z, i);
ex += i;
}
fpi.nbits = z->wds * 32 - hi0bits(z->x[j = z->wds-1]);
if (fpi.nbits < 106) {
fpi.nbits = 106;
if (j < 3) {
for(i = 0; i <= j; i++)
bits0[i] = bits[i];
while(i < 4)
bits0[i++] = 0;
bits = bits0;
}
}
mode = 2;
if (ndig <= 0) {
if (bufsize < (int)(fpi.nbits * .301029995664) + 10) {
Bfree(z);
return 0;
}
mode = 0;
}
fpi.emin = 1-1023-53+1;
fpi.emax = 2046-1023-106+1;
fpi.rounding = Rounding;
fpi.sudden_underflow = 0;
i = STRTOG_Normal;
s = gdtoa(&fpi, ex, bits, &i, mode, ndig, &decpt, &se);
b = g__fmt(buf, s, se, decpt, z->sign, bufsize);
Bfree(z);
return b;
}
strtoIg(CONST char *s00, char **se, FPI *fpi, Long *exp, Bigint **B, int *rvp)
#endif
{
Bigint *b, *b1;
int i, nb, nw, nw1, rv, rv1, swap;
unsigned int nb1, nb11;
Long e1;
b = *B;
rv = strtodg(s00, se, fpi, exp, b->x);
if (rv == STRTOG_NoMemory)
return rv;
if (!(rv & STRTOG_Inexact)) {
B[1] = 0;
return *rvp = rv;
}
e1 = exp[0];
rv1 = rv ^ STRTOG_Inexact;
b1 = Balloc(b->k);
if (b1 == NULL)
return STRTOG_NoMemory;
Bcopy(b1, b);
nb = fpi->nbits;
nb1 = nb & 31;
nb11 = (nb1 - 1) & 31;
nw = b->wds;
nw1 = nw - 1;
if (rv & STRTOG_Inexlo) {
swap = 0;
b1 = increment(b1);
if (fpi->sudden_underflow
&& (rv & STRTOG_Retmask) == STRTOG_Zero) {
b1->x[0] = 0;
b1->x[nw1] = 1L << nb11;
rv1 += STRTOG_Normal - STRTOG_Zero;
rv1 &= ~STRTOG_Underflow;
goto swapcheck;
}
if (b1->wds > nw
|| nb1 && b1->x[nw1] & 1L << nb1) {
if (++e1 > fpi->emax)
rv1 = STRTOG_Infinite | STRTOG_Inexhi;
rshift(b1, 1);
}
else if ((rv & STRTOG_Retmask) == STRTOG_Denormal) {
if (b1->x[nw1] & 1L << nb11) {
rv1 += STRTOG_Normal - STRTOG_Denormal;
rv1 &= ~STRTOG_Underflow;
}
}
}
else {
swap = STRTOG_Neg;
if ((rv & STRTOG_Retmask) == STRTOG_Infinite) {
b1 = set_ones(b1, nb);
e1 = fpi->emax;
rv1 = STRTOG_Normal | STRTOG_Inexlo;
goto swapcheck;
}
decrement(b1);
if ((rv & STRTOG_Retmask) == STRTOG_Denormal) {
for(i = nw1; !b1->x[i]; --i)
if (!i) {
rv1 = STRTOG_Zero | STRTOG_Inexlo;
break;
}
goto swapcheck;
}
if (!(b1->x[nw1] & 1L << nb11)) {
if (e1 == fpi->emin) {
if (fpi->sudden_underflow)
rv1 += STRTOG_Zero - STRTOG_Normal;
else
rv1 += STRTOG_Denormal - STRTOG_Normal;
rv1 |= STRTOG_Underflow;
}
else {
b1 = lshift(b1, 1);
b1->x[0] |= 1;
--e1;
}
}
}
swapcheck:
if (swap ^ (rv & STRTOG_Neg)) {
rvp[0] = rv1;
rvp[1] = rv;
B[0] = b1;
B[1] = b;
exp[1] = exp[0];
exp[0] = e1;
}
else {
rvp[0] = rv;
rvp[1] = rv1;
B[1] = b1;
exp[1] = e1;
}
return rv;
}
#ifdef Honor_FLT_ROUNDS
if (bc->rounding != 1) {
if (i > 0)
b = lshift(b, i);
if (dsign)
b = increment(b);
}
else
#endif
{
b = lshift(b, ++i);
b->x[0] |= 1;
}
void BigNum::divmod(vector<long long>& numbers, vector<long long>& o_numbers, vector<long long>& quo, vector<long long>& rem, long long base)
{
long n = o_numbers.size();
long m = numbers.size() - n;
vector<long long> vec_d;
vec_d.push_back(base / ( *(o_numbers.end() - 1) + 1 ));
vector<long long> u = full_mul(numbers, vec_d, base);
vector<long long> v = full_mul(o_numbers, vec_d, base);
vector<long long> bn1;
bn1.push_back(1);
lshift(&bn1, n+1);
quo.reserve(m+1);
for ( int i = 0; i < m+1; ++i )
quo.push_back(0);
long j = m;
while ( j >= 0 )
{
long long qs = (u[j + n] * base + u[j + n - 1]) / v[n - 1];
long long rs = (u[j + n] * base + u[j + n - 1]) % v[n - 1];
while ( rs < base )
if ( qs == base || qs * v[n - 2] > base * rs + u[j + n - 2] )
{
qs -= 1;
rs += v[n - 1];
}
else
break;
vector<long long> vec_qs;
vec_qs.push_back(qs);
vector<long long> part_u;
vector<long long> summand = full_mul(v, vec_qs, base);
part_u = add(u, u.begin() + j, u.begin() + j + n + 1, bn1, bn1.begin(), bn1.end(), base);
part_u = full_sub(part_u, summand, base);
trim_num_zeroes(part_u);
quo[j] = qs;
bool neg_flag;
if ( part_u.size() > n + 1 )
{
neg_flag = false;
part_u = full_sub(part_u, bn1, base);
}
else
neg_flag = true;
if ( neg_flag )
{
--quo[j];
part_u = full_add(part_u, v, base);
}
for ( int i = j; i < j + n; ++i )
u[i] = part_u[i - j];
--j;
}
for ( long j = m + n - 1; j > n - 1; --j )
u[j] = 0;
long long chk;
rem.reserve(m + n);
for ( long i = 0; i < n; ++i )
rem.push_back(0);
short_divmod(u, vec_d[0], rem, &chk, base);
if ( chk != 0 )
throw invalid_argument("error while scaling back to 1/d");
}
_Facade& operator <<=(const _ValueType& lshift_value){
lshift(lshift_value);
return *( static_cast<_Facade*>(this) ); // *(_Facade*)this;
}
void keyEvent(rdr::U32 keysym, bool down, bool jap)
{
vnclog.Print(LL_INTWARN, " keysym 0x%x",keysym);
if (keysym>=XK_dead_grave && keysym <=XK_dead_belowdot)// && down)
{
keysymDead=keysym;
vnclog.Print(LL_INTWARN, " ************** DEAD KEY");
//we have a dead key
//Record dead key
return;
}
if ((keysym >= 32 && keysym <= 126) ||
(keysym >= 160 && keysym <= 255))
{
if (keysymDead!=0 && down)
{
vnclog.Print(LL_INTWARN, " Compose dead 0x%x 0x%x",keysymDead,keysym);
switch (keysymDead)
{
case XK_dead_grave:
switch(keysym)
{
case XK_A: keysym=XK_Agrave;break;
case XK_E: keysym=XK_Egrave;break;
case XK_I: keysym=XK_Igrave;break;
case XK_O: keysym=XK_Ograve;break;
case XK_U: keysym=XK_Ugrave;break;
case XK_a: keysym=XK_agrave;break;
case XK_e: keysym=XK_egrave;break;
case XK_i: keysym=XK_igrave;break;
case XK_o: keysym=XK_ograve;break;
case XK_u: keysym=XK_ugrave;break;
}
case XK_dead_acute:
switch(keysym)
{
case XK_A: keysym=XK_Aacute;break;
case XK_E: keysym=XK_Eacute;break;
case XK_I: keysym=XK_Iacute;break;
case XK_O: keysym=XK_Oacute;break;
case XK_U: keysym=XK_Uacute;break;
case XK_a: keysym=XK_aacute;break;
case XK_e: keysym=XK_eacute;break;
case XK_i: keysym=XK_iacute;break;
case XK_o: keysym=XK_oacute;break;
case XK_u: keysym=XK_uacute;break;
case XK_y: keysym=XK_yacute;break;
case XK_Y: keysym=XK_Yacute;break;
}
case XK_dead_circumflex:
switch(keysym)
{
case XK_A: keysym=XK_Acircumflex;break;
case XK_E: keysym=XK_Ecircumflex;break;
case XK_I: keysym=XK_Icircumflex;break;
case XK_O: keysym=XK_Ocircumflex;break;
case XK_U: keysym=XK_Ucircumflex;break;
case XK_a: keysym=XK_acircumflex;break;
case XK_e: keysym=XK_ecircumflex;break;
case XK_i: keysym=XK_icircumflex;break;
case XK_o: keysym=XK_ocircumflex;break;
case XK_u: keysym=XK_ucircumflex;break;
}
case XK_dead_tilde:
switch(keysym)
{
case XK_A : keysym=XK_Ntilde;break;
case XK_O : keysym=XK_Otilde;break;
case XK_a : keysym=XK_atilde;break;
case XK_n : keysym=XK_ntilde;break;
case XK_o : keysym=XK_otilde;break;
}
case XK_dead_diaeresis:
switch(keysym)
{
case XK_A: keysym=XK_Adiaeresis;break;
case XK_E: keysym=XK_Ediaeresis;break;
case XK_I: keysym=XK_Idiaeresis;break;
case XK_O: keysym=XK_Odiaeresis;break;
case XK_U: keysym=XK_Udiaeresis;break;
case XK_a: keysym=XK_adiaeresis;break;
case XK_e: keysym=XK_ediaeresis;break;
case XK_i: keysym=XK_idiaeresis;break;
case XK_o: keysym=XK_odiaeresis;break;
case XK_u: keysym=XK_udiaeresis;break;
case XK_y: keysym=XK_ydiaeresis;break;
}
case XK_dead_cedilla:
switch(keysym)
{
case XK_C: keysym=XK_Ccedilla;break;
case XK_c: keysym=XK_ccedilla;break;
}
}
keysymDead=0;
vnclog.Print(LL_INTWARN, " Composed 0x%x",keysym);
}
// ordinary Latin-1 character
SHORT s = VkKeyScan(keysym);
// [v1.0.2-jp1 fix] yak!'s patch
// This break Other keyboards, we need an easy way of fixing this
if (jap)
{
if (keysym==XK_kana_WO) {
s = 0x0130;
} else if (keysym==XK_backslash) {
s = 0x00e2;
} else if (keysym==XK_yen) {
s = 0x00dc;
}
}
vnclog.Print(LL_INTWARN, " SHORT s %i",s);
if (s == -1)
{
if (down) {
vnclog.Print(LL_INTWARN, "down");
// not a single keypress - try synthesizing dead chars.
{
vnclog.Print(LL_INTWARN, " Found key");
//Lookup ascii representation
int ascii=0;
#if 0
// 11 Dec 2008 jdp disabled since the viewer is sending unicode now
for (ascii=0;ascii<256;ascii++)
{
if (keysym==ascii_to_x[ascii]) break;
}
#endif
ascii = keysym;
if (ascii <= 255)
{
rdr::U8 a0=ascii/100;
ascii=ascii%100;
rdr::U8 a1=ascii/10;
ascii=ascii%10;
rdr::U8 a2=ascii;
KeyStateModifier shift(VK_SHIFT);
KeyStateModifier lshift(VK_LSHIFT);
KeyStateModifier rshift(VK_RSHIFT);
if (vncService::IsWin95()) {
shift.release();
} else {
lshift.release();
rshift.release();
}
vnclog.Print(LL_INTWARN, " Simulating ALT+%d%d%d\n", a0, a1 ,a2);
keybd_event(VK_MENU,MapVirtualKey( VK_MENU, 0 ), 0 ,0);
/**
Pressing the Alt+NNN combinations without leading zero (for example, Alt+20, Alt+130, Alt+221)
will insert characters from the Extended ASCII (or MS DOS ASCII, or OEM) table. The character
glyphs contained by this table depend on the language of Windows. See the table below for the
list of characters that can be inserted through the Alt+NNN combinations (without leading zero)
in English Windows.
Pressing the Alt+0NNN combinations will insert the ANSI characters corresponding to the activate
keyboard layout. Please see Windows Character Map utility (charmap.exe) for the possible Alt+0NNN
combinations.
Finally, the Alt+00NNN combinations (two leading zeros) will insert Unicode characters. The Unicode
codes of characters are displayed in Charmap.
**/
// jdp 11 December 2008 - Need the leading 0!
keybd_event(VK_NUMPAD0, MapVirtualKey(VK_NUMPAD0, 0), 0, 0);
keybd_event(VK_NUMPAD0, MapVirtualKey(VK_NUMPAD0, 0),KEYEVENTF_KEYUP,0);
keybd_event(VK_NUMPAD0+a0, MapVirtualKey(VK_NUMPAD0+a0, 0), 0, 0);
keybd_event(VK_NUMPAD0+a0, MapVirtualKey(VK_NUMPAD0+a0, 0),KEYEVENTF_KEYUP,0);
keybd_event(VK_NUMPAD0+a1, MapVirtualKey(VK_NUMPAD0+a1, 0),0,0);
keybd_event(VK_NUMPAD0+a1, MapVirtualKey(VK_NUMPAD0+a1, 0),KEYEVENTF_KEYUP, 0);
keybd_event(VK_NUMPAD0+a2, MapVirtualKey(VK_NUMPAD0+a2, 0) ,0, 0);
keybd_event(VK_NUMPAD0+a2, MapVirtualKey(VK_NUMPAD0+a2, 0),KEYEVENTF_KEYUP, 0);
keybd_event(VK_MENU, MapVirtualKey( VK_MENU, 0 ),KEYEVENTF_KEYUP, 0);
return;
}
}
vnclog.Print(LL_INTWARN, "ignoring unrecognised Latin-1 keysym 0x%x",keysym);
}
return;
}
/*if (s == -1) {
vnclog.Print(LL_INTWARN, "ignoring unrecognised Latin-1 keysym %d\n",
keysym);
keybd_event( VK_MENU, MapVirtualKey(VK_MENU, 0),0, 0);
keybd_event( VK_MENU, MapVirtualKey(VK_MENU, 0),KEYEVENTF_KEYUP, 0);
return;
}*/
BYTE vkCode = LOBYTE(s);
// 18 March 2008 jdp
// Correct the keymask shift state to cope with the capslock state
BOOL capslockOn = (GetKeyState(VK_CAPITAL) & 1) != 0;
BYTE modifierState = HIBYTE(s);
modifierState = capslockOn ? modifierState ^ 1 : modifierState;
KeyStateModifier ctrl(VK_CONTROL);
KeyStateModifier alt(VK_MENU);
KeyStateModifier shift(VK_SHIFT);
KeyStateModifier lshift(VK_LSHIFT);
KeyStateModifier rshift(VK_RSHIFT);
if (down) {
if (modifierState & 2) ctrl.press();
if (modifierState & 4) alt.press();
if (modifierState & 1) {
shift.press();
} else {
// [v1.0.2-jp1 fix] Even if "SHIFT + SPACE" are pressed, "SHIFT" is valid
if (vkCode == 0x20){
}
else{
if (vncService::IsWin95()) {
shift.release();
} else {
lshift.release();
rshift.release();
}
}
}
}
vnclog.Print(LL_INTINFO,
"latin-1 key: keysym %d(0x%x) vkCode 0x%x down %d capslockOn %d\n",
keysym, keysym, vkCode, down, capslockOn);
doKeyboardEvent(vkCode, down ? 0 : KEYEVENTF_KEYUP);
} else {
// see if it's a recognised keyboard key, otherwise ignore it
if (vkMap.find(keysym) == vkMap.end()) {
vnclog.Print(LL_INTWARN, "ignoring unknown keysym %d\n",keysym);
return;
}
BYTE vkCode = vkMap[keysym];
DWORD flags = 0;
if (extendedMap[keysym]) flags |= KEYEVENTF_EXTENDEDKEY;
if (!down) flags |= KEYEVENTF_KEYUP;
// vnclog.Print(LL_INTINFO,
// "keyboard key: keysym %d(0x%x) vkCode 0x%x ext %d down %d\n",
// keysym, keysym, vkCode, extendedMap[keysym], down);
if (down && (vkCode == VK_DELETE) &&
((GetAsyncKeyState(VK_CONTROL) & 0x8000) != 0) &&
((GetAsyncKeyState(VK_MENU) & 0x8000) != 0) &&
vncService::IsWinNT())
{
vnclog.Print(LL_INTINFO,
"CAD\n");
// If running under Vista and started from Session0 in Application mode
if (vncService::VersionMajor()>=6 && vncService::RunningFromExternalService() )
{
vnclog.Print(LL_INTINFO,
"Vista and runnning as system -> CAD\n");
// Try to run the special Vista cad.exe file...
HANDLE ThreadHandle2;
DWORD dwTId;
ThreadHandle2 = CreateThread(NULL, 0, Cadthread, NULL, 0, &dwTId);
CloseHandle(ThreadHandle2);
}
else if (vncService::VersionMajor()>=6)
{
vnclog.Print(LL_INTINFO,
"Vista and runnning as user -> Taskmgr\n");
WinExec("taskmgr.exe", SW_SHOWNORMAL);
}
else if (vncService::VersionMajor()<6 && vncService::RunningFromExternalService() )
{
vnclog.Print(LL_INTINFO,
"Not Vista and runnning as system, use old method\n");
vncService::SimulateCtrlAltDel();
}
else if (vncService::VersionMajor()<6)
{
vnclog.Print(LL_INTINFO,
"Not Vista and runnning as user -> Taskmgr\n");
WinExec("taskmgr.exe", SW_SHOWNORMAL);
}
return;
}
if (vncService::IsWin95()) {
switch (vkCode) {
case VK_RSHIFT: vkCode = VK_SHIFT; break;
case VK_RCONTROL: vkCode = VK_CONTROL; break;
case VK_RMENU: vkCode = VK_MENU; break;
}
}
doKeyboardEvent(vkCode, flags);
}
}
/*VARARGS 1*/
void
execute(struct command *t, volatile int wanttty, int *pipein, int *pipeout,
int do_glob)
{
int forked = 0;
const struct biltins * volatile bifunc;
pid_t pid = 0;
int pv[2];
sigset_t set;
static sigset_t csigset;
#ifdef VFORK
static int onosigchld = 0;
#endif /* VFORK */
static int nosigchld = 0;
(void) &wanttty;
(void) &forked;
(void) &bifunc;
if (t == 0)
return;
#ifdef WINNT_NATIVE
{
if ((varval(STRNTslowexec) == STRNULL) &&
!t->t_dcdr && !t->t_dcar && !t->t_dflg && !didfds &&
(intty || intact) && (t->t_dtyp == NODE_COMMAND) &&
!isbfunc(t)) {
if ((t->t_dcom[0][0] & (QUOTE | TRIM)) == QUOTE)
(void) Strcpy(t->t_dcom[0], t->t_dcom[0] + 1);
Dfix(t);
if (nt_try_fast_exec(t) == 0)
return;
}
}
#endif /* WINNT_NATIVE */
/*
* Ed [email protected] & Dominic [email protected]
* Sat Feb 25 03:13:11 PST 1995
* try implicit cd if we have a 1 word command
*/
if (implicit_cd && (intty || intact) && t->t_dcom && t->t_dcom[0] &&
t->t_dcom[0][0] && (blklen(t->t_dcom) == 1) && !noexec) {
Char *sCName;
struct stat stbuf;
char *pathname;
sCName = dollar(t->t_dcom[0]);
if (sCName != NULL && sCName[0] == '~') {
struct Strbuf buf = Strbuf_INIT;
const Char *name_end;
for (name_end = sCName + 1; *name_end != '\0' && *name_end != '/';
name_end++)
continue;
if (name_end != sCName + 1) {
Char *name, *home;
name = Strnsave(sCName + 1, name_end - (sCName + 1));
home = gethdir(name);
if (home != NULL) {
Strbuf_append(&buf, home);
xfree(home);
} else
Strbuf_append(&buf, name);
xfree(name);
} else
Strbuf_append(&buf, varval(STRhome));
Strbuf_append(&buf, name_end);
xfree(sCName);
sCName = Strbuf_finish(&buf);
}
pathname = short2str(sCName);
xfree(sCName);
/* if this is a dir, tack a "cd" on as the first arg */
if (pathname != NULL &&
((stat(pathname, &stbuf) != -1 && S_ISDIR(stbuf.st_mode))
#ifdef WINNT_NATIVE
|| (pathname[0] && pathname[1] == ':' && pathname[2] == '\0')
#endif /* WINNT_NATIVE */
)) {
Char *vCD[2];
Char **ot_dcom = t->t_dcom;
vCD[0] = Strsave(STRcd);
vCD[1] = NULL;
t->t_dcom = blkspl(vCD, ot_dcom);
xfree(ot_dcom);
if (implicit_cd > 1) {
blkpr(t->t_dcom);
xputchar( '\n' );
}
}
}
/*
* From: Michael Schroeder <*****@*****.**>
* Don't check for wantty > 0...
*/
if (t->t_dflg & F_AMPERSAND)
wanttty = 0;
switch (t->t_dtyp) {
case NODE_COMMAND:
if ((t->t_dcom[0][0] & (QUOTE | TRIM)) == QUOTE)
memmove(t->t_dcom[0], t->t_dcom[0] + 1,
(Strlen(t->t_dcom[0] + 1) + 1) * sizeof (*t->t_dcom[0]));
if ((t->t_dflg & F_REPEAT) == 0)
Dfix(t); /* $ " ' \ */
if (t->t_dcom[0] == 0) {
return;
}
/*FALLTHROUGH*/
case NODE_PAREN:
#ifdef BACKPIPE
if (t->t_dflg & F_PIPEIN)
mypipe(pipein);
#else /* !BACKPIPE */
if (t->t_dflg & F_PIPEOUT)
mypipe(pipeout);
#endif /* BACKPIPE */
/*
* Must do << early so parent will know where input pointer should be.
* If noexec then this is all we do.
*/
if (t->t_dflg & F_READ) {
xclose(0);
heredoc(t->t_dlef);
if (noexec)
xclose(0);
}
setcopy(STRstatus, STR0, VAR_READWRITE);
/*
* This mess is the necessary kludge to handle the prefix builtins:
* nice, nohup, time. These commands can also be used by themselves,
* and this is not handled here. This will also work when loops are
* parsed.
*/
while (t->t_dtyp == NODE_COMMAND)
if (eq(t->t_dcom[0], STRnice)) {
if (t->t_dcom[1]) {
if (strchr("+-", t->t_dcom[1][0])) {
if (t->t_dcom[2]) {
setname("nice");
t->t_nice = (unsigned char)getn(t->t_dcom[1]);
lshift(t->t_dcom, 2);
t->t_dflg |= F_NICE;
}
else
break;
}
else {
t->t_nice = 4;
lshift(t->t_dcom, 1);
t->t_dflg |= F_NICE;
}
}
else
break;
}
else if (eq(t->t_dcom[0], STRnohup)) {
if (t->t_dcom[1]) {
t->t_dflg |= F_NOHUP;
lshift(t->t_dcom, 1);
}
else
break;
}
else if (eq(t->t_dcom[0], STRhup)) {
if (t->t_dcom[1]) {
t->t_dflg |= F_HUP;
lshift(t->t_dcom, 1);
}
else
break;
}
else if (eq(t->t_dcom[0], STRtime)) {
if (t->t_dcom[1]) {
t->t_dflg |= F_TIME;
lshift(t->t_dcom, 1);
}
else
break;
}
#ifdef F_VER
else if (eq(t->t_dcom[0], STRver))
if (t->t_dcom[1] && t->t_dcom[2]) {
setname("ver");
t->t_systype = getv(t->t_dcom[1]);
lshift(t->t_dcom, 2);
t->t_dflg |= F_VER;
}
else
break;
#endif /* F_VER */
else
break;
/* is it a command */
if (t->t_dtyp == NODE_COMMAND) {
/*
* Check if we have a builtin function and remember which one.
*/
bifunc = isbfunc(t);
if (noexec) {
/*
* Continue for builtins that are part of the scripting language
*/
if (bifunc == NULL)
break;
if (bifunc->bfunct != (bfunc_t)dobreak &&
bifunc->bfunct != (bfunc_t)docontin &&
bifunc->bfunct != (bfunc_t)doelse &&
bifunc->bfunct != (bfunc_t)doend &&
bifunc->bfunct != (bfunc_t)doforeach&&
bifunc->bfunct != (bfunc_t)dogoto &&
bifunc->bfunct != (bfunc_t)doif &&
bifunc->bfunct != (bfunc_t)dorepeat &&
bifunc->bfunct != (bfunc_t)doswbrk &&
bifunc->bfunct != (bfunc_t)doswitch &&
bifunc->bfunct != (bfunc_t)dowhile &&
bifunc->bfunct != (bfunc_t)dozip)
break;
}
}
else { /* not a command */
bifunc = NULL;
if (noexec)
break;
}
/*
* GrP Executing a command - run jobcmd hook
* Don't run for builtins
* Don't run if we're not in a tty
* Don't run if we're not really executing
*/
/*
* CR - Charles Ross Aug 2005
* added "isoutatty".
* The new behavior is that the jobcmd won't be executed
* if stdout (SHOUT) isnt attached to a tty.. IE when
* redirecting, or using backquotes etc..
*/
if (t->t_dtyp == NODE_COMMAND && !bifunc && !noexec && intty && isoutatty) {
Char *cmd = unparse(t);
cleanup_push(cmd, xfree);
job_cmd(cmd);
cleanup_until(cmd);
}
/*
* We fork only if we are timed, or are not the end of a parenthesized
* list and not a simple builtin function. Simple meaning one that is
* not pipedout, niced, nohupped, or &'d. It would be nice(?) to not
* fork in some of these cases.
*/
#ifdef BACKPIPE
/*
* Can't have NOFORK for the tail of a pipe - because it is not the
* last command spawned (even if it is at the end of a parenthesised
* list).
*/
if (t->t_dflg & F_PIPEIN)
t->t_dflg &= ~(F_NOFORK);
#else
/*
* "command | builtin" may cause major misbehaviour as noted in
* in the BUGS file entry
* Subject: Redirected input to built-in functions misbehaves badly
* forking when the builtin is the end of the pipe corrects the
* problem.
*/
if (bifunc && (t->t_dflg & F_PIPEIN))
t->t_dflg &= ~(F_NOFORK);
#endif /* BACKPIPE */
/*
* Prevent forking cd, pushd, popd, chdir cause this will cause the
* shell not to change dir! (XXX: but only for nice?)
*/
if (bifunc && (bifunc->bfunct == (bfunc_t)dochngd ||
bifunc->bfunct == (bfunc_t)dopushd ||
bifunc->bfunct == (bfunc_t)dopopd))
t->t_dflg &= ~(F_NICE);
if (((t->t_dflg & F_TIME) || ((t->t_dflg & F_NOFORK) == 0 &&
(!bifunc || t->t_dflg &
(F_PIPEOUT | F_AMPERSAND | F_NICE | F_NOHUP | F_HUP)))) ||
/*
* We have to fork for eval too.
*/
(bifunc && (t->t_dflg & F_PIPEIN) != 0 &&
bifunc->bfunct == (bfunc_t)doeval)) {
#ifdef VFORK
if (t->t_dtyp == NODE_PAREN ||
t->t_dflg & (F_REPEAT | F_AMPERSAND) || bifunc)
#endif /* VFORK */
{
forked++;
/*
* We need to block SIGCHLD here, so that if the process does
* not die before we can set the process group
*/
if (wanttty >= 0 && !nosigchld) {
sigemptyset(&set);
sigaddset(&set, SIGCHLD);
(void)sigprocmask(SIG_BLOCK, &set, &csigset);
nosigchld = 1;
}
pid = pfork(t, wanttty);
if (pid == 0 && nosigchld) {
sigprocmask(SIG_SETMASK, &csigset, NULL);
nosigchld = 0;
}
else if (pid != 0 && (t->t_dflg & F_AMPERSAND))
backpid = pid;
}
#ifdef VFORK
else {
int ochild, osetintr, ohaderr, odidfds;
int oSHIN, oSHOUT, oSHDIAG, oOLDSTD, otpgrp;
int oisoutatty, oisdiagatty;
sigset_t oset, ocsigset;
# ifndef CLOSE_ON_EXEC
int odidcch;
# endif /* !CLOSE_ON_EXEC */
/*
* Prepare for the vfork by saving everything that the child
* corrupts before it exec's. Note that in some signal
* implementations which keep the signal info in user space
* (e.g. Sun's) it will also be necessary to save and restore
* the current sigvec's for the signals the child touches
* before it exec's.
*/
/*
* Sooooo true... If this is a Sun, save the sigvec's. (Skip
* Gilbrech - 11/22/87)
*/
# ifdef SAVESIGVEC
struct sigaction savesv[NSIGSAVED];
sigset_t savesm;
# endif /* SAVESIGVEC */
if (wanttty >= 0 && !nosigchld && !noexec) {
sigemptyset(&set);
sigaddset(&set, SIGCHLD);
(void)sigprocmask(SIG_BLOCK, &set, &csigset);
nosigchld = 1;
}
sigemptyset(&set);
sigaddset(&set, SIGCHLD);
sigaddset(&set, SIGINT);
(void)sigprocmask(SIG_BLOCK, &set, &oset);
ochild = child;
osetintr = setintr;
ohaderr = haderr;
odidfds = didfds;
# ifndef CLOSE_ON_EXEC
odidcch = didcch;
# endif /* !CLOSE_ON_EXEC */
oSHIN = SHIN;
oSHOUT = SHOUT;
oSHDIAG = SHDIAG;
oOLDSTD = OLDSTD;
otpgrp = tpgrp;
oisoutatty = isoutatty;
oisdiagatty = isdiagatty;
ocsigset = csigset;
onosigchld = nosigchld;
Vsav = Vdp = 0;
Vexpath = 0;
Vt = 0;
# ifdef SAVESIGVEC
savesigvec(savesv, savesm);
# endif /* SAVESIGVEC */
if (use_fork)
pid = fork();
else
pid = vfork();
if (pid < 0) {
# ifdef SAVESIGVEC
restoresigvec(savesv, savesm);
# endif /* SAVESIGVEC */
sigprocmask(SIG_SETMASK, &oset, NULL);
stderror(ERR_NOPROC);
}
forked++;
if (pid) { /* parent */
# ifdef SAVESIGVEC
restoresigvec(savesv, savesm);
# endif /* SAVESIGVEC */
child = ochild;
setintr = osetintr;
haderr = ohaderr;
didfds = odidfds;
SHIN = oSHIN;
# ifndef CLOSE_ON_EXEC
didcch = odidcch;
# endif /* !CLOSE_ON_EXEC */
SHOUT = oSHOUT;
SHDIAG = oSHDIAG;
OLDSTD = oOLDSTD;
tpgrp = otpgrp;
isoutatty = oisoutatty;
isdiagatty = oisdiagatty;
csigset = ocsigset;
nosigchld = onosigchld;
xfree(Vsav);
Vsav = 0;
xfree(Vdp);
Vdp = 0;
xfree(Vexpath);
Vexpath = 0;
blk_cleanup(Vt);
Vt = 0;
/* this is from pfork() */
palloc(pid, t);
sigprocmask(SIG_SETMASK, &oset, NULL);
}
else { /* child */
/* this is from pfork() */
pid_t pgrp;
int ignint = 0;
if (nosigchld) {
sigprocmask(SIG_SETMASK, &csigset, NULL);
nosigchld = 0;
}
if (setintr)
ignint = (tpgrp == -1 && (t->t_dflg & F_NOINTERRUPT))
|| (gointr && eq(gointr, STRminus));
pgrp = pcurrjob ? pcurrjob->p_jobid : getpid();
child++;
if (setintr) {
setintr = 0;
/*
* casts made right for SunOS 4.0 by Douglas C. Schmidt
* <*****@*****.**>
* (thanks! -- PWP)
*
* ignint ifs cleaned by Johan Widen <[email protected]>
* (thanks again)
*/
if (ignint) {
(void) signal(SIGINT, SIG_IGN);
(void) signal(SIGQUIT, SIG_IGN);
}
else {
(void) signal(SIGINT, vffree);
(void) signal(SIGQUIT, SIG_DFL);
}
# ifdef BSDJOBS
if (wanttty >= 0) {
(void) signal(SIGTSTP, SIG_DFL);
(void) signal(SIGTTIN, SIG_DFL);
(void) signal(SIGTTOU, SIG_DFL);
}
# endif /* BSDJOBS */
sigaction(SIGTERM, &parterm, NULL);
}
else if (tpgrp == -1 &&
(t->t_dflg & F_NOINTERRUPT)) {
(void) signal(SIGINT, SIG_IGN);
(void) signal(SIGQUIT, SIG_IGN);
}
pgetty(wanttty, pgrp);
if (t->t_dflg & F_NOHUP)
(void) signal(SIGHUP, SIG_IGN);
if (t->t_dflg & F_HUP)
(void) signal(SIGHUP, SIG_DFL);
if (t->t_dflg & F_NICE) {
int nval = SIGN_EXTEND_CHAR(t->t_nice);
# if defined(HAVE_SETPRIORITY) && defined(PRIO_PROCESS)
if (setpriority(PRIO_PROCESS, 0, nval) == -1 && errno)
stderror(ERR_SYSTEM, "setpriority",
strerror(errno));
# else /* !HAVE_SETPRIORITY || !PRIO_PROCESS */
(void) nice(nval);
# endif /* HAVE_SETPRIORITY && PRIO_PROCESS */
}
# ifdef F_VER
if (t->t_dflg & F_VER) {
tsetenv(STRSYSTYPE, t->t_systype ? STRbsd43 : STRsys53);
dohash(NULL, NULL);
}
# endif /* F_VER */
}
}
#endif /* VFORK */
}
if (pid != 0) {
/*
* It would be better if we could wait for the whole job when we
* knew the last process had been started. Pwait, in fact, does
* wait for the whole job anyway, but this test doesn't really
* express our intentions.
*/
#ifdef BACKPIPE
if (didfds == 0 && t->t_dflg & F_PIPEOUT) {
xclose(pipeout[0]);
xclose(pipeout[1]);
}
if ((t->t_dflg & F_PIPEIN) != 0)
break;
#else /* !BACKPIPE */
if (didfds == 0 && t->t_dflg & F_PIPEIN) {
xclose(pipein[0]);
xclose(pipein[1]);
}
if ((t->t_dflg & F_PIPEOUT) != 0)
break;
#endif /* BACKPIPE */
if (nosigchld) {
sigprocmask(SIG_SETMASK, &csigset, NULL);
nosigchld = 0;
}
if ((t->t_dflg & F_AMPERSAND) == 0)
pwait();
break;
}
doio(t, pipein, pipeout);
#ifdef BACKPIPE
if (t->t_dflg & F_PIPEIN) {
xclose(pipein[0]);
xclose(pipein[1]);
}
#else /* !BACKPIPE */
if (t->t_dflg & F_PIPEOUT) {
xclose(pipeout[0]);
xclose(pipeout[1]);
}
#endif /* BACKPIPE */
/*
* Perform a builtin function. If we are not forked, arrange for
* possible stopping
*/
if (bifunc) {
if (forked) {
func(t, bifunc);
exitstat();
} else {
jmp_buf_t oldexit;
int ohaderr = haderr;
getexit(oldexit);
if (setexit() == 0)
func(t, bifunc);
resexit(oldexit);
haderr = ohaderr;
if (adrof(STRprintexitvalue)) {
int rv = getn(varval(STRstatus));
if (rv != 0)
xprintf(CGETS(17, 2, "Exit %d\n"), rv);
}
}
break;
}
if (t->t_dtyp != NODE_PAREN) {
doexec(t, do_glob);
/* NOTREACHED */
}
/*
* For () commands must put new 0,1,2 in FSH* and recurse
*/
if ((OLDSTD = dcopy(0, FOLDSTD)) >= 0)
(void)close_on_exec(OLDSTD, 1);
if ((SHOUT = dcopy(1, FSHOUT)) >= 0) {
(void)close_on_exec(SHOUT, 1);
isoutatty = isatty(SHOUT);
}
if ((SHDIAG = dcopy(2, FSHDIAG)) >= 0) {
(void)close_on_exec(SHDIAG, 1);
isdiagatty = isatty(SHDIAG);
}
xclose(SHIN);
SHIN = -1;
#ifndef CLOSE_ON_EXEC
didcch = 0;
#else
(void) close_on_exec(FSHOUT, 1);
(void) close_on_exec(FSHDIAG, 1);
(void) close_on_exec(FOLDSTD, 1);
#endif /* !CLOSE_ON_EXEC */
didfds = 0;
wanttty = -1;
t->t_dspr->t_dflg |= t->t_dflg & (F_NOINTERRUPT | F_BACKQ);
execute(t->t_dspr, wanttty, NULL, NULL, do_glob);
exitstat();
case NODE_PIPE:
#ifdef BACKPIPE
t->t_dcdr->t_dflg |= F_PIPEIN | (t->t_dflg &
(F_PIPEOUT | F_AMPERSAND | F_NOFORK | F_NOINTERRUPT | F_BACKQ));
execute(t->t_dcdr, wanttty, pv, pipeout, do_glob);
t->t_dcar->t_dflg |= F_PIPEOUT | (t->t_dflg &
(F_PIPEIN | F_AMPERSAND | F_STDERR | F_NOINTERRUPT | F_BACKQ));
execute(t->t_dcar, wanttty, pipein, pv, do_glob);
#else /* !BACKPIPE */
t->t_dcar->t_dflg |= F_PIPEOUT | (t->t_dflg &
(F_PIPEIN | F_AMPERSAND | F_STDERR | F_NOINTERRUPT | F_BACKQ));
execute(t->t_dcar, wanttty, pipein, pv, do_glob);
t->t_dcdr->t_dflg |= F_PIPEIN | (t->t_dflg &
(F_PIPEOUT | F_AMPERSAND | F_NOFORK | F_NOINTERRUPT | F_BACKQ));
execute(t->t_dcdr, wanttty, pv, pipeout, do_glob);
#endif /* BACKPIPE */
break;
case NODE_LIST:
if (t->t_dcar) {
t->t_dcar->t_dflg |= t->t_dflg & (F_NOINTERRUPT | F_BACKQ);
execute(t->t_dcar, wanttty, NULL, NULL, do_glob);
/*
* In strange case of A&B make a new job after A
*/
if (t->t_dcar->t_dflg & F_AMPERSAND && t->t_dcdr &&
(t->t_dcdr->t_dflg & F_AMPERSAND) == 0)
pendjob();
}
if (t->t_dcdr) {
t->t_dcdr->t_dflg |= t->t_dflg &
(F_NOFORK | F_NOINTERRUPT | F_BACKQ);
execute(t->t_dcdr, wanttty, NULL, NULL, do_glob);
}
break;
case NODE_OR:
case NODE_AND:
if (t->t_dcar) {
t->t_dcar->t_dflg |= t->t_dflg & (F_NOINTERRUPT | F_BACKQ);
execute(t->t_dcar, wanttty, NULL, NULL, do_glob);
if ((getn(varval(STRstatus)) == 0) !=
(t->t_dtyp == NODE_AND)) {
return;
}
}
if (t->t_dcdr) {
t->t_dcdr->t_dflg |= t->t_dflg &
(F_NOFORK | F_NOINTERRUPT | F_BACKQ);
execute(t->t_dcdr, wanttty, NULL, NULL, do_glob);
}
break;
default:
break;
}
/*
* Fall through for all breaks from switch
*
* If there will be no more executions of this command, flush all file
* descriptors. Places that turn on the F_REPEAT bit are responsible for
* doing donefds after the last re-execution
*/
if (didfds && !(t->t_dflg & F_REPEAT))
donefds();
}
static inline int32_t RVC_decoder__texture_Y__DCRecontruction__addressingaccess(ActorInstance_RVC_decoder__texture_Y__DCRecontruction__addressing* thisActor, int32_t p, int32_t c){
return bitor(lshift(p, 2), c);
}
