static void checkOtherBits( FILE *fp, int indent, int size, char *prefix, char *var, int which_long ) {
//*****************************************************************************************************
if( which_long >= _NLONGS( size ) ) {
doShift( fp, indent, size, var );
} else {
char buffer[ 80 ];
sprintf( buffer, "if( %s->_%d & 0x80000000 ) {", var, which_long );
emitStmt( fp, indent, buffer );
doSet( fp, indent + 1, size, prefix, var, which_long + 1 );
emitStmt( fp, indent, "} else {" );
checkOtherBits( fp, indent + 1, size, prefix, var, which_long + 1 );
emitStmt( fp, indent, "}" );
}
}
static void emitBitNext( FILE *fp, int size, char *prefix, char *type_name )
//**************************************************************************
{
int indent;
fprintf( fp, "#ifdef %s_DEFINE_BITNEXT\n", prefix );
fprintf( fp, "static void %sNext( %s *set ) {\n\n", prefix, type_name );
indent = 1;
if( size > 32 ) {
emitStmt( fp, indent, "if( set->_0 & 0x80000000 ) {" );
doSet( fp, indent + 1, size, prefix, "set", 1 );
emitStmt( fp, indent, "} else {" );
if( size > 64 ) {
checkOtherBits( fp, indent + 1, size, prefix, "set", 1 );
} else {
doShift( fp, indent + 1, size, "set" );
}
emitStmt( fp, indent, "}" );
} else {
doShift( fp, indent, size, "set" );
}
fprintf( fp, "}\n" );
fprintf( fp, "#endif\n\n" );
}
bool LinuxDisplayMode::setDefault(int index)
{
return doSet(index, false);
}
bool LinuxDisplayMode::set(int index)
{
return doSet(index, true);
}
//
// SourceExpression_Binary::doSetBase
//
void SourceExpression_Binary::doSetBase(ObjectVector *objects,
VariableData *dst)
{
VariableData::Pointer src = exprL->getData();
VariableType::Reference typeL = exprL->getType();
// If can't do the op= codegen, emulate it.
if(!canDoSet(src, typeL))
{
doSetBaseEmulated(objects, dst, src, typeL);
return;
}
int tmpBase = 0;
ObjectExpression::Pointer tmpA, tmpB;
VariableData::Pointer tmp = VariableData::create_stack(src->size);
if (dst->type != VariableData::MT_VOID)
make_objects_memcpy_prep(objects, dst, tmp, pos);
// MT_REGISTERARRAY addressing.
if(src->type == VariableData::MT_ARRAY)
{
src->offsetTemp = VariableData::create_stack
(src->offsetExpr->getType()->getSize(pos));
src->offsetExpr->makeObjects(objects, src->offsetTemp);
// Extra address for get.
if (dst->type != VariableData::MT_VOID)
objects->addToken(OCODE_STK_COPY);
}
if(docast)
create_value_cast_explicit(exprR, typeL, context, pos)->makeObjects(objects, tmp);
else
exprR->makeObjects(objects, tmp);
// MT_POINTER addressing.
if (src->type == VariableData::MT_POINTER)
{
src->offsetTemp = VariableData::create_stack
(src->offsetExpr->getType()->getSize(pos));
src->offsetExpr->makeObjects(objects, src->offsetTemp);
// Extra address for get.
if (dst->type != VariableData::MT_VOID)
{
tmpA = context->getTempVar(tmpBase++);
objects->addToken(OCODE_SET_TEMP, tmpA);
objects->addToken(OCODE_GET_TEMP, tmpA);
}
}
// MT_FARPTR addressing.
else if(src->type == VariableData::MT_FARPTR)
{
src->offsetTemp = VariableData::create_stack(src->offsetExpr->getType()->getSize(pos));
src->offsetExpr->makeObjects(objects, src->offsetTemp);
// Extra address for get.
if(dst->type != VariableData::MT_VOID)
{
tmpA = context->getTempVar(tmpBase++);
tmpB = context->getTempVar(tmpBase++);
objects->addToken(OCODE_SET_TEMP, tmpB);
objects->addToken(OCODE_SET_TEMP, tmpA);
objects->addToken(OCODE_GET_TEMP, tmpA);
objects->addToken(OCODE_GET_TEMP, tmpB);
}
}
doSet(objects, src, typeL, tmpBase);
if (dst->type != VariableData::MT_VOID)
{
// MT_ARRAY addressing.
if(src->type == VariableData::MT_ARRAY)
doSetBaseGet(objects, src, NULL, NULL);
else
doSetBaseGet(objects, src, tmpA, tmpB);
make_objects_memcpy_post(objects, dst, tmp, typeL, context, pos);
}
}
/// Actual parameter access
// String access
bool CParameter::doSetValue(const string& strValue, uint32_t uiOffset, CParameterAccessContext& parameterAccessContext) const
{
return doSet(strValue, uiOffset, parameterAccessContext);
}
void execute(pruCPU *cpu) {
aluInstruction inst;
fmt2InstructionHeader fmt2Hdr;
while(1) {
int didBranch = 0;
cgc_memcpy(&inst, (aluInstruction *)&cpu->code[cpu->pc], 4);
switch(inst.opFmt) {
case 0b000:
switch(inst.aluOp) {
case ADD:
doAdd(cpu, inst);
break;
case ADC:
doAdc(cpu, inst);
break;
case SUB:
doSub(cpu, inst);
break;
case SUC:
doSuc(cpu, inst);
break;
case LSL:
doLsl(cpu, inst);
break;
case LSR:
doLsr(cpu, inst);
break;
case RSB:
doRsb(cpu, inst);
break;
case RSC:
doRsc(cpu, inst);
break;
case AND:
doAnd(cpu, inst);
break;
case OR:
doOr(cpu, inst);
break;
case XOR:
doXor(cpu, inst);
break;
case NOT:
doNot(cpu, inst);
break;
case MIN:
doMin(cpu, inst);
break;
case MAX:
doMax(cpu, inst);
break;
case CLR:
doClr(cpu, inst);
break;
case SET:
doSet(cpu, inst);
break;
}
break;
case 0b001:
cgc_memcpy(&fmt2Hdr, &inst, sizeof(fmt2Hdr));
switch(fmt2Hdr.subOp)
{
case JMP:
case JAL:
;
fmt2BranchInstruction fmt2Branch;
cgc_memcpy(&fmt2Branch, &inst, 4);
doBranch(cpu, fmt2Branch);
didBranch = 1;
break;
case LDI:
;
fmt2LdiInstruction fmt2Ldi;
cgc_memcpy(&fmt2Ldi, &inst, 4);
doLdi(cpu, fmt2Ldi);
break;
case LMBD:
;
fmt2LmbdInstruction fmt2Lmbd;
cgc_memcpy(&fmt2Lmbd, &inst, 4);
doLmbd(cpu, fmt2Lmbd);
break;
case HALT:
return;
case SCAN:
;
fmt2ScanInstruction fmt2Scan;
cgc_memcpy(&fmt2Scan, &inst, 4);
doScan(cpu, fmt2Scan);
break;
case SLP:
case RESERVED_1:
case RESERVED_2:
case RESERVED_3:
case RESERVED_4:
case RESERVED_5:
case RESERVED_6:
case RESERVED_7:
case RESERVED_8:
case RESERVED_9:
return;
}
break;
case 0b11:
;
fmtQatbInstruction qatbInstruction;
cgc_memcpy(&qatbInstruction, &inst, 4);
doQATB(cpu, qatbInstruction);
default:
return;
}
if(didBranch == 0)
cpu->pc++;
cpu->numExecuted++;
if(cpu->numExecuted >= MAX_INSNS)
return;
}
}
//-----------------------------------------------------------------------
void ParamCommand::doCopy(void* target, const void* source)
{
// Default implementation just get/set, derived class should be implement
// their special case version for effective (i.e. avoid string conversion).
doSet(target, doGet(source));
}
int main()
{
int i;
char* argv[8];
int argc;
printf_register(serial_putchar);
printf("waiting...");
// Wait a short while
for(i = 0; i < 10000; ++i)
asm volatile ("nop");
printf("configuring...");
i2c_init();
argv[0] = "1";
argc = 1;
doConfig(argv, argc);
printf("done.\n");
while (1)
{
printf("\n> ");
argc = readcmd(argv, 8);
printf("\r\n> ");
if(argc > 0)
{
switch(argv[0][0])
{
case 'S':
doSet(argv, argc);
break;
case 'G':
doGet(argv, argc);
break;
case 'R':
doResult(argv, argc);
break;
case 'W':
doWrite(argv, argc);
break;
case 'X':
doRead(argv, argc);
break;
case 'Z':
doStatus(argv, argc);
break;
case 'I':
switch(argv[0][1])
{
case 'I':
i2c_init();
break;
case 'W':
doI2CWrite(argv, argc);
break;
case 'R':
doI2CRead(argv, argc);
break;
case 'C':
doConfig(argv, argc);
break;
}
break;
}
}
}
}
