bool Parser::statement() {
bool isReturn = false;
switch (lexer->token) {
case '{': isReturn = block(); break;
case TK_if: ifStat(); break;
case TK_while: whileStat(); break;
case TK_for: forStat(); break;
case TK_return: {
advance();
int top = syms->localsTop();
emit(top, RET, 0, expr(top), UNUSED);
isReturn = true;
break;
}
case TK_NAME: {
int lookahead = lexer->lookahead();
if (lookahead == '=' || lookahead == ':'+TK_EQUAL) {
Value name = lexer->info.name;
consume(TK_NAME);
if (lookahead == '=') {
int slot = lookupSlot(name);
consume('=');
int top = syms->localsTop();
patchOrEmitMove(top + 1, slot, expr(top));
proto->patchPos = -1;
} else {
consume(':'+TK_EQUAL);
if (syms->definedInThisBlock(name)) {
CERR(true, E_VAR_REDEFINITION, name);
// aSlot = slot; // reuse existing local with same name
} else {
const Value a = expr(syms->localsTop());
const int slot = syms->set(name);
patchOrEmitMove(slot+1, slot, a);
proto->patchPos = -1;
}
}
break;
}
}
default: {
int top = syms->localsTop();
Value lhs = expr(top);
if (TOKEN == '=') {
consume('=');
CERR(!IS_REG(lhs), E_ASSIGN_TO_CONST, lhs);
CERR(proto->patchPos < 0, E_ASSIGN_RHS, lhs);
unsigned code = proto->code.pop();
int op = OP(code);
CERR(op != GETI && op != GETF, E_ASSIGN_RHS, lhs);
assert((int)lhs == OC(code));
emit(top + 3, op + 1, OA(code), VAL_REG(OB(code)), expr(top + 2));
}
}
}
return isReturn;
}
void idct_sh4(DCTELEM *block)
{
DEFREG;
int i;
float tblock[8*8],*fblock;
int ofs1,ofs2,ofs3;
#if defined(__SH4__)
#error "FIXME!! change to single float"
#endif
/* row */
/* even part */
load_matrix(even_table);
fblock = tblock+4;
i = 8;
do {
fr0 = block[0];
fr1 = block[2];
fr2 = block[4];
fr3 = block[6];
block+=8;
ftrv();
*--fblock = fr3;
*--fblock = fr2;
*--fblock = fr1;
*--fblock = fr0;
fblock+=8+4;
} while(--i);
block-=8*8;
fblock-=8*8+4;
load_matrix(odd_table);
i = 8;
// ofs1 = sizeof(float)*1;
// ofs2 = sizeof(float)*2;
// ofs3 = sizeof(float)*3;
do {
float t0,t1,t2,t3;
fr0 = block[1];
fr1 = block[3];
fr2 = block[5];
fr3 = block[7];
block+=8;
ftrv();
t0 = *fblock++;
t1 = *fblock++;
t2 = *fblock++;
t3 = *fblock++;
fblock+=4;
*--fblock = t0 - fr0;
*--fblock = t1 - fr1;
*--fblock = t2 - fr2;
*--fblock = t3 - fr3;
*--fblock = t3 + fr3;
*--fblock = t2 + fr2;
*--fblock = t1 + fr1;
*--fblock = t0 + fr0;
fblock+=8;
} while(--i);
block-=8*8;
fblock-=8*8;
/* col */
/* even part */
load_matrix(even_table);
ofs1 = sizeof(float)*2*8;
ofs2 = sizeof(float)*4*8;
ofs3 = sizeof(float)*6*8;
i = 8;
#define OA(fblock,ofs) *(float*)((char*)fblock + ofs)
do {
fr0 = OA(fblock, 0);
fr1 = OA(fblock,ofs1);
fr2 = OA(fblock,ofs2);
fr3 = OA(fblock,ofs3);
ftrv();
OA(fblock,0 ) = fr0;
OA(fblock,ofs1) = fr1;
OA(fblock,ofs2) = fr2;
OA(fblock,ofs3) = fr3;
fblock++;
} while(--i);
fblock-=8;
load_matrix(odd_table);
i=8;
do {
float t0,t1,t2,t3;
t0 = OA(fblock, 0); /* [8*0] */
t1 = OA(fblock,ofs1); /* [8*2] */
t2 = OA(fblock,ofs2); /* [8*4] */
t3 = OA(fblock,ofs3); /* [8*6] */
fblock+=8;
fr0 = OA(fblock, 0); /* [8*1] */
fr1 = OA(fblock,ofs1); /* [8*3] */
fr2 = OA(fblock,ofs2); /* [8*5] */
fr3 = OA(fblock,ofs3); /* [8*7] */
fblock+=-8+1;
ftrv();
block[8*0] = DESCALE(t0 + fr0,3);
block[8*7] = DESCALE(t0 - fr0,3);
block[8*1] = DESCALE(t1 + fr1,3);
block[8*6] = DESCALE(t1 - fr1,3);
block[8*2] = DESCALE(t2 + fr2,3);
block[8*5] = DESCALE(t2 - fr2,3);
block[8*3] = DESCALE(t3 + fr3,3);
block[8*4] = DESCALE(t3 - fr3,3);
block++;
} while(--i);
#if defined(__SH4__)
#error "FIXME!! change to double"
#endif
}
void ff_idct_sh4(int16_t *block)
{
DEFREG;
int i;
float tblock[8*8],*fblock;
int ofs1,ofs2,ofs3;
int fpscr;
fp_single_enter(fpscr);
/* row */
/* even part */
load_matrix(even_table);
fblock = tblock+4;
i = 8;
do {
fr0 = block[0];
fr1 = block[2];
fr2 = block[4];
fr3 = block[6];
block+=8;
ftrv();
*--fblock = fr3;
*--fblock = fr2;
*--fblock = fr1;
*--fblock = fr0;
fblock+=8+4;
} while(--i);
block-=8*8;
fblock-=8*8+4;
load_matrix(odd_table);
i = 8;
do {
float t0,t1,t2,t3;
fr0 = block[1];
fr1 = block[3];
fr2 = block[5];
fr3 = block[7];
block+=8;
ftrv();
t0 = *fblock++;
t1 = *fblock++;
t2 = *fblock++;
t3 = *fblock++;
fblock+=4;
*--fblock = t0 - fr0;
*--fblock = t1 - fr1;
*--fblock = t2 - fr2;
*--fblock = t3 - fr3;
*--fblock = t3 + fr3;
*--fblock = t2 + fr2;
*--fblock = t1 + fr1;
*--fblock = t0 + fr0;
fblock+=8;
} while(--i);
block-=8*8;
fblock-=8*8;
/* col */
/* even part */
load_matrix(even_table);
ofs1 = sizeof(float)*2*8;
ofs2 = sizeof(float)*4*8;
ofs3 = sizeof(float)*6*8;
i = 8;
#define OA(fblock,ofs) *(float*)((char*)fblock + ofs)
do {
fr0 = OA(fblock, 0);
fr1 = OA(fblock,ofs1);
fr2 = OA(fblock,ofs2);
fr3 = OA(fblock,ofs3);
ftrv();
OA(fblock,0 ) = fr0;
OA(fblock,ofs1) = fr1;
OA(fblock,ofs2) = fr2;
OA(fblock,ofs3) = fr3;
fblock++;
} while(--i);
fblock-=8;
load_matrix(odd_table);
i=8;
do {
float t0,t1,t2,t3;
t0 = OA(fblock, 0); /* [8*0] */
t1 = OA(fblock,ofs1); /* [8*2] */
t2 = OA(fblock,ofs2); /* [8*4] */
t3 = OA(fblock,ofs3); /* [8*6] */
fblock+=8;
fr0 = OA(fblock, 0); /* [8*1] */
fr1 = OA(fblock,ofs1); /* [8*3] */
fr2 = OA(fblock,ofs2); /* [8*5] */
fr3 = OA(fblock,ofs3); /* [8*7] */
fblock+=-8+1;
ftrv();
block[8*0] = DESCALE(t0 + fr0,3);
block[8*7] = DESCALE(t0 - fr0,3);
block[8*1] = DESCALE(t1 + fr1,3);
block[8*6] = DESCALE(t1 - fr1,3);
block[8*2] = DESCALE(t2 + fr2,3);
block[8*5] = DESCALE(t2 - fr2,3);
block[8*3] = DESCALE(t3 + fr3,3);
block[8*4] = DESCALE(t3 - fr3,3);
block++;
} while(--i);
fp_single_leave(fpscr);
}
// extern __thread jmp_buf jumpBuf;
int VM::call(Value A, int nEffArgs, Value *regs, Stack *stack) {
Vector<RetInfo> retInfo; // only used if FAST_CALL
if (!(IS_O_TYPE(A, O_FUNC) || IS_CF(A) || IS_O_TYPE(A, O_CFUNC))) { return -1; }
regs = stack->maybeGrow(regs, 256);
int nExpectedArgs = IS_O_TYPE(A, O_FUNC) ? ((Func *)GET_OBJ(A))->proto->nArgs : NARGS_CFUNC;
nEffArgs = prepareStackForCall(regs, nExpectedArgs, nEffArgs, gc);
if (IS_CF(A) || IS_O_TYPE(A, O_CFUNC)) {
if (IS_CF(A)) {
tfunc f = GET_CF(A);
*regs = f(this, CFunc::CFUNC_CALL, 0, regs, nEffArgs);
} else {
((CFunc *) GET_OBJ(A))->call(this, regs, nEffArgs);
}
return 0;
}
unsigned code = 0;
Value B;
Value *ptrC;
Func *activeFunc = (Func *) GET_OBJ(A);
unsigned *pc = (unsigned *) activeFunc->proto->code.buf();
static void *dispatch[] = {
#define _(name) &&name
#include "opcodes.inc"
#undef _
};
assert(sizeof(dispatch)/sizeof(dispatch[0]) == N_OPCODES);
copyUpvals(activeFunc, regs);
STEP;
JMP: pc += OD(code); STEP;
JT: if (!IS_FALSE(*ptrC)) { pc += OD(code); } STEP;
JF: if ( IS_FALSE(*ptrC)) { pc += OD(code); } STEP;
JLT: if (lessThan(A, B)) { pc += OSC(code); } STEP;
JNIS: if (A != B) { pc += OSC(code); } STEP;
FOR:
A = *(ptrC + 1);
B = *(ptrC + 2);
if (!IS_NUM(A) || !IS_NUM(B)) { goto error; } // E_FOR_NOT_NUMBER
*ptrC = B;
if (!(GET_NUM(B) < GET_NUM(A))) { pc += OD(code); }
STEP;
LOOP: {
const double counter = GET_NUM(*ptrC) + 1;
if (counter < GET_NUM(*(ptrC+1))) { pc += OD(code); }
*ptrC = VAL_NUM(counter);
STEP;
}
FUNC:
assert(IS_PROTO(A));
*ptrC = VAL_OBJ(Func::alloc(gc, PROTO(A), regs + 256, regs, OB(code)));
STEP;
// index, A[B]
GETI: *ptrC = types->type(A)->indexGet(A, B); if (*ptrC == VERR) { goto error; } STEP;
GETF: *ptrC = types->type(A)->fieldGet(A, B); if (*ptrC == VERR) { goto error; } STEP;
SETI: if (!types->type(*ptrC)->indexSet(*ptrC, A, B)) { goto error; } STEP;
SETF: if (!types->type(*ptrC)->fieldSet(*ptrC, A, B)) { goto error; } STEP;
/*
const int oa = OA(code);
const int ob = OB(code);
int top = max(oa, ob) + 1;
top = max(top, activeFunc->proto->localsTop);
Value *base = regs + top;
printf("top %d\n", top);
base[0] = A;
base[1] = B;
int cPos = ptrC - regs;
DO_CALL(v, 2, regs, base, stack);
regs[cPos] = base[0];
break;
if (*ptrC == VERR) { goto error; }
*/
GETS: *ptrC = getSlice(gc, A, B, regs[OB(code)+1]); if (*ptrC==VERR) { goto error; } STEP;
SETS: if (setSlice(*ptrC, A, regs[OA(code)+1], B)) { goto error; } STEP;
RET: {
regs[0] = A;
Value *root = stack->base;
gc->maybeCollect(root, regs - root + 1);
#if FAST_CALL
if (!retInfo.size()) {
return 0;
}
RetInfo *ri = retInfo.top();
pc = ri->pc;
regs = stack->base + ri->base;
activeFunc = ri->func;
retInfo.pop();
copyUpvals(activeFunc, regs);
STEP;
#else
return 0;
#endif
}
CALL: {
if (!IS_OBJ(A) && !IS_CF(A)) { goto error; } // E_CALL_NOT_FUNC
int nEffArgs = OSB(code);
assert(nEffArgs != 0);
Value *base = ptrC;
#if FAST_CALL
if (IS_O_TYPE(A, O_FUNC)) {
Func *f = (Func *) GET_OBJ(A);
Proto *proto = f->proto;
prepareStackForCall(base, proto->nArgs, nEffArgs, gc);
RetInfo *ret = retInfo.push();
ret->pc = pc;
ret->base = regs - stack->base;
ret->func = activeFunc;
regs = stack->maybeGrow(base, 256);
copyUpvals(f, regs);
pc = proto->code.buf();
activeFunc = f;
} else {
#endif
int ret = DO_CALL(A, nEffArgs, regs, base, stack);
if (ret) { goto error; }
#if FAST_CALL
}
#endif
STEP;
}
MOVEUP: {
const int slot = regs + 256 - ptrC;
activeFunc->setUp(slot, A);
}
MOVE_R: *ptrC = A; STEP;
MOVE_I: *ptrC = VAL_NUM(OD(code)); STEP;
MOVE_V: {
int id = OA(code);
*ptrC =
id == CONST_NIL ? VNIL :
id == CONST_EMPTY_STRING ? EMPTY_STRING :
id == CONST_EMPTY_ARRAY ? VAL_OBJ(emptyArray->copy(gc)) :
VAL_OBJ(emptyMap->copy(gc));
STEP;
}
MOVE_C: {
Value v = *pc | (((u64) *(pc+1)) << 32);
pc += 2;
if (IS_ARRAY(v)) {
v = VAL_OBJ(ARRAY(v)->copy(gc));
} else if (IS_MAP(v)) {
v = VAL_OBJ(MAP(v)->copy(gc));
}
*ptrC = v;
STEP;
}
LEN: *ptrC = VAL_NUM(len(A)); STEP;
NOTL: *ptrC = IS_FALSE(A) ? TRUE : FALSE; STEP;
// notb: *ptrC = IS_INT(A)? VAL_INT(~getInteger(A)):ERROR(E_WRONG_TYPE); STEP;
ADD: *ptrC = doAdd(gc, A, B); if (*ptrC == VERR) { goto error; } STEP;
SUB: *ptrC = BINOP(-, A, B); STEP;
MUL: *ptrC = BINOP(*, A, B); STEP;
DIV: *ptrC = BINOP(/, A, B); STEP;
MOD: *ptrC = doMod(A, B); if (*ptrC == VERR) { goto error; } STEP;
POW: *ptrC = doPow(A, B); if (*ptrC == VERR) { goto error; } STEP;
AND: *ptrC = BITOP(&, A, B); STEP;
OR: *ptrC = BITOP(|, A, B); STEP;
XOR: *ptrC = BITOP(^, A, B); STEP;
SHL_RR: ERR(!IS_NUM(B), E_WRONG_TYPE); *ptrC = doSHL(A, (int)GET_NUM(B)); STEP;
SHR_RR: ERR(!IS_NUM(B), E_WRONG_TYPE); *ptrC = doSHR(A, (int)GET_NUM(B)); STEP;
SHL_RI: *ptrC = doSHL(A, OSB(code)); STEP;
SHR_RI: *ptrC = doSHR(A, OSB(code)); STEP;
EQ: *ptrC = equals(A, B) ? TRUE : FALSE; STEP;
NEQ: *ptrC = !equals(A, B) ? TRUE : FALSE; STEP;
IS: *ptrC = A == B ? TRUE : FALSE; STEP;
NIS: *ptrC = A != B ? TRUE : FALSE; STEP;
LT: *ptrC = lessThan(A, B) ? TRUE : FALSE; STEP;
LE: *ptrC = (equals(A, B) || lessThan(A, B)) ? TRUE : FALSE; STEP;
error: return pc - (unsigned *) activeFunc->proto->code.buf();
}
"off", TkCbufall,
"0", TkCbufauto,
"no", TkCbufauto,
"off", TkCbufauto,
nil
};
#define O(t, e) ((long)(&((t*)0)->e))
#define OA(t, e) ((long)(((t*)0)->e))
static
TkOption opts[] =
{
"closeenough", OPTfrac, O(TkCanvas, close), nil,
"confine", OPTfrac, O(TkCanvas, confine), nil,
"scrollregion", OPTfrac, OA(TkCanvas, scrollr), IAUX(4),
"xscrollincrement", OPTfrac, O(TkCanvas, xscrolli), nil,
"yscrollincrement", OPTfrac, O(TkCanvas, yscrolli), nil,
"xscrollcommand", OPTtext, O(TkCanvas, xscroll), nil,
"yscrollcommand", OPTtext, O(TkCanvas, yscroll), nil,
"width", OPTnnfrac, O(TkCanvas, width), nil,
"height", OPTnnfrac, O(TkCanvas, height), nil,
"buffer", OPTstab, O(TkCanvas, buffer), tkbuffer,
"buffered", OPTstab, O(TkCanvas, buffer), tkbool, /* backwards compatibility */
"selectborderwidth", OPTnndist, O(TkCanvas, sborderwidth), nil,
nil
};
int cvslshape[] = { TKI2F(8), TKI2F(10), TKI2F(3) };
Rectangle bbnil = { 1000000, 1000000, -1000000, -1000000 };
Rectangle huger = { -1000000, -1000000, 1000000, 1000000 };
void Panama<B>::Iterate(unsigned int count, const word32 *p, word32 *z, const word32 *y)
{
unsigned int bstart = m_bstart;
word32 *const a = m_state;
#define c (a+17)
#define b ((Stage *)(a+34))
// output
#define OA(i) z[i] = ConditionalByteReverse(B::ToEnum(), a[i+9])
#define OX(i) z[i] = y[i] ^ ConditionalByteReverse(B::ToEnum(), a[i+9])
// buffer update
#define US(i) {word32 t=b0[i]; b0[i]=ConditionalByteReverse(B::ToEnum(), p[i])^t; b25[(i+6)%8]^=t;}
#define UL(i) {word32 t=b0[i]; b0[i]=a[i+1]^t; b25[(i+6)%8]^=t;}
// gamma and pi
#define GP(i) c[5*i%17] = rotlFixed(a[i] ^ (a[(i+1)%17] | ~a[(i+2)%17]), ((5*i%17)*((5*i%17)+1)/2)%32)
// theta and sigma
#define T(i,x) a[i] = c[i] ^ c[(i+1)%17] ^ c[(i+4)%17] ^ x
#define TS1S(i) T(i+1, ConditionalByteReverse(B::ToEnum(), p[i]))
#define TS1L(i) T(i+1, b4[i])
#define TS2(i) T(i+9, b16[i])
while (count--)
{
if (z)
{
if (y)
{
OX(0); OX(1); OX(2); OX(3); OX(4); OX(5); OX(6); OX(7);
y += 8;
}
else
{
OA(0); OA(1); OA(2); OA(3); OA(4); OA(5); OA(6); OA(7);
}
z += 8;
}
word32 *const b16 = b[(bstart+16) % STAGES];
word32 *const b4 = b[(bstart+4) % STAGES];
bstart = (bstart + STAGES - 1) % STAGES;
word32 *const b0 = b[bstart];
word32 *const b25 = b[(bstart+25) % STAGES];
if (p)
{
US(0); US(1); US(2); US(3); US(4); US(5); US(6); US(7);
}
else
{
UL(0); UL(1); UL(2); UL(3); UL(4); UL(5); UL(6); UL(7);
}
GP(0); GP(1); GP(2); GP(3); GP(4); GP(5); GP(6); GP(7);
GP(8); GP(9); GP(10); GP(11); GP(12); GP(13); GP(14); GP(15); GP(16);
T(0,1);
if (p)
{
TS1S(0); TS1S(1); TS1S(2); TS1S(3); TS1S(4); TS1S(5); TS1S(6); TS1S(7);
p += 8;
}
else
{
TS1L(0); TS1L(1); TS1L(2); TS1L(3); TS1L(4); TS1L(5); TS1L(6); TS1L(7);
}
TS2(0); TS2(1); TS2(2); TS2(3); TS2(4); TS2(5); TS2(6); TS2(7);
}
m_bstart = bstart;
}
void Panama<B>::Iterate(size_t count, const word32 *p, word32 *z, const word32 *y)
{
word32 bstart = m_state[17];
word32 *const aPtr = m_state;
word32 cPtr[17];
#define bPtr ((byte *)(aPtr+20))
// reorder the state for SSE2
// a and c: 4 8 12 16 | 3 7 11 15 | 2 6 10 14 | 1 5 9 13 | 0
// xmm0 xmm1 xmm2 xmm3 eax
#define a(i) aPtr[((i)*13+16) % 17] // 13 is inverse of 4 mod 17
#define c(i) cPtr[((i)*13+16) % 17]
// b: 0 4 | 1 5 | 2 6 | 3 7
#define b(i, j) b##i[(j)*2%8 + (j)/4]
// output
#define OA(i) z[i] = ConditionalByteReverse(B::ToEnum(), a(i+9))
#define OX(i) z[i] = y[i] ^ ConditionalByteReverse(B::ToEnum(), a(i+9))
// buffer update
#define US(i) {word32 t=b(0,i); b(0,i)=ConditionalByteReverse(B::ToEnum(), p[i])^t; b(25,(i+6)%8)^=t;}
#define UL(i) {word32 t=b(0,i); b(0,i)=a(i+1)^t; b(25,(i+6)%8)^=t;}
// gamma and pi
#define GP(i) c(5*i%17) = rotlFixed(a(i) ^ (a((i+1)%17) | ~a((i+2)%17)), ((5*i%17)*((5*i%17)+1)/2)%32)
// theta and sigma
#define T(i,x) a(i) = c(i) ^ c((i+1)%17) ^ c((i+4)%17) ^ x
#define TS1S(i) T(i+1, ConditionalByteReverse(B::ToEnum(), p[i]))
#define TS1L(i) T(i+1, b(4,i))
#define TS2(i) T(i+9, b(16,i))
while (count--)
{
if (z)
{
if (y)
{
OX(0); OX(1); OX(2); OX(3); OX(4); OX(5); OX(6); OX(7);
y += 8;
}
else
{
OA(0); OA(1); OA(2); OA(3); OA(4); OA(5); OA(6); OA(7);
}
z += 8;
}
word32 *const b16 = (word32 *)(bPtr+((bstart+16*32) & 31*32));
word32 *const b4 = (word32 *)(bPtr+((bstart+(32-4)*32) & 31*32));
bstart += 32;
word32 *const b0 = (word32 *)(bPtr+((bstart) & 31*32));
word32 *const b25 = (word32 *)(bPtr+((bstart+(32-25)*32) & 31*32));
if (p)
{
US(0); US(1); US(2); US(3); US(4); US(5); US(6); US(7);
}
else
{
UL(0); UL(1); UL(2); UL(3); UL(4); UL(5); UL(6); UL(7);
}
GP(0);
GP(1);
GP(2);
GP(3);
GP(4);
GP(5);
GP(6);
GP(7);
GP(8);
GP(9);
GP(10);
GP(11);
GP(12);
GP(13);
GP(14);
GP(15);
GP(16);
T(0,1);
if (p)
{
TS1S(0); TS1S(1); TS1S(2); TS1S(3); TS1S(4); TS1S(5); TS1S(6); TS1S(7);
p += 8;
}
else
{
TS1L(0); TS1L(1); TS1L(2); TS1L(3); TS1L(4); TS1L(5); TS1L(6); TS1L(7);
}
TS2(0); TS2(1); TS2(2); TS2(3); TS2(4); TS2(5); TS2(6); TS2(7);
}
m_state[17] = bstart;
}
tkt->nfocus = 0;
}
#define O(t, e) ((long)(&((t*)0)->e))
#define OA(t, e) ((long)(((t*)0)->e))
typedef struct TkSee TkSee;
struct TkSee {
int r[4];
int p[2];
int query;
};
static
TkOption seeopts[] = {
"rectangle", OPTfrac, OA(TkSee, r), IAUX(4),
"point", OPTfrac, OA(TkSee, p), IAUX(2),
"where", OPTbool, O(TkSee, query), nil,
nil
};
char*
tkseecmd(TkTop *t, char *arg, char **ret)
{
TkOptab tko[2];
TkSee opts;
TkName *names;
Tk *tk;
char *e;
Rectangle vr;
Point vp;
