/*********************************
* *
* printExpr *
* *
*********************************/
void
printExpr(PE_EXPR *expr)
{
if (expr) {
switch (expr->tag) {
case E_VAR:
printf("VAR(%s)", expr->info.var);
break;
case E_APP:
printf("APP(");
printTerm(expr->info.app.term);
printf(", ");
printExpr(expr->info.app.expr);
printf(")");
break;
case E_PAIR:
printf("PAIR(");
printExpr(expr->info.epair.l);
printf(", ");
printExpr(expr->info.epair.r);
printf(")");
break;
case E_BANG:
printf("()");
break;
default:
printf("printExpr: Error\n");
exit(-1);
break;
}
}
}
void icodePrint(FILE* fp){
int i;
int zero =0;
fprintf(fp, "\n\x1b[32m~~~~~~~~~~~~~~~ Icode: ~~~~~~~~~~~~~~~\x1b[0m\n\n");
fprintf(fp, " # | Operation | Result | Argument 1 | Argument 2 | Label | Line\n");
fprintf(fp, "\n-----------------------------------------------------------------------------------------------------\n\n");
for(i = 1; i < currQuad; i++){
fprintf(fp, "%3u|%20s|", i, enumIcodeToString(quads[i].op));
// fprintf(stderr, "\t %u: %s \t ", i, enumIcodeToString(quads[i].op));
printExpr(fp, quads[i].result);
fprintf(fp, "|");
printExpr(fp, quads[i].arg1);
fprintf(fp, "|");
printExpr(fp, quads[i].arg2);
fprintf(fp, "|");
if (quads[i].op == JUMP || quads[i].op == IF_EQ || quads[i].op == IF_NOTEQ
|| quads[i].op == IF_GREATER || quads[i].op == IF_LESS
|| quads[i].op == IF_GREATEREQ || quads[i].op == IF_LESSEQ){
// fprintf(stderr, "\t %u \t", quads[i].label);
fprintf(fp, "%7u|", quads[i].label);
}else{
fprintf(fp, "%7d|", zero);
}
fprintf(fp, "%5d", quads[i].line);
fprintf(fp, "\n\n");
}
}
void printWhil (struct WHILE_S *w) {
struct func_elem *e = (struct func_elem *) malloc (sizeof (struct func_elem));
if (w == NULL) {
//fprintf (stderr, "While does not exist.\n");
return;
}
strcpy (e->name, "while");
e->nextCnt = 0;
list_push (&funclist, e);
if (w->do_while) {
fprintf (fp, "do{\n");
printStmtList (w->stmt);
fprintf (fp, "} while(");
printExpr (w->cond);
fprintf (fp, ");");
}
else {
fprintf (fp, "while(");
printExpr (w->cond);
fprintf (fp, "){\n");
printStmtList (w->stmt);
fprintf (fp, "}");
}
list_pop (&funclist);
free (e);
}
void Expression::printVarIndex() {
byte *arrDesc;
int16 dim;
int16 dimCount;
int16 operation;
int16 temp;
int32 pos = _vm->_game->_script->pos();
operation = _vm->_game->_script->readByte();
switch (operation) {
case OP_LOAD_VAR_INT32:
case OP_LOAD_VAR_STR:
temp = _vm->_game->_script->readUint16() * 4;
debugN(5, "&var_%d", temp);
if ((operation == OP_LOAD_VAR_STR) && (_vm->_game->_script->peekByte() == 13)) {
_vm->_game->_script->skip(1);
debugN(5, "+");
printExpr(OP_END_MARKER);
}
break;
case OP_ARRAY_INT32:
case OP_ARRAY_STR:
debugN(5, "&var_%d[", _vm->_game->_script->readUint16());
dimCount = _vm->_game->_script->readByte();
arrDesc = _vm->_game->_script->getData() + _vm->_game->_script->pos();
_vm->_game->_script->skip(dimCount);
for (dim = 0; dim < dimCount; dim++) {
printExpr(OP_END_MARKER);
debugN(5, " of %d", (int16) arrDesc[dim]);
if (dim != dimCount - 1)
debugN(5, ",");
}
debugN(5, "]");
if ((operation == OP_ARRAY_STR) && (_vm->_game->_script->peekByte() == 13)) {
_vm->_game->_script->skip(1);
debugN(5, "+");
printExpr(OP_END_MARKER);
}
break;
default:
debugN(5, "var_0");
break;
}
debugN(5, "\n");
_vm->_game->_script->seek(pos);
return;
}
void Parse::printVarIndex() {
char *arrDesc;
int16 dim;
int16 dimCount;
int16 operation;
int16 temp;
char *pos = _vm->_global->_inter_execPtr;
operation = *_vm->_global->_inter_execPtr++;
switch (operation) {
case 23:
case 25:
temp = _vm->_inter->load16() * 4;
debugN(5, "&var_%d", temp);
if (operation == 25 && *_vm->_global->_inter_execPtr == 13) {
_vm->_global->_inter_execPtr++;
debugN(5, "+");
printExpr(12);
}
break;
case 26:
case 28:
debugN(5, "&var_%d[", _vm->_inter->load16());
dimCount = *_vm->_global->_inter_execPtr++;
arrDesc = _vm->_global->_inter_execPtr;
_vm->_global->_inter_execPtr += dimCount;
for (dim = 0; dim < dimCount; dim++) {
printExpr(12);
debugN(5, " of %d", (int16)arrDesc[dim]);
if (dim != dimCount - 1)
debugN(5, ",");
}
debugN(5, "]");
if (operation == 28 && *_vm->_global->_inter_execPtr == 13) {
_vm->_global->_inter_execPtr++;
debugN(5, "+");
printExpr(12);
}
break;
default:
debugN(5, "var_0");
break;
}
debugN(5, "\n");
_vm->_global->_inter_execPtr = pos;
return;
}
/*********************************
* *
* printRecord *
* *
*********************************/
void
printRecord(PE_RECORD **record)
{
int count = 0;
char *parent = NULL;
int numStructors = 0;
assert(record);
parent = getStructorParent(record[0]->destr);
numStructors = getNumStructors(parent);
printf("(");
for (count = 0; count < numStructors; count++) {
if (record[count]) {
if (count != 0)
printf(", ");
printf("%s:", record[0]->destr);
printExpr(record[0]->expr);
}
else {
printMsg(WARN_MSG, "printRecord - incomplete number of destructors");
/* !!!! set parse error flag */
}
}
printf(")");
}
void printFor (struct FOR_S *f) {
struct func_elem *e = (struct func_elem *) malloc (sizeof (struct func_elem));
if (f == NULL) {
//fprintf (stderr, "For does not exist.\n");
return;
}
strcpy (e->name, "for");
e->nextCnt = 0;
list_push (&funclist, e);
fprintf (fp, "for(");
printAssi (f->init);
fprintf (fp, ";");
printExpr (f->cond);
fprintf (fp, ";");
printAssi (f->inc);
fprintf (fp, "){\n");
printStmtList (f->stmt);
fprintf (fp, "}");
list_pop (&funclist);
free (e);
}
void printIf (struct IF_S *i) {
struct func_elem *e = (struct func_elem *) malloc (sizeof (struct func_elem));
if (i == NULL) {
//fprintf (stderr, "If does not exist.\n");
return;
}
strcpy (e->name, "if");
e->nextCnt = 0;
list_push (&funclist, e);
fprintf (fp, "if(");
printExpr (i->cond);
fprintf (fp, "){\n");
printStmtList (i->if_);
fprintf (fp, "}");
if (i->else_ != NULL) {
fprintf (fp, " else{\n");
printStmtList (i->else_);
fprintf (fp, "}");
}
list_pop (&funclist);
free (e);
}
void printRet (struct EXPR *r) {
fprintf (fp, "return");
if (r != NULL) {
fprintf (fp, " ");
printExpr (r);
}
}
void printAssi (struct ASSIGN *a) {
if (a == NULL) {
//fprintf (stderr, "Assign does not exist.\n");
return;
}
if (a->index == NULL)
fprintf (fp, "%s", a->ID);
else {
fprintf (fp, "%s[", a->ID);
printExpr (a->index);
fprintf (fp, "]");
}
fprintf (fp, "=");
printExpr (a->expr);
}
/*********************************
* *
* printT_Phrase *
* *
*********************************/
void
printT_Phrase(PE_T_PHRASE *phrase)
{
assert(phrase);
printPatt(phrase->patt);
printf(" => ");
printExpr(phrase->expr);
}
void printArguList (struct ARG *a, int num) {
if (a == NULL) {
//fprintf (stderr, "Argument list does not exist.\n");
return;
}
if (a->prev != NULL)
printArguList (a->prev, num+1);
printExpr (a->expr);
if (num != 0)
fprintf (fp, ", ");
}
/*********************************
* *
* displayDef *
* *
*********************************/
void
displayDef(PE_DEF *def)
{
assert(def);
printf("FUNCTION: %s {", def->id);
printList((LIST *) def->macros);
printf("} ");
if (def->type_sig) {
printf(": ");
printTypeSig(def->type_sig);
}
printf(" (");
printVarBase(def->var_base);
printf(") = \n");
printExpr(def->expr);
printf("\n");
}
static void print(llvm::raw_ostream &out, const Object *x) {
if (x == NULL) {
out << "NULL";
return;
}
switch (x->objKind) {
case SOURCE : {
const Source *y = (const Source *)x;
out << "Source(" << y->fileName << ")";
break;
}
case IDENTIFIER : {
const Identifier *y = (const Identifier *)x;
out << "Identifier(" << y->str << ")";
break;
}
case DOTTED_NAME : {
const DottedName *y = (const DottedName *)x;
out << "DottedName(" << llvm::makeArrayRef(y->parts) << ")";
break;
}
case EXPRESSION : {
const Expr *y = (const Expr *)x;
printExpr(out, y);
break;
}
case EXPR_LIST : {
const ExprList *y = (const ExprList *)x;
out << "ExprList(" << y->exprs << ")";
break;
}
case STATEMENT : {
const Statement *y = (const Statement *)x;
printStatement(out, y);
break;
}
case CASE_BLOCK : {
const CaseBlock *y = (const CaseBlock *)x;
out << "CaseBlock(" << y->caseLabels << ", " << y->body << ")";
break;
}
case CATCH : {
const Catch *y = (const Catch *)x;
out << "Catch(" << y->exceptionVar << ", "
<< y->exceptionType << ", " << y->body << ")";
break;
}
case CODE : {
const Code *y = (const Code *)x;
out << "Code(" << y->patternVars << ", " << y->predicate;
out << ", " << y->formalArgs << ", " << y->hasVarArg;
out << ", " << y->returnSpecs << ", " << y->varReturnSpec;
out << ", " << y->body << ")";
break;
}
case FORMAL_ARG : {
const FormalArg *y = (const FormalArg *)x;
out << "FormalArg(" << y->name << ", " << y->type << ", "
<< y->tempness << ")";
break;
}
case RETURN_SPEC : {
const ReturnSpec *y = (const ReturnSpec *)x;
out << "ReturnSpec(" << y->type << ", " << y->name << ")";
break;
}
case RECORD_DECL : {
const RecordDecl *y = (const RecordDecl *)x;
out << "RecordDecl(" << y->name << ", " << y->params;
out << ", " << y->varParam << ", " << y->body << ")";
break;
}
case RECORD_BODY : {
const RecordBody *y = (const RecordBody *)x;
out << "RecordBody(" << y->isComputed << ", " << y->computed;
out << ", " << y->fields << ")";
break;
}
case RECORD_FIELD : {
const RecordField *y = (const RecordField *)x;
out << "RecordField(" << y->name << ", " << y->type << ")";
break;
}
case VARIANT_DECL : {
const VariantDecl *y = (const VariantDecl *)x;
out << "VariantDecl(" << y->name << ", " << y->params;
out << ", " << y->varParam << ")";
break;
}
case INSTANCE_DECL : {
const InstanceDecl *y = (const InstanceDecl *)x;
out << "InstanceDecl(" << y->patternVars << ", " << y->predicate;
out << ", " << y->target << ", " << y->members << ")";
break;
}
case OVERLOAD : {
const Overload *y = (const Overload *)x;
out << "Overload(" << y->target << ", " << y->code << ", "
<< y->callByName << ", " << y->isInline << ")";
break;
}
case PROCEDURE : {
const Procedure *y = (const Procedure *)x;
out << "Procedure(" << y->name << ")";
break;
}
case INTRINSIC : {
const IntrinsicSymbol *intrin = (const IntrinsicSymbol *)x;
out << "IntrinsicSymbol(" << intrin->name << ", " << intrin->id << ")";
break;
}
case ENUM_DECL : {
const EnumDecl *y = (const EnumDecl *)x;
out << "EnumDecl(" << y->name << ", " << y->members << ")";
break;
}
case ENUM_MEMBER : {
const EnumMember *y = (const EnumMember *)x;
out << "EnumMember(" << y->name << ")";
break;
}
case NEW_TYPE_DECL : {
const NewTypeDecl *y = (const NewTypeDecl *)x;
out << "NewTypeDecl(" << y->name << ")";
break;
}
case GLOBAL_VARIABLE : {
const GlobalVariable *y = (const GlobalVariable *)x;
out << "GlobalVariable(" << y->name << ", " << y->params
<< ", " << y->varParam << ", " << y->expr << ")";
break;
}
case EXTERNAL_PROCEDURE : {
const ExternalProcedure *y = (const ExternalProcedure *)x;
out << "ExternalProcedure(" << y->name << ", " << y->args;
out << ", " << y->hasVarArgs << ", " << y->returnType;
out << ", " << y->body << ")";
break;
}
case EXTERNAL_ARG: {
const ExternalArg *y = (const ExternalArg *)x;
out << "ExternalArg(" << y->name << ", " << y->type << ")";
break;
}
case EXTERNAL_VARIABLE : {
const ExternalVariable *y = (const ExternalVariable *)x;
out << "ExternalVariable(" << y->name << ", " << y->type << ")";
break;
}
case GLOBAL_ALIAS : {
const GlobalAlias *y = (const GlobalAlias *)x;
out << "GlobalAlias(" << y->name << ", " << y->params
<< ", " << y->varParam << ", " << y->expr << ")";
break;
}
case IMPORT : {
const Import *y = (const Import *)x;
switch (y->importKind) {
case IMPORT_MODULE : {
const ImportModule *z = (const ImportModule *)y;
out << "Import(" << z->dottedName << ", " << z->alias << ")";
break;
}
case IMPORT_STAR : {
const ImportStar *z = (const ImportStar *)y;
out << "ImportStar(" << z->dottedName << ")";
break;
}
case IMPORT_MEMBERS : {
const ImportMembers *z = (const ImportMembers *)y;
out << "ImportMembers(" << z->visibility << ", " << z->dottedName << ", [";
for (size_t i = 0; i < z->members.size(); ++i) {
if (i != 0)
out << ", ";
const ImportedMember &a = z->members[i];
out << "(" << a.name << ", " << a.alias << ")";
}
out << "])";
break;
}
default :
assert(false);
}
break;
}
case EVAL_TOPLEVEL : {
const EvalTopLevel *eval = (const EvalTopLevel *)x;
out << "EvalTopLevel(" << eval->args << ")";
break;
}
case STATIC_ASSERT_TOP_LEVEL : {
const StaticAssertTopLevel *staticAssert = (const StaticAssertTopLevel*)x;
out << "StaticAssertTopLevel(" << staticAssert->cond;
for (size_t i = 0; i < staticAssert->message->size(); ++i) {
out << ", " << staticAssert->message->exprs[i];
}
out << ")";
break;
}
case MODULE_DECLARATION : {
const ModuleDeclaration *y = (const ModuleDeclaration *)x;
out << "ModuleDeclaration(" << y->name << ", " << y->attributes << ")";
break;
}
case MODULE : {
const Module *y = (const Module *)x;
out << "Module(" << bigVec(y->imports) << ", "
<< bigVec(y->topLevelItems) << ")";
break;
}
case PRIM_OP : {
const PrimOp *y = (const PrimOp *)x;
out << "PrimOp(" << primOpName(const_cast<PrimOp *>(y)) << ")";
break;
}
case TYPE : {
const Type *y = (const Type *)x;
typePrint(out, const_cast<Type *>(y));
break;
}
case PATTERN : {
const Pattern *y = (const Pattern *)x;
patternPrint(out, const_cast<Pattern *>(y));
break;
}
case MULTI_PATTERN : {
const MultiPattern *y = (const MultiPattern *)x;
patternPrint(out, const_cast<MultiPattern *>(y));
break;
}
case VALUE_HOLDER : {
const ValueHolder *y = (const ValueHolder *)x;
EValuePtr ev = new EValue(y->type, y->buf);
out << "ValueHolder(";
printTypeAndValue(out, ev);
out << ")";
break;
}
case MULTI_STATIC : {
const MultiStatic *y = (const MultiStatic *)x;
out << "MultiStatic(" << y->values << ")";
break;
}
case PVALUE : {
const PValue *y = (const PValue *)x;
out << "PValue(" << y->data << ")";
break;
}
case MULTI_PVALUE : {
const MultiPValue *y = (const MultiPValue *)x;
out << "MultiPValue(" << llvm::makeArrayRef(y->values) << ")";
break;
}
case EVALUE : {
const EValue *y = (const EValue *)x;
out << "EValue(" << y->type << ")";
break;
}
case MULTI_EVALUE : {
const MultiEValue *y = (const MultiEValue *)x;
out << "MultiEValue(" << y->values << ")";
break;
}
case CVALUE : {
const CValue *y = (const CValue *)x;
out << "CValue(" << y->type << ")";
break;
}
case MULTI_CVALUE : {
const MultiCValue *y = (const MultiCValue *)x;
out << "MultiCValue(" << y->values << ")";
break;
}
case DOCUMENTATION : {
const Documentation *d = (const Documentation *)x;
out << "Documentation(" << d->text << ")";
break;
}
default :
out << "UnknownObj(" << x->objKind << ")";
break;
}
}
void printExpr (struct EXPR *ex) {
if (ex == NULL) {
//fprintf (stderr, "Expression does not exist.\n");
return;
}
if (ex->e == eUnop) {
if (ex->expression.unop_->u == eNegative)
fprintf (fp, "-");
printExpr (ex->expression.unop_->expr);
}
else if (ex->e == eAddi) {
printExpr (ex->expression.addiop_->lhs);
if (ex->expression.addiop_->a == ePlus)
fprintf (fp, "+");
else
fprintf (fp, "-");
printExpr (ex->expression.addiop_->rhs);
}
else if (ex->e == eMult) {
printExpr (ex->expression.multop_->lhs);
if (ex->expression.multop_->m == eMulti)
fprintf (fp, "*");
else
fprintf (fp, "/");
printExpr (ex->expression.multop_->rhs);
}
else if (ex->e == eRela) {
printExpr (ex->expression.eqltop_->lhs);
if (ex->expression.relaop_->r == eLT)
fprintf (fp, "<");
else if (ex->expression.relaop_->r == eGT)
fprintf (fp, ">");
else if (ex->expression.relaop_->r == eLE)
fprintf (fp, "<=");
else
fprintf (fp, ">=");
printExpr (ex->expression.eqltop_->rhs);
}
else if (ex->e == eEqlt) {
printExpr (ex->expression.eqltop_->lhs);
if (ex->expression.eqltop_->e == eEQ)
fprintf (fp, "==");
else
fprintf (fp, "!=");
printExpr (ex->expression.eqltop_->rhs);
}
else if (ex->e == eCallExpr) {
printCall (ex->expression.call_);
}
else if (ex->e == eIntnum) {
fprintf (fp, "%d", ex->expression.intnum);
}
else if (ex->e == eFloatnum) {
fprintf (fp, "%f", ex->expression.floatnum);
}
else if (ex->e == eId) {
fprintf (fp, "%s", ex->expression.ID_->ID);
if (ex->expression.ID_->expr != NULL) {
fprintf (fp, "[");
printExpr (ex->expression.ID_->expr);
fprintf (fp, "]");
}
}
else { // eExpr
fprintf (fp, "(");
printExpr (ex->expression.bracket);
fprintf (fp, ")");
}
}
/* analyze data reference with regular access pattern */
int analyze_regular_access(dat_inst_t *d_inst, inf_node_t *ib) {
int dbg = 0;
int i,j,min, tmp;
int lpId, addr, flag;
insn_t *insn;
expr_p exp;
reg_t tmpReg;
ts_p ts;
loop_t *lp;
int lpIter[5];
worklist_p tsList, tsNode, addrSet;
initReg(&tmpReg);
exp = &(d_inst->addrExpr);
//check if it is really regular access (no unknown parameter)
for (i=0; i<exp->varNum; i++) {
if (exp->value[i].t==VALUE_PARA || exp->value[i].t==VALUE_UNDEF){
analyze_unpred_access(d_inst,ib);return;}
}
//Sort BIV loopID in ascending order
for (i=0; i<exp->varNum; i++) {
min = i;
for (j=i+1; j<exp->varNum; j++) {
if (exp->value[j].val <= exp->value[min].val) min = j;
#if 0
if (exp->coef[i] = 0 - exp->coef[j]) {
exp->value[i].val = max(exp->value[i].val,exp->value[j].val);
exp->coef[i] = absInt(exp->coef[i]);
exp->coef[j] = 0;
exp->value[j].val = 999;
}
#endif
}
if (i==min) continue;//exp->value[i] is already min
if (exp->value[min].val == exp->value[i].val) {
//min & i are two biv of the same loop --> merge
exp->coef[i] += exp->coef[min];
exp->value[min].val = 999;exp->coef[min] =0;
}
else {//swap min & i
cpyReg(&tmpReg, exp->value[i]);
cpyReg(&(exp->value[i]), exp->value[min]);
cpyReg(&(exp->value[min]), tmpReg);
tmp = exp->coef[i]; exp->coef[i]=exp->coef[min]; exp->coef[min]=tmp;
}
}
//Clear up merged register
while (exp->varNum>0) {
i = exp->varNum-1;
if (exp->value[i].val == 999) exp->varNum--;
else break;
}
/*To deal with j = i*/
if (dbg) {fprintf(dbgAddr,"\nSorted expr: ");printExpr(dbgAddr,exp);}
//create the temporal scope for memory blocks of d_inst
tsList = NULL; tsNode = NULL;
lp = loops[exp->value[0].val];//inner most loop
i = 0;
while (lp!=NULL) {
if (0) fprintf(dbgAddr,"\n In loop L%d, lbound %d",lp->id,lp->bound-1);
ts = (ts_p) malloc(sizeof(ts_s));
if (lp->id == exp->value[i].val) {
ts->loop_id = lp->id; ts->lw = 0; ts->up = 0; ts->flag = 0;i++;
}
else {
ts->loop_id = lp->id; ts->lw = 0; ts->up = lp->bound; ts->flag = 0;
}
addAfterNode(ts, &tsNode, &tsList);
//addToWorkList( &(orgTS),memTS);
lp = lp->parent;
}
if (dbg) {fprintf(dbgAddr,"\nTemporal scope: ");printTSset(dbgAddr,tsList);}
//enumerating possible memory blocks
addrSet = NULL; lastNode = NULL;
enumTSset = &tsList;
enumAddrSet = &addrSet;
flag = 0;
for (i=0; i<num_tcfg_loops; i++) iterValue[i]=-1;
minAddr = exp->k; maxAddr = 0;
enum_regular_address(d_inst, exp, flag, 0, tsList, exp->k);
d_inst->addr_set = addrSet;
if (dbg) {
fprintf(dbgAddr,"\nGenerated range: [%x, %x], %d elems",
minAddr, maxAddr, GET_MEM(maxAddr-minAddr));
//printSAddrSet(dbgAddr,d_inst->addr_set,1);
}
}
int main(void){
// initialize
init();
while(1) {
// input & process
if (Stylus.Released) {
clearButton();
}
if (Pad.Released.L || Pad.Released.R) {
pushed_trig = 0;
}
if (Pad.Released.Left || Pad.Released.Y) {
pushed_left = 0;
}
if (Pad.Released.Right || Pad.Released.A) {
pushed_right = 0;
}
if (Pad.Released.Up || Pad.Released.X) {
pushed_up = 0;
}
if (Pad.Released.Down || Pad.Released.B) {
pushed_down = 0;
}
if (Stylus.Held) {
if (!pushed_stylus) {
if (result_print == 2) {
insertString(inputValue, inputPos, " ", 100);
inputValue[inputPos] = getStylusValue();
if (actionStylus2(checkValue(inputValue[inputPos])))
goto LOOP_END;
// if (on_graph) {
//
// } else {
//
// }
} else {
insertString(expr, exprPos, " ", 200);
expr[exprPos] = getStylusValue();
insertString(p_expr, printStrPos, " ", 340);
p_expr[printStrPos] = expr[exprPos];
if (actionStylus(checkValue(expr[exprPos])))
goto LOOP_END;
}
}
pushed_stylus = 1;
}
if (Pad.Held.L || Pad.Held.R) {
if (!pushed_trig) {
stylus_page = stylus_page == 1 ? 2 : 1;
changeLabel(stylus_page);
}
pushed_trig = 1;
}
if (Pad.Held.Left || Pad.Held.Y) {
if (!pushed_left) {
moveCursor(-1); // left move
}
pushed_left = 1;
}
if (Pad.Held.Right || Pad.Held.A) {
if (!pushed_right) {
moveCursor(1); // right move
}
pushed_right = 1;
}
if (Pad.Held.Up || Pad.Held.X) {
if (!pushed_up) {
overviewPrevExpr();
}
pushed_up = 1;
}
if (Pad.Held.Down || Pad.Held.B) {
if (!pushed_down) {
overviewNextExpr();
}
pushed_down = 1;
}
// teardown
printExpr();
//moveCursor(1);
LOOP_END:
PA_WaitForVBL(); // process interrupt
}
return 0;
}
