int
open_dns_from_host(char *host, int port, int addr_family, int flags)
{
struct sockaddr_storage addr;
int addrlen;
addrlen = get_addr(host, port, addr_family, flags, &addr);
if (addrlen < 0)
return addrlen;
return open_dns(&addr, addrlen);
}
SWITCH_DECLARE(const char *) switch_get_addr(char *buf, switch_size_t len, switch_sockaddr_t *in)
{
if (!in) {
return SWITCH_BLANK_STRING;
}
if (in->family == AF_INET) {
return get_addr(buf, len, (struct sockaddr *) &in->sa, in->salen);
}
return get_addr6(buf, len, (struct sockaddr_in6 *) &in->sa, in->salen);
}
static void srcover_rect(const GBitmap& bitmap, const GIRect& rect, const GPixel& color) {
unsigned a = GPixel_GetA(color);
if (0 == a) {
return;
}
RowProc proc = (255 == a) ? src_row : srcover_row;
const int width = rect.width();
for (int y = rect.top(); y < rect.bottom(); ++y) {
proc(get_addr(bitmap, rect.x(), y), width, color);
}
}
static int valid_ips( struct sockaddr_storage *their_addr )
{
char remoteIP[2][INET6_ADDRSTRLEN] = { "", "" };
inet_ntop(their_addr[0].ss_family,
get_addr(u[0].addr),
remoteIP[0], INET6_ADDRSTRLEN);
inet_ntop(their_addr[1].ss_family,
get_addr(u[0].addr),
remoteIP[1], INET6_ADDRSTRLEN);
if ( strcmp( remoteIP[0], remoteIP[1] ) != 0 )
{
log_printf("*** Warning: Got two connections from different sources. ***\n");
log_printf("*** %s :: %s ***\n", remoteIP[0], remoteIP[1]);
return -1;
}
log_message(remoteIP[1]);
return 0;
}
void print_index(std::string& idx_file_name)
{
glib::CharStr contents;
gsize cont_len;
if(!g_file_get_contents(idx_file_name.c_str(), get_addr(contents), &cont_len, NULL)) {
std::cerr << "Unable to open file " << idx_file_name << std::endl;
return;
}
if(!quiet_mode) {
if(syn_file)
std::cout << " INDEX KEY" << std::endl;
else
std::cout << " OFFSET SIZE KEY" << std::endl;
}
gchar *p1 = get_impl(contents);
gchar *end = p1+cont_len;
int rec_no = 0;
const gchar* key;
if(syn_file) {
guint32 index;
while(p1<end) {
key = p1;
p1 += strlen(p1) + 1;
index = g_ntohl(*reinterpret_cast<guint32*>(p1));
p1 += sizeof(guint32);
++rec_no;
if(key_only)
std::cout << key << std::endl;
else
std::cout << std::setw(10) << index << " " << key << std::endl;
}
} else {
guint32 offset, size;
while(p1<end) {
key = p1;
p1 += strlen(p1) + 1;
offset = g_ntohl(*reinterpret_cast<guint32*>(p1));
p1 += sizeof(guint32);
size = g_ntohl(*reinterpret_cast<guint32*>(p1));
p1 += sizeof(guint32);
++rec_no;
if(key_only)
std::cout << key << std::endl;
else
std::cout << std::setw(10) << offset << " " << std::setw(10) << size << " "<< key << std::endl;
}
}
if(!quiet_mode)
std::cout << "number of entries: " << rec_no << std::endl;
}
DRESULT disk_write (BYTE pdrv, const BYTE* buff, DWORD sector, UINT count)
{
DRESULT result;
if (pdrv >= N_PDRV)
{
result = RES_ERROR;
}
else if (!pdrv_data[pdrv].initialized)
{
result = RES_NOTRDY;
}
else if (!pdrv_data[pdrv].present)
{
result = RES_ERROR;
}
else if (pdrv_data[pdrv].write_protected)
{
result = RES_ERROR;
}
else
{
while (count > 0)
{
uint32_t addr;
int write_res;
addr = get_addr(sector, pdrv_data[pdrv].byte_addressable);
write_res = sd_write_single_block(addr, buff);
if (write_res != 0)
{
break;
}
buff += SD_SECTOR_SIZE;
sector++;
count--;
}
if (count > 0)
{
result = RES_ERROR;
}
else
{
result = RES_OK;
}
}
return result;
}
//TODO remove it
void EP::gen_inst(std::vector<Instruction*>& inst_vec,bool use_cache)
{
uint pc = get_addr();
for (size_t i = 0;i < _code_num;i++)
{
code_t code = _code[i];
//Instruction *pInst = new Instruction(code, pc & 0xFFFFFFE0,pc);
// Instruction *inst =
// InstFetchController::fetch_inst(code,pc & 0xFFFFFFE0,pc,use_cache);
//inst_vec.push_back(inst);
pc += 4;
}
}
void *mem_pool(size_t size)
{
char *ret;
char *last_mm; //当前块
char *new_mm;
char *p;
if (head == NULL) { /*第一次申请空间`*/
head = mk_smm(size);
return get_addr(head, size);
}
/*获取此内存池链表的最后一个的首地址给 cur_mm*/
if (((memctl_t *)head)->next) { /*不止一次申请过空间*/
for (p = head; ((memctl_t *)p)->next; p =(char *)((memctl_t *)p)->next) { /*每个池中都检测能否放下此 size 大小*/
if (((memctl_t *)p)->left >= size) { /*此碎片能放下此 size */
return get_addr(p, size);
} /*此碎片放不下,继续向下走*/
}
last_mm = p;
} else /*只申请过一次空间*/
last_mm = head;
/*从当前内存池链表的末尾判断能否放下，还是需要新申请空间*/
if (((memctl_t *)last_mm)->left >= size) { /*能放得下*/
ret = get_addr(last_mm, size);
} else { /*放不下，需要另外申请空间*/
new_mm = mk_smm(size);
((memctl_t *)last_mm)->next = (memctl_t *)new_mm;
ret = get_addr(new_mm, size);
}
return ret;
}
void
_init(void)
{
DP(("hello world"));
_socket = dlwrap("socket");
_sock.domain = get_u16("FORCE_BIND_SOCKDOM", AF_INET);
_sock.type = get_u16("FORCE_BIND_SOCKTYPE", SOCK_DGRAM);
_sock.proto = get_u16("FORCE_BIND_SOCKPROTO", IPPROTO_UDP);
get_addr(&_saddr, "FORCE_BIND_ADDR", "127.0.0.1\0\0\0\0\0\0");
get_port(&_saddr, "FORCE_BIND_PORT");
_saddr.sin_family = _sock.domain;
}
/*
* copy the data to the backup osd
* return the error information
*/
void *do_copy(void *copy_arg)
{
PDEBUG("[do_copy thread]\n");
static int ret = 0;
co_write_in *arg = (co_write_in*)copy_arg;
co_write_out res;
res.err = 0;
char ipp[IP_BUF];
get_addr(ipp, arg->ip);
arg->ip = 0;
ret = copy_data(arg, &res, ipp);
return (void*)&ret;
}
static void incoming_arp(struct clip_vcc *clip_vcc, struct atmarphdr *hdr,
int len)
{
void *spa,*tpa;
u32 src_ip,tgt_ip;
u8 *here;
if (len < hdr->data - (u8 *)hdr)
{
printk(KERN_WARNING "got truncated ARP packet (%d bytes)\n", len);
return;
}
if (hdr->ar_hrd != htons(ARPHRD_ATM))
{
printk(KERN_WARNING "unknown hw protocol 0x%04x", ntohs(hdr->ar_hrd));
return;
}
if (hdr->ar_pro != htons(ETH_P_IP))
{
printk(KERN_WARNING "unknown upper protocol 0x%04x",
ntohs(hdr->ar_pro));
return;
}
if (!(hdr->ar_shtl & TL_LEN)) hdr->ar_shtl = 0; /* paranoia */
if (!(hdr->ar_thtl & TL_LEN)) hdr->ar_thtl = 0;
here = hdr->data;
get_addr(&here, hdr->ar_shtl & TL_LEN);
get_addr(&here, hdr->ar_sstl & TL_LEN);
spa = get_addr(&here, hdr->ar_spln);
get_addr(&here, hdr->ar_thtl & TL_LEN);
get_addr(&here, hdr->ar_tstl & TL_LEN);
tpa = get_addr(&here, hdr->ar_tpln);
if (here - (u8 *)hdr > len)
{
printk(KERN_WARNING "message too short (got %d, need %d)",len,
here - (u8 *)hdr);
return;
}
src_ip = get_ip(spa);
tgt_ip = get_ip(tpa);
switch (ntohs(hdr->ar_op)) {
case ARPOP_InREQUEST:
DPRINTK("got InARP_REQ");
if (!clip_learn(clip_vcc, src_ip))
clip_inarp_reply_send(clip_vcc->vcc, src_ip);
break;
case ARPOP_InREPLY:
DPRINTK("got InARP_REP");
clip_learn(clip_vcc, src_ip);
break;
default:
DPRINTK("unrecognized ARP op 0x%x", ntohs(hdr->ar_op));
}
}
int fdt_decode_sdmmc(const void *blob, int node, struct fdt_sdmmc *config)
{
config->reg = (struct tegra2_mmc *)get_addr(blob, node, "reg");
config->enabled = get_is_enabled(blob, node, 1);
config->periph_id = get_int(blob, node, "periph-id", -1);
config->width = get_int(blob, node, "width", -1);
config->removable = get_int(blob, node, "removable", 1);
if (config->periph_id == -1 || config->width == -1)
return -FDT_ERR_MISSING;
/* These GPIOs are optional */
decode_gpio(blob, node, "cd-gpio", &config->cd_gpio);
decode_gpio(blob, node, "wp-gpio", &config->wp_gpio);
decode_gpio(blob, node, "power-gpio", &config->power_gpio);
return 0;
}
int
open_tun(const char *tun_device)
{
char adapter[256];
char tapfile[512];
int tunfd;
struct sockaddr_storage localsock;
int localsock_len;
memset(adapter, 0, sizeof(adapter));
memset(if_name, 0, sizeof(if_name));
get_device(adapter, sizeof(adapter), tun_device);
if (strlen(adapter) == 0 || strlen(if_name) == 0) {
if (tun_device) {
warnx("No TAP adapters found. Try without -d.");
} else {
warnx("No TAP adapters found. Version 0801 and 0901 are supported.");
}
return -1;
}
fprintf(stderr, "Opening device %s\n", if_name);
snprintf(tapfile, sizeof(tapfile), "%s%s.tap", TAP_DEVICE_SPACE, adapter);
dev_handle = CreateFile(tapfile, GENERIC_WRITE | GENERIC_READ, 0, 0, OPEN_EXISTING, FILE_ATTRIBUTE_SYSTEM | FILE_FLAG_OVERLAPPED, NULL);
if (dev_handle == INVALID_HANDLE_VALUE) {
warnx("Could not open device!");
return -1;
}
/* Use a UDP connection to forward packets from tun,
* so we can still use select() in main code.
* A thread does blocking reads on tun device and
* sends data as udp to this socket */
localsock_len = get_addr("127.0.0.1", 55353, AF_INET, 0, &localsock);
tunfd = open_dns(&localsock, localsock_len);
data.tun = dev_handle;
memcpy(&(data.addr), &localsock, localsock_len);
data.addrlen = localsock_len;
CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)tun_reader, &data, 0, NULL);
return tunfd;
}
bool MapFile::open(const char *file_name, bool logerr, long file_size)
{
filename_ = file_name;
close();
size = file_size;
#ifdef HAVE_MMAP
if ((mmap_fd = ::open(file_name, O_RDONLY)) < 0) {
if (logerr)
g_warning(_("Can not open %s: %s\n"), file_name, strerror(errno));
else
g_info(_("Can not open %s: %s\n"), file_name, strerror(errno));
return false;
}
if (-1 == size) {
struct stat stat_info;
if (fstat(mmap_fd, &stat_info)==-1)
return false;
size = stat_info.st_size;
}
data = (char *)mmap(NULL, size, PROT_READ, MAP_SHARED, mmap_fd, 0);
if ((void *)data == (void *)(-1))
return false;
#elif defined(WIN32)
//TODO: rewirte to handle CreateFileA and CreateFileW cases
hFile = CreateFile(file_name, GENERIC_READ, 0, NULL, OPEN_ALWAYS,
FILE_ATTRIBUTE_NORMAL, 0);
if (-1==size)
size=GetFileSize(hFile, NULL);
hFileMap = CreateFileMapping(hFile, NULL, PAGE_READONLY, 0,
size, NULL);
data = (char *)MapViewOfFile(hFileMap, FILE_MAP_READ, 0, 0, size);
# else
gsize fsize;
if (!g_file_get_contents(file_name, get_addr(databuf_), &fsize, NULL))
return false;
size = fsize;
data = get_impl(databuf_);
#endif
cur = data;
end_of_file = data + size;
return true;
}
static int parse_encap_mpls(struct rtattr *rta, size_t len, int *argcp, char ***argvp)
{
inet_prefix addr;
int argc = *argcp;
char **argv = *argvp;
if (get_addr(&addr, *argv, AF_MPLS)) {
fprintf(stderr, "Error: an inet address is expected rather than \"%s\".\n", *argv);
exit(1);
}
rta_addattr_l(rta, len, MPLS_IPTUNNEL_DST, &addr.data,
addr.bytelen);
*argcp = argc;
*argvp = argv;
return 0;
}
static void trace_sock(int sockfd, const struct sockaddr *addr, socklen_t addrlen) {
debug("trace_sock %d");
Descriptor *d = get_descriptor(sockfd);
if (d == NULL) {
return;
}
char *addrstr = get_addr(addr, addrlen);
if (addrstr == NULL) {
/* It is not a type of socket we understand */
return;
}
debug("sock addr %s", addrstr);
if (d->path == NULL || strcmp(addrstr, d->path) != 0) {
/* This is here to handle the case where a socket is reused to connect
* to another address without being closed first. This happens, for example,
* with DNS lookups in curl.
*/
trace_close(sockfd);
/* Reset the descriptor */
d->type = DTYPE_NONE;
d->path = NULL;
d->bread = 0;
d->bwrite = 0;
d->nread = 0;
d->nwrite = 0;
d->bseek = 0;
d->nseek = 0;
char *temp = strdup(addrstr);
if (temp == NULL) {
printerr("strdup: %s\n", strerror(errno));
return;
}
d->type = DTYPE_SOCK;
d->path = temp;
}
}
int connect_to(char * host, char * port)
{
int sockfd;
struct addrinfo hints, *servinfo, *p;
int rv;
char s[INET6_ADDRSTRLEN];
memset(&hints, 0, sizeof hints);
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
printf("port:%s\n",port);
if ((rv = getaddrinfo(host, port, &hints, &servinfo)) != 0)
{
fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(rv));
return -1;
}
for(p = servinfo; p != NULL; p = p->ai_next)
{
if ((sockfd = socket(p->ai_family, p->ai_socktype,
p->ai_protocol)) == -1)
{
perror("client: socket");
continue;
}
if (connect(sockfd, p->ai_addr, p->ai_addrlen) == -1)
{
close(sockfd);
perror("client: connect");
continue;
}
break;
}
if (p == NULL)
{
fprintf(stderr, "client: failed to connect\n");
return -1;
}
inet_ntop(p->ai_family, get_addr((struct sockaddr *)p->ai_addr), s, sizeof s);
fprintf(stdout, "client: connecting to %s\n", s);
freeaddrinfo(servinfo);
return sockfd;
}
void ARMInstruction::decode_data_refs()
{
if ((m_opcode & 0x0c000000) == 0x04000000) {
int regN = (m_opcode >> 16) & 0xf;
//int regD = (m_opcode >> 12) & 0xf;
u32 offset = 0;
int IPUBWL = (m_opcode >> 20) & 0x3f;
if (regN != 15)
return;
if (IPUBWL & (1 << 5)) { // I -> not an immediate
return;
} else {
offset = m_opcode & 0xfff;
}
address_t base = get_addr() + 8;
address_t taddr;
if (IPUBWL & (1 << 4)) { // P
if (IPUBWL & (1 << 3)) // U
taddr = base + offset;
else
taddr = base - offset;
} else {
taddr = base;
}
if (IPUBWL & (1 << 0)) { // ldr
m_pcflags |= PCFLAG_DREF;
if (IPUBWL & (1 << 2)) // ldrb
m_pcflags |= PCFLAG_DSBYTE;
else
m_pcflags |= PCFLAG_DSWORD;
m_data_ref_addr = taddr;
}
}
/*---------------------------------------------------------------------*/
void sg2d_fill_pixel( const struct rect *_rect, u8 color )
{
u32 screen_ofsx = 0;//_info.screen_width >> 1;
u32 screen_ofsy = 0;//_info.screen_height >> 1;
u8 *addr = NULL;
u32 y,x;
// vector2_t pos, base;
for( y = 0; y < _rect->height; ++y ) {
// base.y = _rect->posy + y;
for( x = 0; x < _rect->width; ++x ) {
// base.x = _rect->posx + x;
// rotate( &pos, &base, rot );
addr = get_addr( (_rect->posy+y), (_rect->posx+x) );
if( is_valid_address(addr) ) {
*addr = color;
}
}
}
}
END_TEST
START_TEST(test_parse_format_ipv4_listen_all)
{
char *host = "0.0.0.0";
char *formatted;
struct sockaddr_storage addr;
struct sockaddr_in *v4addr;
int addr_len;
addr_len = get_addr(NULL, 53, AF_INET, AI_PASSIVE, &addr);
fail_unless(addr_len == sizeof(struct sockaddr_in));
v4addr = (struct sockaddr_in *) &addr;
fail_unless(v4addr->sin_addr.s_addr == htonl(0x00000000));
fail_unless(v4addr->sin_port == htons(53));
formatted = format_addr(&addr, addr_len);
fail_if(strcmp(host, formatted));
}
END_TEST
START_TEST(test_parse_format_ipv4)
{
char *host = "192.168.2.10";
char *formatted;
struct sockaddr_storage addr;
struct sockaddr_in *v4addr;
int addr_len;
addr_len = get_addr(host, 53, AF_INET, 0, &addr);
fail_unless(addr_len == sizeof(struct sockaddr_in));
v4addr = (struct sockaddr_in *) &addr;
fail_unless(v4addr->sin_addr.s_addr == htonl(0xc0a8020a));
fail_unless(v4addr->sin_port == htons(53));
formatted = format_addr(&addr, addr_len);
fail_if(strcmp(host, formatted));
}
int ParseCommandLine(int argc, char * argv [])
{
quiet_mode = FALSE;
key_only = FALSE;
static GOptionEntry entries[] = {
{ "quiet", 'q', 0, G_OPTION_ARG_NONE, &quiet_mode, "no additional information, only index entries", NULL },
{ "key-only", 'k', 0, G_OPTION_ARG_NONE, &key_only, "print only keys (implies --quiet option)", NULL },
{ NULL },
};
glib::OptionContext opt_cnt(g_option_context_new("INDEX_FILE"));
g_option_context_add_main_entries(get_impl(opt_cnt), entries, NULL);
g_option_context_set_help_enabled(get_impl(opt_cnt), TRUE);
g_option_context_set_summary(get_impl(opt_cnt),
"Print context of StarDict index file in human readable form.\n"
"\n"
"Supported files: .idx, .ridx, .syn\n"
);
glib::Error err;
if (!g_option_context_parse(get_impl(opt_cnt), &argc, &argv, get_addr(err))) {
std::cerr << "Option parsing failed: " << err->message << std::endl;
return EXIT_FAILURE;
}
if(argc == 1) {
std::cerr << "Index file is not specified." << std::endl;
return EXIT_FAILURE;
}
if(argc > 2) {
std::cerr << "warning: only the first file will be processed." <<std::endl;
}
idx_file_name = argv[1];
if(!g_str_has_suffix(idx_file_name.c_str(), ".idx")
&& !g_str_has_suffix(idx_file_name.c_str(), ".syn")
&& !g_str_has_suffix(idx_file_name.c_str(), ".ridx")) {
std::cerr << "Unsupported index type." << std::endl;
return EXIT_FAILURE;
}
syn_file = g_str_has_suffix(idx_file_name.c_str(), ".syn");
if(key_only)
quiet_mode = TRUE;
return EXIT_SUCCESS;
}
unsigned long dwarf_function_ending_address(Dwarf_Die function_die, struct dwarf_compilation_unit * unit){
Dwarf_Error error = 0;
Dwarf_Attribute *attrbuf = 0;
Dwarf_Addr highpc = 0;
Dwarf_Signed attrcount = 0;
Dwarf_Unsigned i;
int res = dwarf_attrlist(function_die,&attrbuf,&attrcount,&error);
if(res != DW_DLV_OK) {
return 0;
}
for(i = 0; i < attrcount ; ++i) {
Dwarf_Half aform;
res = dwarf_whatattr(attrbuf[i],&aform,&error);
if(aform == DW_AT_high_pc) {
get_addr(attrbuf[i],&highpc);
return highpc;
}
}
return 0;
}
t_sock connect_server_ipv4(char *ip, int port, char *proto_name)
{
t_sock client;
t_protoent *proto;
t_sockaddr_in sin;
ft_dprintf(1, "{yellow}Try connecting to '%s:%d' on ipv4\n{eoc}", ip, port);
client = 0;
proto = getprotobyname(proto_name);
if (proto)
if ((client = socket(PF_INET, SOCK_STREAM, proto->p_proto)) == -1)
exit(ft_dprintf(2, "can't create socket\n"));
sin.sin_family = AF_INET;
sin.sin_port = htons(port);
sin.sin_addr.s_addr = get_addr(ip);
if ((connect(client, (const t_sockaddr*)&sin, sizeof(sin))) == -1)
exit(ft_dprintf(1, "\033[22;31mError : init client on %d\033[22;37m\n",
port));
ft_dprintf(1, "{yellow}Success\n{eoc}");
return (client);
}
void Nsf_Impl::map_memory()
{
// Map standard things
cpu.reset( unmapped_code() );
cpu.map_code( 0, 0x2000, low_ram, low_ram_size ); // mirrored four times
cpu.map_code( sram_addr, sram_size, sram() );
// Determine initial banks
byte banks [bank_count];
static byte const zero_banks [sizeof header_.banks] = { 0 };
if ( memcmp( header_.banks, zero_banks, sizeof zero_banks ) )
{
banks [0] = header_.banks [6];
banks [1] = header_.banks [7];
memcpy( banks + fds_banks, header_.banks, sizeof header_.banks );
}
else
{
// No initial banks, so assign them based on load_addr
int first_bank = (get_addr( header_.load_addr ) - sram_addr) / bank_size;
unsigned total_banks = rom.size() / bank_size;
for ( int i = bank_count; --i >= 0; )
{
int bank = i - first_bank;
if ( (unsigned) bank >= total_banks )
bank = 0;
banks [i] = bank;
}
}
// Map banks
for ( int i = (fds_enabled() ? 0 : fds_banks); i < bank_count; ++i )
write_bank( i, banks [i] );
// Map FDS RAM
if ( fds_enabled() )
cpu.map_code( rom_addr, fdsram_size, fdsram() );
}
int fdt_decode_get_spi_switch(const void *blob, struct fdt_spi_uart *config)
{
int node, uart_node;
const u32 *gpio;
node = fdt_node_offset_by_compatible(blob, 0,
"nvidia,spi-uart-switch");
if (node < 0)
return node;
uart_node = lookup_phandle(blob, node, "uart");
if (uart_node < 0)
return uart_node;
config->port = get_int(blob, uart_node, "id", -1);
if (config->port == -1)
return -FDT_ERR_NOTFOUND;
config->gpio = -1;
config->regs = (NS16550_t)get_addr(blob, uart_node, "reg");
gpio = fdt_getprop(blob, node, "gpios", NULL);
if (gpio)
config->gpio = fdt32_to_cpu(gpio[1]);
return 0;
}
bool connect_pool::aliving()
{
// XXX，虽然此处未加锁，但也应该不会有问题，因为下面的 peek() 过程会再次
// 对 alive_ 加锁，以防止多线程操作时的冲突
if (alive_)
return true;
time_t now = time(NULL);
lock_.lock();
if (retry_inter_ > 0 && now - last_dead_ >= retry_inter_)
{
alive_ = true;
lock_.unlock();
// 重置服务端连接状态，以便重试
logger("reset server: %s", get_addr());
return true;
}
lock_.unlock();
return false;
}
blargg_err_t Nsf_Impl::load_( Data_Reader& in )
{
// pad ROM data with 0
RETURN_ERR( rom.load( in, header_.size, &header_, 0 ) );
if ( !header_.valid_tag() )
return blargg_err_file_type;
RETURN_ERR( high_ram.resize( (fds_enabled() ? fdsram_offset + fdsram_size : fdsram_offset) ) );
addr_t load_addr = get_addr( header_.load_addr );
if ( load_addr < (fds_enabled() ? sram_addr : rom_addr) )
set_warning( "Load address is too low" );
rom.set_addr( load_addr % bank_size );
if ( header_.vers != 1 )
set_warning( "Unknown file version" );
set_play_period( header_.play_period() );
return blargg_ok;
}
//address
static void *add_free_block(void *bp) {
//dbg_printf("addfree%p\n",bp);
void* block;
if (free_list==base) {
set_succ(bp,0);
set_pred(bp,0);
free_list=bp;
return bp;
}
//int i=0;
block=free_list;
size_t block_off;
while(block!=base) {
//printf("freehead%p",block);
block_off=get_offset(block);
if (get_offset(bp)<block_off) {
set_succ(bp,block_off);
set_pred(bp,get_pred_offset(block));
void *pred=pred_blkp(block);
set_pred(block,get_offset(bp));
if (block==free_list)
free_list=bp;
else {
set_succ(pred,get_offset(bp));
}//printf("add%p %p %p %p\n",bp,pred_blkp(bp),succ_blkp(bp),block);
return bp;
}
block=succ_blkp(block);
// i++;
}
set_succ(bp,0);
set_pred(bp,block_off);
set_succ(get_addr(block_off),get_offset(bp));
return bp;
}
blargg_err_t Nsf_Impl::start_track( int track )
{
int speed_flags = 0;
#if NSF_EMU_EXTRA_FLAGS
speed_flags = header().speed_flags;
#endif
apu.reset( header().pal_only(), (speed_flags & 0x20) ? 0x3F : 0 );
apu.enable_w4011_( enable_w4011 );
apu.write_register( 0, 0x4015, 0x0F );
apu.write_register( 0, 0x4017, (speed_flags & 0x10) ? 0x80 : 0 );
// Clear memory
memset( unmapped_code(), Nes_Cpu::halt_opcode, unmapped_size );
memset( low_ram, 0, low_ram_size );
memset( sram(), 0, sram_size );
map_memory();
// Arrange time of first call to play routine
play_extra = 0;
next_play = play_period;
play_delay = initial_play_delay;
saved_state.pc = idle_addr;
// Setup for call to init routine
cpu.r.a = track;
cpu.r.x = header_.pal_only();
cpu.r.sp = 0xFF;
jsr_then_stop( header_.init_addr );
if ( cpu.r.pc < get_addr( header_.load_addr ) )
set_warning( "Init address < load address" );
return blargg_ok;
}
