IndexSet::IndexSet (IndexSet *set) {
#ifdef ASSERT
_serial_number = _serial_count++;
set->check_watch("copied", _serial_number);
check_watch("initialized by copy", set->_serial_number);
_max_elements = set->_max_elements;
#endif
_count = set->_count;
_max_blocks = set->_max_blocks;
if (_max_blocks <= preallocated_block_list_size) {
_blocks = _preallocated_block_list;
} else {
_blocks =
(IndexSet::BitBlock**) arena()->Amalloc_4(sizeof(IndexSet::BitBlock**) * _max_blocks);
}
for (uint i = 0; i < _max_blocks; i++) {
BitBlock *block = set->_blocks[i];
if (block == &_empty_block) {
set_block(i, &_empty_block);
} else {
BitBlock *new_block = alloc_block();
memcpy(new_block->words(), block->words(), sizeof(uint32) * words_per_block);
set_block(i, new_block);
}
}
}
void Block__parent(VM* vm)
{
Block* block = as_block(vm->input(0));
if (block == NULL) {
set_block(vm->output(), NULL);
return;
}
set_block(vm->output(), get_parent_block(block));
}
int single_file_processor(char *filename, struct stat *st)
{
struct file_header hdr;
int fd;
mode_t mode = st->st_mode;
hdr.namelen = strlen(filename) + 1;
hdr.mode = mode;
hdr.atime = st->st_atim.tv_sec;
hdr.atime_nsec = st->st_atim.tv_nsec;
hdr.mtime = st->st_mtim.tv_sec;
hdr.mtime_nsec = st->st_mtim.tv_nsec;
if (S_ISREG(mode)) {
int ret;
fd = open(filename, O_RDONLY);
if (fd < 0)
gui_fatal("open %s", filename);
hdr.filelen = st->st_size;
write_headers(&hdr, filename);
ret = copy_file(1, fd, hdr.filelen, &crc32_sum);
if (ret != COPY_FILE_OK) {
if (ret != COPY_FILE_WRITE_ERROR)
gui_fatal("Copying file %s: %s", filename,
copy_file_status_to_str(ret));
else {
set_block(0);
wait_for_result();
exit(1);
}
}
close(fd);
}
if (S_ISDIR(mode)) {
hdr.filelen = 0;
write_headers(&hdr, filename);
}
if (S_ISLNK(mode) && !ignore_symlinks) {
char name[st->st_size + 1];
if (readlink(filename, name, sizeof(name)) != st->st_size)
gui_fatal("readlink %s", filename);
hdr.filelen = st->st_size + 1;
write_headers(&hdr, filename);
if (!write_all_with_crc(1, name, st->st_size + 1)) {
set_block(0);
wait_for_result();
exit(1);
}
}
// check for possible error from qfile-unpacker
wait_for_result();
return 0;
}
void Term__contents(VM* vm)
{
Term* t = as_term_ref(vm->input(0));
if (t == NULL)
return vm->throw_str("NULL term");
set_block(vm->output(), t->nestedContents);
}
static void *find_free_space(int bsize, size_t size, void **map)
{
t_header *header;
t_block *block;
header = (t_header *)*map;
while (header)
{
block = (t_block *)header->first;
while (block && (void *)block + block->next <= header->end)
{
if (block->flag == FREE && block->next >= size)
return (set_block(bsize, size, block, header->end));
if ((void *)block + block->next == header->end)
block = NULL;
else
block = (void *)block + block->next;
}
if (!header->next)
{
if (new_map(bsize, map, header) < 0)
return (NULL);
}
else
header = header->next;
}
return (NULL);
}
/** Empty (ie zero) the buffer.
*/
void
AudioBuffer::clear()
{
assert(nframes() != 0);
set_block(0, 0, nframes() - 1);
_state = OK;
}
void
AudioBuffer::copy(Context& context, const Buffer* src)
{
const AudioBuffer* src_abuf = dynamic_cast<const AudioBuffer*>(src);
if (!src_abuf) {
clear();
return;
}
// Control => Control
if (src_abuf->is_control() == is_control()) {
ObjectBuffer::copy(context, src);
// Audio => Audio
} else if (!src_abuf->is_control() && !is_control()) {
copy(src_abuf->data(),
context.offset(), context.offset() + context.nframes() - 1);
// Audio => Control
} else if (!src_abuf->is_control() && is_control()) {
data()[0] = src_abuf->data()[context.offset()];
// Control => Audio
} else if (src_abuf->is_control() && !is_control()) {
data()[context.offset()] = src_abuf->data()[0];
// Control => Audio or Audio => Control
} else {
set_block(src_abuf->data()[0], 0, nframes());
}
}
void change_event_make_append(Value* event, Block* target, Value* expression)
{
change_event_set_blank(event, 1);
set_symbol(change_event_type(event), s_ChangeAppend);
set_block(change_event_target(event), target);
set_value(change_event_field(event, 0), expression);
}
void recv_loop(int acc){
ssize_t total, len;
if(g_mode == 'n'){
set_block(acc, 0);
}
for(total = 0;;){
if((len = recv(acc, g_buf, sizeof(g_buf), 0)) == -1){
if(errno == EAGAIN){
fprintf(stderr, ".");
continue;
} else {
perror("recv");
break;
}
}
if(len == 0){
fprintf(stderr, "recv:EOF\n");
break;
}
fprintf(stderr, "recv:%d\n", (int) len);
total += len;
}
fprintf(stderr, "total:%d\n", (int) total);
}
void
block_write(const char *buf, int n)
{
set_block();
if (write(psfd, buf, n) != n)
log_sys("block_write: write error");
}
void Term__parent(VM* vm)
{
Term* t = as_term_ref(vm->input(0));
if (t == NULL)
return vm->throw_str("NULL term");
set_block(vm->output(), t->owningBlock);
}
int main() { /*------------------------------main function------------------------------*/
setcursortype(NOCURSOR);
create_world();
int i;
srand((unsigned)time(NULL));
for(;;) {
ModTick();
check_wall();//checck_crash
set_block();
new_block();
check_move();//move_block();
i++;
Sleep(1);
if (i>399) {
i=0;
move_block(DOWN);
}
gotoxy(0,0);
printf("%3d",b_x);
gotoxy(0,1);
printf("%3d",b_y);
gotoxy(0,3);
printf("%3d",b_type);
}
gotoxy(0,0);
getch();
} /*------------------------------main function------------------------------*/
void migrate_value(Value* value, Migration* migration)
{
if (is_ref(value)) {
set_term_ref(value, migrate_term_pointer(as_term_ref(value), migration));
} else if (is_block(value)) {
set_block(value, migrate_block_pointer(as_block(value), migration));
} else if (is_list_based(value)) {
migrate_list_value(value, migration);
} else if (is_hashtable(value)) {
Value oldHashtable;
move(value, &oldHashtable);
set_hashtable(value);
Value* hashtable = value;
for (int i=0; i < hashtable_slot_count(&oldHashtable); i++) {
Value* oldKey = hashtable_key_by_index(&oldHashtable, i);
if (oldKey == NULL || is_null(oldKey))
continue;
Value* oldValue = hashtable_value_by_index(&oldHashtable, i);
Value key;
copy(oldKey, &key);
migrate_value(&key, migration);
Value* newValue = hashtable_insert(hashtable, &key);
copy(oldValue, newValue);
migrate_value(newValue, migration);
}
}
}
void Term__function(VM* vm)
{
Term* t = as_term_ref(vm->input(0));
if (t == NULL)
return vm->throw_str("NULL term");
set_block(vm->output(), term_function(t));
}
void SLHA_io::set_block_imag(const std::string& name,
const Eigen::MatrixBase<Derived>& matrix,
const std::string& symbol, double scale)
{
std::ostringstream ss;
ss << "Block " << name;
if (scale != 0.)
ss << " Q= " << FORMAT_SCALE(scale);
ss << '\n';
const int rows = matrix.rows();
const int cols = matrix.cols();
for (int i = 1; i <= rows; ++i) {
if (cols == 1) {
ss << boost::format(vector_formatter) % i % Im(matrix(i-1,0))
% ("Im(" + symbol + "(" + ToString(i) + "))");
} else {
for (int k = 1; k <= cols; ++k) {
ss << boost::format(mixing_matrix_formatter) % i % k % Im(matrix(i-1,k-1))
% ("Im(" + symbol + "(" + ToString(i) + "," + ToString(k) + "))");
}
}
}
set_block(ss);
}
void VoxelMap::set_voxel(int value, Vector3i pos, unsigned int c) {
Vector3i bpos = voxel_to_block(pos);
VoxelBlock * block = get_block(pos);
if (block == NULL) {
set_block(bpos, VoxelBlock::create(*this, bpos));
}
block->voxels->set_voxel(value, pos - block_to_voxel(bpos), c);
}
void write_headers(struct file_header *hdr, char *filename)
{
if (!write_all_with_crc(1, hdr, sizeof(*hdr))
|| !write_all_with_crc(1, filename, hdr->namelen)) {
set_block(0);
wait_for_result();
exit(1);
}
}
void IndexSet::free_block(uint i) {
debug_only(check_watch("free block", i));
assert(i < _max_blocks, "block index too large");
BitBlock *block = _blocks[i];
assert(block != &_empty_block, "cannot free the empty block");
block->set_next((IndexSet::BitBlock*)Compile::current()->indexSet_free_block_list());
Compile::current()->set_indexSet_free_block_list(block);
set_block(i,&_empty_block);
}
void LIR_OopMapGenerator::iterate_one(BlockBegin* block) {
#ifndef PRODUCT
if (TraceLIROopMaps) {
tty->print_cr("Iterating through block %d", block->block_id());
}
#endif
set_block(block);
block->set(BlockBegin::lir_oop_map_gen_reachable_flag);
int i;
if (!is_caching_change_block(block)) {
LIR_OpVisitState state;
LIR_OpList* inst = block->lir()->instructions_list();
int length = inst->length();
for (i = 0; i < length; i++) {
LIR_Op* op = inst->at(i);
LIR_Code code = op->code();
state.visit(op);
for (int j = 0; j < state.info_count(); j++) {
process_info(state.info_at(j));
}
if (code == lir_volatile_move ||
code == lir_move) {
process_move(op);
}
}
}
// Process successors
if (block->end() != _base) {
for (i = 0; i < block->end()->number_of_sux(); i++) {
merge_state(block->end()->sux_at(i));
}
} else {
// Do not traverse OSR entry point of the base
merge_state(_base->std_entry());
}
set_block(NULL);
}
/* The block routine for a compression buffer. */
static int
compress_buffer_block (void *closure, bool block)
{
struct compress_buffer *cb = closure;
if (block)
return set_block (cb->buf);
else
return set_nonblock (cb->buf);
}
/* The block function for a log buffer. */
static int
log_buffer_block (void *closure, bool block)
{
struct log_buffer *lb = closure;
if (block)
return set_block (lb->buf);
else
return set_nonblock (lb->buf);
}
int listen_to(const char * ip,int port, struct sockaddr_in* addr, int is_block)
{
int res;
int fd = create_socket();
if (fd < 0)
{
fprintf(stderr,"create socket failed!\n");
return -1;
}
int result = 0;
if (is_block)
{
result = set_block(fd);
}
else
{
result = set_nonblock(fd);
}
if (result==-1)
{
fprintf(stderr,"set block failed!\n");
return -1;
}
res = set_reuse(fd);
if (res < 0)
{
fprintf(stderr,"set reuse failed!\n");
close_socket(fd);
return -1;
}
make_address(addr, ip, port);
res = bind(fd, (const struct sockaddr*)addr, (socklen_t)sizeof(struct sockaddr_in));
if ( res < 0)
{
fprintf(stderr,"bind failed!\n");
close_socket(fd);
return -1;
}
res = listen(fd, SOMAXCONN);
if ( res < 0)
{
fprintf(stderr,"listen failed!\n");
close_socket(fd);
return -1;
}
return fd;
}
/* Create a new block object (gdb.Block) that encapsulates the struct
block object from GDB. */
PyObject *
block_to_block_object (struct block *block, struct objfile *objfile)
{
block_object *block_obj;
block_obj = PyObject_New (block_object, &block_object_type);
if (block_obj)
set_block (block_obj, block, objfile);
return (PyObject *) block_obj;
}
void VoxelMap::set_block_buffer(Vector3i bpos, Ref<VoxelBuffer> buffer) {
ERR_FAIL_COND(buffer.is_null());
VoxelBlock * block = get_block(bpos);
if (block == NULL) {
block = VoxelBlock::create(*this, bpos, *buffer);
set_block(bpos, block);
}
else {
block->voxels = buffer;
}
}
/* The block function for a multi-source buffer. */
static int
ms_buffer_block (void *closure, bool block)
{
struct ms_buffer *mb = closure;
mb->block = block;
if (block)
return set_block (mb->cur);
else
return set_nonblock (mb->cur);
}
int overlay_mdp_recv(overlay_mdp_frame *mdp, int port, int *ttl)
{
char mdp_socket_name[101];
unsigned char recvaddrbuffer[1024];
struct sockaddr *recvaddr=(struct sockaddr *)recvaddrbuffer;
unsigned int recvaddrlen=sizeof(recvaddrbuffer);
struct sockaddr_un *recvaddr_un;
if (!FORM_SERVAL_INSTANCE_PATH(mdp_socket_name, "mdp.socket"))
return WHY("Could not find mdp socket");
mdp->packetTypeAndFlags=0;
/* Check if reply available */
set_nonblock(mdp_client_socket);
ssize_t len = recvwithttl(mdp_client_socket,(unsigned char *)mdp, sizeof(overlay_mdp_frame),ttl,recvaddr,&recvaddrlen);
set_block(mdp_client_socket);
recvaddr_un=(struct sockaddr_un *)recvaddr;
/* Null terminate received address so that the stat() call below can succeed */
if (recvaddrlen<1024) recvaddrbuffer[recvaddrlen]=0;
if (len>0) {
/* Make sure recvaddr matches who we sent it to */
if (strncmp(mdp_socket_name, recvaddr_un->sun_path, sizeof(recvaddr_un->sun_path))) {
/* Okay, reply was PROBABLY not from the server, but on OSX if the path
has a symlink in it, it is resolved in the reply path, but might not
be in the request path (mdp_socket_name), thus we need to stat() and
compare inode numbers etc */
struct stat sb1,sb2;
if (stat(mdp_socket_name,&sb1)) return WHY("stat(mdp_socket_name) failed, so could not verify that reply came from MDP server");
if (stat(recvaddr_un->sun_path,&sb2)) return WHY("stat(ra->sun_path) failed, so could not verify that reply came from MDP server");
if ((sb1.st_ino!=sb2.st_ino)||(sb1.st_dev!=sb2.st_dev))
return WHY("Reply did not come from server");
}
// silently drop incoming packets for the wrong port number
if (port>0 && port != mdp->in.dst.port){
WARNF("Ignoring packet for port %d",mdp->in.dst.port);
return -1;
}
int expected_len = overlay_mdp_relevant_bytes(mdp);
if (len < expected_len){
return WHYF("Expected packet length of %d, received only %lld bytes", expected_len, (long long) len);
}
/* Valid packet received */
return 0;
} else
/* no packet received */
return -1;
}
CFGBlock* add_block(int ip, bool loop=false) {
CFGBlock* blk = find_block(ip);
if(blk) return blk;
blk = new CFGBlock(ip, loop);
// Inherit the current exception handler
blk->set_exception_handler(current_->exception_handler());
set_block(ip, blk);
return blk;
}
void notify_end_and_wait_for_result()
{
struct file_header end_hdr;
/* nofity end of transfer */
memset(&end_hdr, 0, sizeof(end_hdr));
end_hdr.namelen = 0;
end_hdr.filelen = 0;
write_all_with_crc(1, &end_hdr, sizeof(end_hdr));
set_block(0);
wait_for_result();
}
static void do_exit(int code)
{
int status;
/* restore flags, as we may have not the only copy of this file descriptor
*/
if (local_stdin_fd != -1)
set_block(local_stdin_fd);
close(local_stdin_fd);
close(local_stdout_fd);
// sever communication lines; wait for child, if any
// so that qrexec-daemon can count (recursively) spawned processes correctly
waitpid(-1, &status, 0);
exit(code);
}
void draw_hind_virtual_cockpit_ort_view (int x_min, int x_max)
{
float
fov;
eo_params*
eo;
target_acquisition_systems
system;
rgb_colour
black;
int
damaged = FALSE;
if (eo_sensor == TARGET_ACQUISITION_SYSTEM_FLIR)
{
eo = &hind_flir;
system = TARGET_ACQUISITION_SYSTEM_FLIR;
damaged = hind_damage.flir;
}
else
{
eo = &hind_llltv;
system = TARGET_ACQUISITION_SYSTEM_LLLTV;
damaged = hind_damage.llltv;
}
black.r = 0;
black.g = 0;
black.b = 0;
black.a = 255;
// clear background, since we won't be drawing the 3D view over the entire screen
set_block(0, 0, full_screen_x_max, full_screen_y_max, black);
if (!damaged)
{
fov = rad(get_eo_sensor_fov(eo, system));
set_eo_view_params(system, x_min, full_screen_y_min, x_max, full_screen_y_max, fov, fov);
draw_eo_3d_scene = TRUE;
draw_main_3d_scene (&eo_vp);
draw_eo_3d_scene = FALSE;
}
}
