void index_add(struct index *ls, struct record *lr)
{
assert(lr != NULL);
assert(has_space(ls));
ls->record[ls->entries++] = lr;
}
unsigned g65816_device::g65816i_read_8_vector(unsigned address)
{
CLOCKS -= (bus_5A22_cycle_burst(address));
if (has_space(AS_VECTORS))
return space(AS_VECTORS).read_byte(address & 0x001f);
else
return g65816_read_8_immediate(address);
}
static bool dig_room(int y, int x, int radius, bool radial) {
if (!has_space(y,x,radius))
return false;
for (int yy=y-radius; yy<=y+radius; yy++)
for (int xx=x-radius; xx<=x+radius; xx++)
if ((radial&&in_range(y,x,yy,xx,radius)) || !radial)
tile_m[yy][xx].type=FLOOR;
return true;
}
int
expand_region(vm_seg_t *seg, vm_region_t *region, vm_size_t size, int m,
void *_newaddr)
{
vm_addr_t newaddr;
if (m == EXPAND_UP) {
vm_region_t *nextreg = list_next(&seg->regions, region);
newaddr = region->end;
if (nextreg == NULL) {
// rozszerzając region rozszerzamy segment
if (!has_space(seg,size)) return -1;
seg->end += size;
seg->size += size;
}
region->end += size;
region->size += size;
if (nextreg && region->end == nextreg->begin) {
region->end += nextreg->size;
region->size += nextreg->size;
list_remove(&seg->regions, nextreg);
}
} else {
vm_region_t *prevreg = list_prev(&seg->regions, region);
if (prevreg == NULL) {
if (!has_space(seg,size)) return -1;
seg->base -= size;
seg->size += size;
}
region->begin -= size;
region->size += size;
newaddr = region->begin;
if (prevreg && prevreg->end == region->begin) {
region->begin -= prevreg->size;
region->size += prevreg->size;
list_remove(&seg->regions, prevreg);
}
}
vm_addr_t *na = _newaddr;
*na = newaddr;
return 0;
}
static void ICACHE_FLASH_ATTR user_rx_task(os_event_t *events) {
if(events->sig == 0){
uint8 fifo_len = (READ_PERI_REG(UART_STATUS(UART0))>>UART_RXFIFO_CNT_S)&UART_RXFIFO_CNT;
uint8 d_tmp = 0;
uint8 idx=0;
for(idx=0;idx<fifo_len;idx++) {
d_tmp = READ_PERI_REG(UART_FIFO(UART0)) & 0xFF;
uart_tx_one_char(UART0, d_tmp);
if( has_space() ) {
serial_buffer[putpos++ & POS_MASK] = d_tmp;
}
}
WRITE_PERI_REG(UART_INT_CLR(UART0), UART_RXFIFO_FULL_INT_CLR|UART_RXFIFO_TOUT_INT_CLR);
uart_rx_intr_enable(UART0);
if( serial_datalen() && user_rx_callback ) {
user_rx_callback(serial_datalen());
}
}
struct record* index_insert(struct index *ls, struct record *item,
int sort)
{
bool found;
size_t z;
z = bin_search(ls->record, ls->entries, item, sort, &found);
if (found)
return ls->record[z];
assert(has_space(ls));
memmove(ls->record + z + 1, ls->record + z,
sizeof(struct record*) * (ls->entries - z));
ls->record[z] = item;
ls->entries++;
return item;
}
int set_add(set *ptr, const void *element, size_t len) {
CHECK_NOT_NULL(ptr);
CHECK_NOT_NULL(element);
CHECK_POSITIVE(len);
if (!has_space(ptr, len)) return ERR_MEM;
size_t hash = ptr->hasher(element, len);
for (unsigned int i=0; i < ptr->size; i++) {
size_t index = find_index(hash, i, ptr->size);
if (!ptr->map[index]) { // insert
ptr->map[index] = ptr->tail - ptr->heap;
memcpy(ptr->tail, element, len);
ptr->tail += len;
return SUCCESS;
}
}
return ERR_SIZE;
}
/**
* 加载配置文件
*/
void init_conf(){
buffer_t *rbuf=alloc_buffer(CONF_READ_BUF);
int fd=open_conf_file();
enum PARSE_STATE status=RAW;
config_module_t *current_module;
command_t *current_command;
char_t *module_name=init_char();
char_t *command_key=init_char();
char_t *command_value=init_char();
while(1){
if(has_space(rbuf)){
intptr_t count=read(fd,rbuf->data+rbuf->limit,rbuf->size-rbuf->limit);
if(count<=0){
goto CONFIG_END;
}
rbuf->limit+=count;
}
while(has_remaining(rbuf)){
char c=*(rbuf->data+rbuf->current);
rbuf->current+=1;
if(status==RAW&&c==brace_start){
status=MODULE_START;
}else if(status==MODULE_START&&!char_is_special(c)){
if(c==brace_start){
add_terminal(module_name);
current_module=find_config_module(module_name);
if(current_module==NULL){
my_log(ERROR,"config error,please check\n");
goto CONFIG_END;
}else{
status=FIND_COMMAND_KEY;
}
}else if(c==brace_end){
goto CONFIG_END;
}else{
add_char(module_name,c);
}
}else if(status==FIND_COMMAND_KEY&&!char_is_special(c)){
if(c==brace_end){
current_module=NULL;
reset_char(module_name);
status=MODULE_START;
}else{
add_char(command_key,c);
status=COMMAND_KEY_START;
}
}else if(status==COMMAND_KEY_START){
if(!char_is_special(c)){
add_char(command_key,c);
}else{
add_terminal(command_key);
current_command=find_config_command(command_key,current_module);
if(current_command==NULL){
my_log(ERROR,"config error,please check\n");
goto CONFIG_END;
}
status=COMMAND_VALUE_START;
}
}else if(status==COMMAND_VALUE_START&&!char_is_special(c)){
if(c!=semicolon){
add_char(command_value,c);
}else{
add_terminal(command_value);
current_command->set_value(command_value);
current_command=NULL;
reset_char(command_value);
reset_char(command_key);
status=FIND_COMMAND_KEY;
}
}
}
}
CONFIG_END:
destroy_buffer(rbuf);
}
void m6809_base_device::device_start()
{
if (!m_mintf)
m_mintf = new mi_default;
m_mintf->m_program = &space(AS_PROGRAM);
m_mintf->m_sprogram = has_space(AS_DECRYPTED_OPCODES) ? &space(AS_DECRYPTED_OPCODES) : m_mintf->m_program;
m_mintf->m_direct = &m_mintf->m_program->direct();
m_mintf->m_sdirect = &m_mintf->m_sprogram->direct();
m_lic_func.resolve_safe();
// register our state for the debugger
state_add(STATE_GENPC, "GENPC", m_pc.w).noshow();
state_add(STATE_GENPCBASE, "GENPCBASE", m_ppc.w).noshow();
state_add(STATE_GENFLAGS, "GENFLAGS", m_cc).callimport().callexport().formatstr("%8s").noshow();
state_add(M6809_PC, "PC", m_pc.w).mask(0xffff);
state_add(M6809_S, "S", m_s.w).mask(0xffff);
state_add(M6809_CC, "CC", m_cc).mask(0xff);
state_add(M6809_U, "U", m_u.w).mask(0xffff);
state_add(M6809_A, "A", m_d.b.h).mask(0xff);
state_add(M6809_B, "B", m_d.b.l).mask(0xff);
state_add(M6809_X, "X", m_x.w).mask(0xffff);
state_add(M6809_Y, "Y", m_y.w).mask(0xffff);
state_add(M6809_DP, "DP", m_dp).mask(0xff);
// initialize variables
m_cc = 0;
m_pc.w = 0;
m_s.w = 0;
m_u.w = 0;
m_d.w = 0;
m_x.w = 0;
m_y.w = 0;
m_dp = 0;
m_reg = 0;
m_reg8 = nullptr;
m_reg16 = nullptr;
// setup regtable
save_item(NAME(m_pc.w));
save_item(NAME(m_ppc.w));
save_item(NAME(m_d.w));
save_item(NAME(m_dp));
save_item(NAME(m_u.w));
save_item(NAME(m_s.w));
save_item(NAME(m_x.w));
save_item(NAME(m_y.w));
save_item(NAME(m_cc));
save_item(NAME(m_temp.w));
save_item(NAME(m_opcode));
save_item(NAME(m_nmi_asserted));
save_item(NAME(m_nmi_line));
save_item(NAME(m_firq_line));
save_item(NAME(m_irq_line));
save_item(NAME(m_lds_encountered));
save_item(NAME(m_state));
save_item(NAME(m_ea.w));
save_item(NAME(m_addressing_mode));
save_item(NAME(m_reg));
save_item(NAME(m_cond));
// set our instruction counter
m_icountptr = &m_icount;
m_icount = 0;
}
