static void
clock_location_localtime (SystemTimezone *systz, char *tzone, struct tm *tm, time_t now)
{
glong offset = get_offset (tzone, systz);
time_t real_now = now + offset;
clock_set_tz (tzone);
localtime_r (&real_now, tm);
clock_unset_tz (systz);
}
void c64_magic_voice_cartridge_device::c64_cd_w(address_space &space, offs_t offset, UINT8 data, int sphi2, int ba, int roml, int romh, int io1, int io2)
{
if (!io2 && sphi2)
{
m_tpi->write(space, offset & 0x07, data);
}
int roml2 = !(!roml || (roml && !PB5 && A12 && A13 && !A14 && A15));
int romh2 = !((!romh && !PB6) || (!PB5 && A12 && A13 && !A14 && !A15));
m_exp->cd_w(space, get_offset(offset), data, sphi2, ba, roml2, romh2, io1, 1);
}
static floperr_t internal_cqm_read_sector(floppy_image_legacy *floppy, int head, int track, int sector, int sector_is_index, void *buffer, size_t buflen)
{
UINT64 offset;
floperr_t err;
// take sector offset
err = get_offset(floppy, head, track, sector, sector_is_index, &offset);
if (err)
return err;
memcpy(buffer,get_tag(floppy)->buf+offset,buflen);
return FLOPPY_ERROR_SUCCESS;
}
static floperr_t internal_sorc_write_sector(floppy_image_legacy *floppy, int head, int track, int sector, bool sector_is_index, const void *buffer, size_t buflen, int ddam)
{
uint64_t offset;
floperr_t err;
err = get_offset(floppy, head, track, sector, sector_is_index, &offset);
if (err)
return err;
floppy_image_write(floppy, buffer, offset, buflen);
return FLOPPY_ERROR_SUCCESS;
}
static floperr_t exi_get_sector_length(floppy_image *floppy, int head, int track, int sector, UINT32 *sector_length)
{
floperr_t err;
err = get_offset(floppy, head, track, sector, FALSE, NULL);
if (err)
return err;
if (sector_length) {
*sector_length = 256;
}
return FLOPPY_ERROR_SUCCESS;
}
static floperr_t td0_get_sector_length(floppy_image_legacy *floppy, int head, int track, int sector, uint32_t *sector_length)
{
floperr_t err;
err = get_offset(floppy, head, track, sector, false, nullptr);
if (err)
return err;
if (sector_length) {
*sector_length = get_tag(floppy)->sector_size;
}
return FLOPPY_ERROR_SUCCESS;
}
/* Not much happens here. Eventually use this function to try and
* avoid saving/reloading the source pointers each vertex (if some of
* them can fit in registers).
*/
static void get_src_ptr( struct x86_program *p,
struct x86_reg srcREG,
struct x86_reg vtxREG,
struct tnl_clipspace_attr *a )
{
struct tnl_clipspace *vtx = GET_VERTEX_STATE(p->ctx);
struct x86_reg ptr_to_src = x86_make_disp(vtxREG, get_offset(vtx, &a->inputptr));
/* Load current a[j].inputptr
*/
x86_mov(&p->func, srcREG, ptr_to_src);
}
static floperr_t dsk_get_sector_length(floppy_image_legacy *floppy, int head, int track, int sector, UINT32 *sector_length)
{
floperr_t err;
err = get_offset(floppy, head, track, sector, FALSE, NULL);
if (err)
return err;
if (sector_length) {
*sector_length = get_tag(floppy)->sector_size;
}
return FLOPPY_ERROR_SUCCESS;
}
static floperr_t internal_basicdsk_write_sector(floppy_image *floppy, int head, int track, int sector, int sector_is_index, const void *buffer, size_t buflen, int ddam)
{
UINT64 offset;
floperr_t err;
err = get_offset(floppy, head, track, sector, sector_is_index, &offset);
if (err)
return err;
floppy_image_write(floppy, buffer, offset, buflen);
return FLOPPY_ERROR_SUCCESS;
}
void
TileMap::editor_update()
{
if (get_walker()) {
if (get_path() && get_path()->is_valid()) {
m_movement = get_walker()->get_pos() - get_offset();
set_offset(get_walker()->get_pos());
} else {
set_offset(Vector(0, 0));
}
}
}
static void *get_virtual_base_pointer(void *ptr,
a_base_class_spec_ptr bcsp)
/*
Return a pointer to the virtual base class of the derived object ptr as
specified by bcsp.
*/
{
a_vtbl_entry_ptr vtbl, vbase_offset;
vtbl = *((a_vtbl_entry_ptr *)ptr);
vbase_offset = (a_vtbl_entry_ptr)(((char *)vtbl) + get_offset(bcsp));
return (void *)(((char *)ptr) + *vbase_offset);
} /* get_virtual_base_pointer */
int draw_pixl(PFBDEV const pfbdev,int x,int y,unsigned int color)
{
char *offset;
if (is_fbdev(pfbdev))
return -1;
offset = (char *)get_offset(pfbdev,x,y);
*offset = (color & COLOR);
*(offset + 1) = ((color >> 8) & COLOR);
*(offset + 2) = ((color >> 16) & COLOR);
return 0;
}
void trans_op(Operand op){
switch(op->kind){
case CONSTANT:
fprintf(f2, "\tli $t0, %d\n", op->u.value);
break;
case ARRA:
fprintf(f2, "\tmove $t1, $fp\n");
fprintf(f2, "\taddi $t1, $t1, -%d\n", get_offset(op->u.array_var_no, 1));
fprintf(f2, "\tmove $t0, $t1\n");
break;
case ADDRESS:
fprintf(f2, "\tlw $t1, -%d($fp)\n", get_offset(op->u.addr_temp_no, 0));
fprintf(f2, "lw $t0, 0($t1)\n");
break;
case VARIABLE:
fprintf(f2, "\tlw $t0, -%d($fp)\n", get_offset(op->u.var_no, 1));
break;
case TEMP:
fprintf(f2, "\tlw $t0, -%d($fp)\n", get_offset(op->u.temp_no, 0));
break;
}
}
/* Adds another pointer to a struct represented by an offset table */
int add_to_table_otable(struct offset_table *src, struct offset_table *dest){
struct offset_member temp;
temp.offset = get_offset(DYN_S_VOIDP, dest);
temp.size = dstru_sizeof(DYN_S_VOIDP, NULL);
temp.scalar_type = STYPE_NONE;
temp.flags = SPTR_OFFSET_TBL;
temp.subtable = src;
dest->structure_size += temp.size;
table_add_entry(dest, temp);
return 0;
}
/* Adds a pointer to a scalar */
int add_to_table_sptr(struct offset_table *dest, struct ffi_instruction *ins){
struct offset_member temp;
temp.offset = get_offset(DYN_S_VOIDP, dest);
temp.size = dstru_sizeof(DYN_S_VOIDP, NULL);
temp.scalar_type = (enum type) ins->type;
temp.flags = PTR_MEMBER;
temp.subtable = NULL;
dest->structure_size += temp.size;
table_add_entry(dest, temp);
return 0;
}
/* delete = 1 Do delete dbdata
delete = 0 Do not delete dbdta */
unsigned int file_commit_block(unsigned char *dbdata, INOBNO inobno,
off_t offset)
{
unsigned char *stiger;
compr *compressed;
INUSE *inuse;
OFFHASH *offhash;
unsigned int ret = 0;
#ifndef SHA3
word64 res[3];
#endif
FUNC;
#ifdef SHA3
stiger=sha_binhash(dbdata, BLKSIZE);
#else
binhash(dbdata, BLKSIZE, res);
stiger=(unsigned char *)&res;
#endif
#ifdef LZO
compressed = lzo_compress((unsigned char *) dbdata, BLKSIZE);
#else
compressed = clz_compress((unsigned char *) dbdata, BLKSIZE);
#endif
ret = compressed->size;
inuse = file_get_inuse(stiger);
if (NULL == inuse) {
loghash("commit_block : write hash with file_qdta", stiger);
inuse = s_malloc(sizeof(INUSE));
inuse->inuse = 0;
inuse->offset = get_offset(compressed->size);
inuse->size = compressed->size;
file_qdta(&inobno, stiger, compressed->data, compressed->size,
inuse->offset);
} else
loghash("commit_block : only updated inuse for hash ", stiger);
inuse->inuse++;
file_update_inuse(stiger, inuse);
comprfree(compressed);
offhash = s_malloc(sizeof(OFFHASH));
offhash->offset = offset;
memcpy(offhash->stiger, stiger, config->hashlen);
write_dbb_to_cache(&inobno, offhash);
#ifdef SHA3
free(stiger);
#endif
free(inuse);
return (ret);
}
void bltin_completion(t_prompt *prompt, char **env)
{
int count;
int ret;
if ((prompt->offset =
get_offset(prompt->line, prompt->count_char, &ret)) == -1)
return ;
if (ret == 0
&& (count = count_commands(prompt, env)))
print_commands(prompt, env, count);
else
print_files(prompt);
}
time_t region::read_modification_time(unsigned int x, unsigned int z) const
{
if (!header) {
throw bad_region(path, "header has not been loaded");
}
int o = get_offset(x, z) + RECORD_SIZE;
uint8_t buf[HEADER_RECORD_SIZE];
::memcpy(reinterpret_cast<char*>(buf), &header[o], HEADER_RECORD_SIZE);
uint32_t mtime = ((buf[0] << 24) || (buf[1] << 16) || (buf[2] << 8)) || buf[3];
return mtime;
}
//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;
}
SgAsmCoffSymbolTable*
SgAsmCoffSymbolTable::parse()
{
/* Set the section size according to the number of entries indicated in the header. */
SgAsmPEFileHeader *fhdr = dynamic_cast<SgAsmPEFileHeader*>(get_header());
ROSE_ASSERT(fhdr!=NULL);
set_offset(fhdr->get_e_coff_symtab());
set_size(fhdr->get_e_coff_nsyms()*SgAsmCoffSymbol::COFFSymbol_disk_size);
SgAsmGenericSection::parse();
/* The string table immediately follows the symbols. The first four bytes of the string table are the size of the
* string table in little endian. */
rose_addr_t strtab_offset = get_offset() + fhdr->get_e_coff_nsyms() * SgAsmCoffSymbol::COFFSymbol_disk_size;
p_strtab = new SgAsmGenericSection(fhdr->get_file(), fhdr);
p_strtab->set_offset(strtab_offset);
p_strtab->set_size(sizeof(uint32_t));
p_strtab->set_synthesized(true);
p_strtab->set_name(new SgAsmBasicString("COFF Symbol Strtab"));
p_strtab->set_purpose(SP_HEADER);
p_strtab->parse();
uint32_t word;
p_strtab->read_content(0, &word, sizeof word);
rose_addr_t strtab_size = ByteOrder::le_to_host(word);
if (strtab_size < sizeof(uint32_t))
throw FormatError("COFF symbol table string table size is less than four bytes");
p_strtab->extend(strtab_size - sizeof(uint32_t));
/* Parse symbols until we've parsed the required number or we run off the end of the section. */
for (size_t i = 0; i < fhdr->get_e_coff_nsyms(); i++) {
try {
SgAsmCoffSymbol *symbol = new SgAsmCoffSymbol(fhdr, this, p_strtab, i);
i += symbol->get_st_num_aux_entries();
p_symbols->get_symbols().push_back(symbol);
} catch (const ShortRead &e) {
fprintf(stderr, "SgAsmCoffSymbolTable::parse: warning: read past end of section \"%s\" [%d]\n"
" symbol #%zu at file offset 0x%08"PRIx64"\n"
" skipping %zu symbols (including this one)\n",
get_name()->get_string(true).c_str(), get_id(),
i, e.offset,
fhdr->get_e_coff_nsyms()-i);
break;
}
}
return this;
}
/* %k */
static int print_key (FILE * stream,
const struct printf_info *info,
const void *const *args)
{
const struct key * key;
char * buffer;
int len;
key = *((const struct key **)(args[0]));
len = asprintf (&buffer, "%u %u 0x%Lx %s",
key_dir_id(key),
key_objectid(key),
get_offset (key),
key_of_what (key));
FPRINTF;
}
void text_display::timerEvent(QTimerEvent *event)
{
if(event->timerId() == cursor_timer_id){
cursor_state = !cursor_state;
QPoint screen = nibble_to_screen(get_cursor_nibble());
update(screen.x(), screen.y(), cursor_width, editor_font::get_height());
}else if(event->timerId() == scroll_timer_id){
selection selection_area = get_selection();
set_offset(get_offset() + columns * scroll_direction * scroll_speed);
if(selection_area.is_dragging()){
selection_area.move_end(columns * 2 * scroll_direction);
set_selection(selection_area);
}
editor->update_window();
}
}
map<pos_t, char> Sampler::next_pos_chars(pos_t pos) {
map<pos_t, char> nexts;
// See if the node is cached (did we just visit it?)
pair<Node, bool> cached = node_cache.retrieve(id(pos));
if(!cached.second) {
// If it's not in the cache, put it in
cached.first = xgidx->node(id(pos));
node_cache.put(id(pos), cached.first);
}
Node& node = cached.first;
// if we are still in the node, return the next position and character
if (offset(pos) < node.sequence().size()-1) {
++get_offset(pos);
nexts[pos] = pos_char(pos);
} else {
// look at the next positions we could reach
if (!is_rev(pos)) {
// we are on the forward strand, the next things from this node come off the end
for (auto& edge : xgidx->edges_on_end(id(pos))) {
if (edge.from() == id(pos)) {
pos_t p = make_pos_t(edge.to(), edge.to_end(), 0);
nexts[p] = pos_char(p);
} else if (edge.from_start() && edge.to_end() && edge.to() == id(pos)) {
// doubly inverted, should be normalized to forward but we handle here for safety
pos_t p = make_pos_t(edge.from(), false, 0);
nexts[p] = pos_char(p);
}
}
} else {
// we are on the reverse strand, the next things from this node come off the start
for (auto& edge : xgidx->edges_on_start(id(pos))) {
if (edge.to() == id(pos)) {
pos_t p = make_pos_t(edge.from(), !edge.from_start(), 0);
nexts[p] = pos_char(p);
} else if (edge.from_start() && edge.to_end() && edge.from() == id(pos)) {
// doubly inverted, should be normalized to forward but we handle here for safety
pos_t p = make_pos_t(edge.to(), true, 0);
nexts[p] = pos_char(p);
}
}
}
}
return nexts;
}
int rasm_arm(ut64 offset, const char *str, unsigned char *data)
{
char op[128];
char *arg;
strncpy(op, str, 120);
arg = strchr(op, ' ');
if (arg) {
arg[0] = '\0';
arg = arg + 1;
}
if (!strcmp(op, "trap")) {
memcpy(data, "\xe7\xff\xde\xf", 4);
return 4;
} else if (!strcmp(op, "int")) {
unsigned int sc = get_offset(arg);
unsigned char *ptr = (uchar *)≻
data[0] = 0x5f; // 0xff ??
data[1] = ptr[2];
data[2] = ptr[1];
data[3] = ptr[0];
return 4;
} else if (!strcmp(op, "hang")) {
memcpy(data, "\xea\xfe\xff\xff", 4);
return 4;
} else if (!strcmp(op, "jmp")) {
off_t dst = get_math(arg);
unsigned long addr = (dst-8)/4;
unsigned char *ptr = (uchar *)&addr;
data[0] = 0xea;
data[1] = ptr[2];
data[2] = ptr[1];
data[3] = ptr[0];
return 4;
} else if (!strcmp(op, "jz")) {
} else if (!strcmp(op, "nop")) {
// little endian
memcpy(data, "\x00\x00\xa0\xe1", 4);
} else
return -1;
return 4;
}
/* Parser */
SgAsmPESectionTable*
SgAsmPESectionTable::parse()
{
SgAsmGenericSection::parse();
SgAsmPEFileHeader *fhdr = dynamic_cast<SgAsmPEFileHeader*>(get_header());
ROSE_ASSERT(fhdr!=NULL);
/* Parse section table and construct section objects, but do not parse the sections yet. */
SgAsmGenericSectionPtrList pending;
const size_t entsize = sizeof(SgAsmPESectionTableEntry::PESectionTableEntry_disk);
for (size_t i=0; i<fhdr->get_e_nsections(); i++) {
SgAsmPESectionTableEntry::PESectionTableEntry_disk disk;
if (entsize!=read_content_local(i * entsize, &disk, entsize, false))
fprintf(stderr, "SgAsmPESectionTable::parse: warning: section table entry %" PRIuPTR " at file offset 0x%08"PRIx64
" extends beyond end of defined section table.\n",
i, get_offset()+i*entsize);
SgAsmPESectionTableEntry *entry = new SgAsmPESectionTableEntry(&disk);
SgAsmPESection *section = NULL;
if (entry->get_name() == ".idata") {
section = new SgAsmPEImportSection(fhdr);
} else {
section = new SgAsmPESection(fhdr);
}
section->init_from_section_table(entry, i+1);
pending.push_back(section);
}
/* Build the memory mapping like the real loader would do. This is the same code used by
* SgAsmExecutableFileFormat::parseBinaryFormat() except we're doing it here early because we need it in the rest of the
* PE parser. */
ROSE_ASSERT(NULL==fhdr->get_loader_map());
BinaryLoader *loader = BinaryLoader::lookup(fhdr); /*no need to clone; we're not changing any settings*/
ROSE_ASSERT(loader!=NULL);
MemoryMap *loader_map = new MemoryMap;
loader->remap(loader_map, fhdr);
fhdr->set_loader_map(loader_map);
/* Parse each section after the loader map is created */
for (size_t i=0; i<pending.size(); i++)
pending[i]->parse();
return this;
}
/* Fill in the response with the current hash status */
static void fill_response(struct ec_response_vboot_hash *r,
int request_offset)
{
if (in_progress)
r->status = EC_VBOOT_HASH_STATUS_BUSY;
else if (get_offset(request_offset) == data_offset && hash &&
!want_abort) {
r->status = EC_VBOOT_HASH_STATUS_DONE;
r->hash_type = EC_VBOOT_HASH_TYPE_SHA256;
r->digest_size = SHA256_DIGEST_SIZE;
r->reserved0 = 0;
r->offset = data_offset;
r->size = data_size;
ASSERT(SHA256_DIGEST_SIZE < sizeof(r->hash_digest));
memcpy(r->hash_digest, hash, SHA256_DIGEST_SIZE);
} else
r->status = EC_VBOOT_HASH_STATUS_NONE;
}
static void
insert_location (GtkTreeStore *store, GWeatherTimezone *zone, const char *loc_name, GtkTreeIter *parent)
{
GtkTreeIter iter;
char *name, *offset;
offset = get_offset (zone);
name = g_strdup_printf ("%s <small>(%s)</small>",
loc_name ? loc_name : gweather_timezone_get_name (zone),
offset);
gtk_tree_store_append (store, &iter, parent);
gtk_tree_store_set (store, &iter,
GWEATHER_TIMEZONE_MENU_NAME, name,
GWEATHER_TIMEZONE_MENU_ZONE, zone,
-1);
g_free (name);
g_free (offset);
}
static int read_block_raw(struct hlfs_ctrl *ctrl,uint32_t storage_address,char* block_buf)
{
//HLOG_DEBUG("enter func %s", __func__);
uint32_t block_size = ctrl->sb.block_size;
struct back_storage * storage =NULL;
uint32_t offset = get_offset(storage_address);
uint32_t segno = get_segno(storage_address);
if(segno >= ctrl->start_segno){
storage = ctrl->storage;
}else{
if(NULL == (storage = get_parent_storage(ctrl->family,segno))){
return -1;
}
}
int ret = read_block(storage,storage_address,block_size,block_buf);
//HLOG_DEBUG("leave func %s", __func__);
return ret;
}
string ArchivoRegVars::get(t_num_ref n){
t_reg_var_size reg_size;
int bytes_para_campo_longitud=sizeof(t_reg_var_size);
t_offset offset=get_offset(n);
fseek(f_d_handler, offset, SEEK_SET);
fread(®_size, 1, bytes_para_campo_longitud, f_d_handler);
char* buffer= (char*) malloc(reg_size+1);
fread(buffer, 1, reg_size, f_d_handler);
*(buffer+reg_size)='\0';
if(ferror(f_d_handler)!=0){
salir("",ERROR_DE_LECTURA_DATOS);
}
string data=buffer;
free(buffer);
return data;
}
bl particle::iterate( vector& _vector, const map2d::layer* _layer, f32 _f32_gravity, bl _bl_fixed,
f32 _f32_rate )
{
translation translation_iteration;
if( collides( translation_iteration, _layer, _bl_fixed, _f32_rate ) )
{
_vector = translation_iteration.vector_collision;
if( translation_iteration.get_collision_distance() - ENG2D_PRECISION > 0.f )
position() = get_moved( direction, translation_iteration.get_collision_distance() - ENG2D_PRECISION );
f32 d = direction;
f32 c = translation_iteration.line_collision.get_normal_direction();
f32 b = c - d;
direction = c + b - math<f32>::radians_05();
vector vector_offset = get_offset(true);
const map2d::tile* tile_map = &_layer->get( _vector );
vector_offset.x *= ( 1.f - roughness ) * ( 1.f - tile_map->get_friction() );
vector_offset.y *= hardness * ( 1.f - tile_map->get_restitution() );
set_offset( vector_offset, true );
return true;
}
else
{
position() = get_moved( direction, get_distance( _bl_fixed, _f32_rate ) );
if( _bl_fixed )
{
shift_offset_y( _f32_gravity * _layer->get_gravity(), true, _f32_rate );
}
else
{
shift_offset_y( _f32_gravity * _layer->get_gravity() * ( sys::delta() * 1000.0 ), true, _f32_rate );
}
return false;
} }
