IMPLEMENT
bool Uart::startup(Address _port, int __irq)
{
port = _port;
_irq = __irq;
Proc::Status o = Proc::cli_save();
if (!valid())
{
Proc::sti_restore(o);
fail();
return false;
}
ier(Base_ier_bits);/* disable all rs-232 interrupts */
mcr(0x0b); /* out2, rts, and dtr enabled */
fcr(1); /* enable fifo */
fcr(0x07); /* clear rcv xmit fifo */
fcr(1); /* enable fifo */
lcr(0); /* clear line control register */
/* clearall interrupts */
/*read*/ msr(); /* IRQID 0*/
/*read*/ iir(); /* IRQID 1*/
/*read*/ trb(); /* IRQID 2*/
/*read*/ lsr(); /* IRQID 3*/
while(lsr() & 1/*DATA READY*/) /*read*/ trb();
Proc::sti_restore(o);
return true;
}
static void hposn(void) {
unsigned char msktbl[]={0x81,0x82,0x84,0x88,0x90,0xA0,0xC0};
// F411
ram[HGR_Y]=a;
ram[HGR_X]=x;
ram[HGR_X+1]=y;
pha();
a=a&0xC0;
ram[GBASL]=a;
lsr();
lsr();
a=a|ram[GBASL];
ram[GBASL]=a;
pla();
// F423
ram[GBASH]=a;
asl();
asl();
asl();
rol_mem(GBASH);
asl();
rol_mem(GBASH);
asl();
ror_mem(GBASL);
lda(GBASH);
a=a&0x1f;
a=a|ram[HGR_PAGE];
ram[GBASH]=a;
// F438
a=x;
cpy(0);
if (z==1) goto hposn_2;
y=35;
adc(4);
hposn_1:
iny();
// f442
hposn_2:
sbc(7);
if (c==1) goto hposn_1;
ram[HGR_HORIZ]=y;
x=a;
a=msktbl[(x-0x100)+7]; // LDA MSKTBL-$100+7,X BIT MASK
// MSKTBL=F5B8
ram[HMASK]=a;
a=y;
lsr();
a=ram[HGR_COLOR];
ram[HGR_BITS]=a;
if (c) color_shift();
}
// *********************************************************************************************************
void CDisplayerLua::CToLua::executeHandler(const CLuaString &eventName, int numArgs)
{
CLuaState &ls = *getLua();
CLuaStackRestorer lsr(&ls, ls.getTop() - numArgs);
//
if (!_LuaTable.isValid()) return; // init failed
if (_LuaTable[eventName].isNil()) return; // event not handled
static volatile bool dumpStackWanted = false;
if (dumpStackWanted) ls.dumpStack();
_LuaTable[eventName].push();
if (dumpStackWanted) ls.dumpStack();
// put method before its args
ls.insert(- numArgs - 1);
if (dumpStackWanted) ls.dumpStack();
// this is a method call
_LuaTable.push();
if (dumpStackWanted) ls.dumpStack();
ls.insert(- numArgs - 1);
if (dumpStackWanted) ls.dumpStack();
// First arg always is the instance being displayed
if (getEnclosing())
getEnclosing()->getDisplayedInstance()->getLuaProjection().push();
ls.insert(- numArgs - 1);
if (dumpStackWanted) ls.dumpStack();
CLuaIHM::executeFunctionOnStack(*_LuaTable.getLuaState(), numArgs + 2, 0);
if (dumpStackWanted) ls.dumpStack();
}
int main(){
int n, i, k, pos;
int *a;
time_t t;
if(!scanf("%d", &n) || n<=0)
err();
a = (int*) malloc(sizeof(int)*(n+1));
for(i=1;i<=n;i++){
if(!scanf("%d", &a[i]))
err();
}
if(!scanf("%d", &k))
err();
t = time(NULL);
pos = lsr(a, 1, n, k);
t = time(NULL) - t;
printf("Position : %d\n", pos);
printf("Running time : %f\n", (float)t/1000.0);
return 0;
}
int lsr(int A[], int p, int r, int k){
if(p > r)
return -1;
else{
if(A[p] == k)
return p;
else
lsr(A, p+1, r, k);
}
}
void ARMCore::thumbDataLo(uint4 opcode, uint3 ird, uint3 irm) {
auto &rd = r[ird], rm = r[irm];
r[15] += 2;
if(opcode == 2) { SOut r = lsl(rd, rm); bitf(true, rd = r, r); } // lsls
else if(opcode == 3) { SOut r = lsr(rd, rm); bitf(true, rd = r, r); } // lsrs
else if(opcode == 4) { SOut r = asr(rd, rm); bitf(true, rd = r, r); } // asrs
else if(opcode == 7) { SOut r = ror(rd, rm); bitf(true, rd = r, r); } // rors
else if(opcode == 9) sumf(true, rd = -rm, 0, ~rm); // negs
else if(opcode == 13) bitf(true, rd = rm * rd, {rm*rd, Cf}); // muls
else alu(2*opcode+1, rd, rd, {rm,Cf}); // others are same as ARM
}
static char * LSR2() {
//test LSR and save to memory address
CPU *c = getCPU();
uint16_t address = 0xCFEE;
int8_t operand = 0xFF;
OP_CODE_INFO *o = getOP_CODE_INFO(operand,address,modeAccumulator);
lsr(c,o);
int8_t memVal = read(c,address);
int8_t accumVal = getRegByte(c,ACCUM);
mu_assert("LSR2 err, memVal != 0", memVal == 0);
mu_assert("LSR2 err, accumVal != 0x7F", accumVal == 0x7F);
mu_run_test_with_args(testRegStatus,c,"00100001",
" NVUBDIZC NVUBDIZC\nLSR2 err, %s != %s");
freeOP_CODE_INFO(o);
free(c);
return 0;
}
void armv7a::ror_c(bits* result, uint32_t* carry_out, const bits& x, uint32_t shift)
{
//pseudo_assert(shift != 0, "ror_c assert error");
//pseudo_assert(shift < 32, "ror_c assert error"); //hit, but no need?
if(shift == 0)
{
(*result) = x;
*carry_out = 0;
}
else
{
uint32_t m = shift % x.n;
bits r1, r2;
lsr(&r1, x, m);
lsl(&r2, x, x.n - m);
result->val = r1.val | r2.val;
result->n = x.n;
printd(d_inst, "x=%X:%d shift:%d lsr_r1:%X lsr_r2:%X result:%X, result.n:%d", x.val, x.n, shift, r1.val, r2.val, result->val, result->n);
*carry_out = (*result)(x.n - 1);
}
}
// Returns the next random number based on seeds
// and updates the seeds accordingly.
dodBYTE RNG::RANDOM()
{
int x, y;
dodBYTE a, b;
carry = 0;
for (x = 8; x != 0; --x)
{
b = 0;
a = (SEED[2] & 0xE1);
for (y = 8; y != 0; --y)
{
a = lsl(a);
if (carry != 0)
++b;
}
b = lsr(b);
SEED[0] = rol(SEED[0]);
SEED[1] = rol(SEED[1]);
SEED[2] = rol(SEED[2]);
}
return SEED[0];
}
static void move_left_or_right(void) {
// F465
if (n==0) goto move_right;
a=ram[HMASK];
lsr();
if (c==1) goto lr_2;
a=a^0xc0;
lr_1:
ram[HMASK]=a;
return;
lr_2:
dey();
if (n==0) goto lr_3;
y=39;
lr_3:
a=0xc0;
lr_4:
ram[HMASK]=a;
ram[HGR_HORIZ]=y;
a=ram[HGR_BITS];
color_shift();
return;
move_right:
a=ram[HMASK];
asl();
a=a^0x80;
if (a&0x80) goto lr_1;
a=0x81;
iny();
cpy(40);
if (c==0) goto lr_4;
y=0;
goto lr_4;
}
int main(int argc, char **argv) {
int yy;
grsim_init();
gr();
yy=0;
printf("****yy=%d\n",yy);
y=yy; // ldy #0
x=3; // ldx #3
L1:
ram[0x3c]=x; // stx $3c
a=x; // txa
asl(); // asl
bit_mem(0x3c); // bit $3c
if (z==1) goto L3; // beq L3
ora_mem(0x3c); // ora $3c
eor(0xff); // eor #$ff
and(0x7e); // and #$7e
L2:
if (c==1) goto L3; // bcs L3
lsr(); // lsr
if (z==0) goto L2; // bne L2
a=y; // tya
printf("%x=%x\n",x,a); // sta nibtbl, x
y++; // iny
L3:
x++; // inx
if (!(x&0x80)) goto L1; // bpl L1
return 0;
}
void execALU(){
switch(controle_alu.op_code){
case 1: add(); break;
case 2: addinc(); break;
case 3: and(); break;
case 4: andnota(); break;
case 5: asl(); break;
case 6: asr(); break;
case 7: deca(); break;
case 8: inca(); break;
case 9: j(); break;
case 10: jal(); break;
case 11: jf(); break;
case 12: jr(); break;
case 13: jt(); break;
case 14: lch(); break;
case 15: lcl(); break;
case 16: load(); break;
case 17: loadlit(); break;
case 18: lsl(); break;
case 19: lsr(); break;
case 20: nand(); break;
case 21: nor(); break;
case 22: ones(); break;
case 23: or(); break;
case 24: ornotb(); break;
case 25: passa(); break;
case 26: passnota(); break;
case 27: store(); break;
case 28: sub(); break;
case 29: subdec(); break;
case 30: xnor(); break;
case 31: xor(); break;
case 32: zeros(); break;
}
}
address JNI_FastGetField::generate_fast_get_int_field0(BasicType type) {
const char *name;
switch (type) {
case T_BOOLEAN: name = "jni_fast_GetBooleanField"; break;
case T_BYTE: name = "jni_fast_GetByteField"; break;
case T_CHAR: name = "jni_fast_GetCharField"; break;
case T_SHORT: name = "jni_fast_GetShortField"; break;
case T_INT: name = "jni_fast_GetIntField"; break;
case T_LONG: name = "jni_fast_GetLongField"; break;
case T_FLOAT: name = "jni_fast_GetFloatField"; break;
case T_DOUBLE: name = "jni_fast_GetDoubleField"; break;
default: ShouldNotReachHere();
}
ResourceMark rm;
BufferBlob* blob = BufferBlob::create(name, BUFFER_SIZE);
CodeBuffer cbuf(blob);
MacroAssembler* masm = new MacroAssembler(&cbuf);
address fast_entry = __ pc();
Label slow;
unsigned long offset;
__ adrp(rcounter_addr,
SafepointSynchronize::safepoint_counter_addr(), offset);
Address safepoint_counter_addr(rcounter_addr, offset);
__ ldrw(rcounter, safepoint_counter_addr);
__ andw(rscratch1, rcounter, 1);
__ cbnzw(rscratch1, slow);
__ eor(robj, c_rarg1, rcounter);
__ eor(robj, robj, rcounter); // obj, since
// robj ^ rcounter ^ rcounter == robj
// robj is address dependent on rcounter.
__ ldr(robj, Address(robj, 0)); // *obj
__ lsr(roffset, c_rarg2, 2); // offset
assert(count < LIST_CAPACITY, "LIST_CAPACITY too small");
speculative_load_pclist[count] = __ pc(); // Used by the segfault handler
switch (type) {
case T_BOOLEAN: __ ldrb (result, Address(robj, roffset)); break;
case T_BYTE: __ ldrsb (result, Address(robj, roffset)); break;
case T_CHAR: __ ldrh (result, Address(robj, roffset)); break;
case T_SHORT: __ ldrsh (result, Address(robj, roffset)); break;
case T_FLOAT: __ ldrw (result, Address(robj, roffset)); break;
case T_INT: __ ldrsw (result, Address(robj, roffset)); break;
case T_DOUBLE:
case T_LONG: __ ldr (result, Address(robj, roffset)); break;
default: ShouldNotReachHere();
}
// counter_addr is address dependent on result.
__ eor(rcounter_addr, rcounter_addr, result);
__ eor(rcounter_addr, rcounter_addr, result);
__ ldrw(rscratch1, safepoint_counter_addr);
__ cmpw(rcounter, rscratch1);
__ br (Assembler::NE, slow);
switch (type) {
case T_FLOAT: __ fmovs(v0, result); break;
case T_DOUBLE: __ fmovd(v0, result); break;
default: __ mov(r0, result); break;
}
__ ret(lr);
slowcase_entry_pclist[count++] = __ pc();
__ bind(slow);
address slow_case_addr;
switch (type) {
case T_BOOLEAN: slow_case_addr = jni_GetBooleanField_addr(); break;
case T_BYTE: slow_case_addr = jni_GetByteField_addr(); break;
case T_CHAR: slow_case_addr = jni_GetCharField_addr(); break;
case T_SHORT: slow_case_addr = jni_GetShortField_addr(); break;
case T_INT: slow_case_addr = jni_GetIntField_addr(); break;
case T_LONG: slow_case_addr = jni_GetLongField_addr(); break;
case T_FLOAT: slow_case_addr = jni_GetFloatField_addr(); break;
case T_DOUBLE: slow_case_addr = jni_GetDoubleField_addr(); break;
default: ShouldNotReachHere();
}
{
__ enter();
__ lea(rscratch1, ExternalAddress(slow_case_addr));
__ blr(rscratch1);
__ maybe_isb();
__ leave();
__ ret(lr);
}
__ flush ();
return fast_entry;
}
//***************************************************************
CInstance *CAutoGroup::getGroupingCandidate()
{
//H_AUTO(R2_CAutoGroup_getGroupingCandidate)
if (!_AutoGroupEnabled) return NULL;
// if I'm a bot object, don't auto-group
CObject *palEntry = getEditor().getDMC().getPaletteElement(_PaletteEntry);
if (!palEntry || !palEntry->isTable()) return NULL;
if (getNumber(palEntry, "IsBotObject") == 1) return NULL;
// auto-group feature
// look in default feature and sort objects by distance
CInstance *defaultFeatInst = getEditor().getDefaultFeature(getEditor().getCurrentAct());
CInstance *baseDefaultFeatInst = getEditor().getDefaultFeature(getEditor().getBaseAct());
if (!defaultFeatInst || !baseDefaultFeatInst)
{
nlwarning("Can't access to Default Features"); // syntax error in lua was making the client crash
return NULL; //In this case there is no default features
}
CObjectTable *defaultFeat = defaultFeatInst->getObjectTable();
CObjectTable *baseDefaultFeat = baseDefaultFeatInst->getObjectTable();
CObject *components = defaultFeat->getAttr("Components");
CObject *baseComponents = baseDefaultFeat->getAttr("Components");
if (!components || !baseComponents || !palEntry->isTable()) return NULL;
_SortedComponents.clear();
for (uint k = 0; k < (components->getSize()+baseComponents->getSize()); ++k)
{
CObject *obj = NULL;
if(k<components->getSize())
obj = components->getValue(k);
else
obj = baseComponents->getValue(k - components->getSize());
CInstance *inst = getEditor().getInstanceFromObject(obj);
if (!inst)
{
nlwarning("Error: can not find create Instance of an object.");
continue;
}
CDisplayerVisual *dv = inst->getDisplayerVisual();
if (!dv) continue;
CComponentSort cs;
cs.Dist = (_TestPos - dv->getWorldPos()).norm();
if (cs.Dist > CV_AutoGroupMaxDist.get()) continue;
cs.Instance = inst;
_SortedComponents.push_back(cs);
}
// iterate through other features
CObjectTable *act = getEditor().getCurrentAct()->getObjectTable();
CObjectTable *baseAct = getEditor().getBaseAct()->getObjectTable();
if (!act || !baseAct) return NULL;
CObject *features = act->getAttr("Features");
CObject *baseFeatures = baseAct->getAttr("Features");
if (!features || !baseFeatures) return NULL;
for (uint k = 0; k < (features->getSize()+baseFeatures->getSize()); ++k)
{
CObject *obj = NULL;
if(k<features->getSize())
obj = features->getValue(k);
else
obj = baseFeatures->getValue(k - features->getSize());
CInstance *inst = getEditor().getInstanceFromObject(obj);
CDisplayerVisual *dv = inst->getDisplayerVisual();
if (!dv) continue;
if (inst->isKindOf("NpcGrpFeature"))
{
if (dv->getNumSons() == 0) continue;
CComponentSort cs;
cs.Dist = (_TestPos - dv->getSon(0)->getWorldPos()).norm();
if (cs.Dist > CV_AutoGroupMaxDist.get()) continue;
cs.Instance = inst;
_SortedComponents.push_back(cs);
}
}
std::sort(_SortedComponents.begin(), _SortedComponents.end());
CLuaState &ls = getEditor().getLua();
const CObject *categoryObj = getObject(palEntry, "Category");
if (!categoryObj)
{
nlwarning("No 'Category' field in palEntry '%s'", _PaletteEntry.c_str());
return NULL;
}
if (!categoryObj->isString()) return NULL;
std::string category = categoryObj->toString();
//
const CObject *subCategoryObj = getObject(palEntry, "SubCategory");
std::string subCategory;
if (subCategoryObj && subCategoryObj->isString())
{
subCategory = subCategoryObj->toString();
}
else
{
//nlwarning("No 'SubCategory' field in palEntry '%s'", paletteEntry.c_str());
}
//
if (category.empty()) return NULL;
for(uint k = 0; k < _SortedComponents.size(); ++k)
{
CLuaStackRestorer lsr(&ls, 0);
if (_SortedComponents[k].Instance->isKindOf("Npc"))
{
_SortedComponents[k].Instance->getLuaProjection().callMethodByNameNoThrow("isPlant", 0, 1);
if (ls.toBoolean(-1) == true) continue;
_SortedComponents[k].Instance->getLuaProjection().callMethodByNameNoThrow("isBotObject", 0, 1);
if (ls.toBoolean(-1) == true) continue;
}
else if (!_SortedComponents[k].Instance->isKindOf("NpcGrpFeature"))
{
continue;
}
std::string destCategory;
if (_SortedComponents[k].Instance->getLuaProjection().callMethodByNameNoThrow("getCategory", 0, 1))
{
destCategory = ls.toString(-1);
ls.pop();
}
if (destCategory != category) continue;
//
std::string destSubCategory;
if (_SortedComponents[k].Instance->getLuaProjection().callMethodByNameNoThrow("getSubCategory", 0, 1))
{
if (ls.isString(-1))
{
destSubCategory = ls.toString(-1);
}
ls.pop();
}
if (destSubCategory != subCategory) continue;
// good candidate
return _SortedComponents[k].Instance;
}
return NULL;
}