int _OP_RL(cmem *b,uint32 o,uint8 r,uint32 l){
OPCODE_6 op;
op.o1=0x03+o&0xFF;
op.o2=0x85+8*r;
op.s=l;
add_block(b,(uint8*)&op,sizeof(OPCODE_6));
return 6;
}
int _PUSH_C(cmem *b,uint32 c){
int i=0;
if (c>0x7f){
OPCODE_5 op;
op.o1=0x68;
op.s=c;
add_block(b,(uint8*)&op,sizeof(OPCODE_5));
i=5;
}else{
OPCODE_2 op;
op.o1=0x6A;
op.o2=c;
add_block(b,(uint8*)&op,sizeof(OPCODE_2));
i=2;
}
return i;
}
int _OP_RA(cmem *b,uint32 o,uint8 r,uint32 a){
OPCODE_6 op;
op.o1=0x03+o&0xFF;
op.o2=0x05+r*8;
op.s=a;
add_block(b,(uint8*)&op,sizeof(OPCODE_6));
return 6;
}
int _JAE_C(cmem *b,uint32 a){
int i;
if (a>255){
OPCODE_6 op;
op.o1=0x0F;
op.o2=0x83;
op.s=a;
add_block(b,(uint8*)&op,sizeof(OPCODE_6));
i=6;
}else{
OPCODE_2 op;
op.o1=0x73;
op.o2=(uint8)a&0xFF;
add_block(b,(uint8*)&op,sizeof(OPCODE_2));
i=2;
}
return i;
}
void par_setd(char *block, char *name, char *fmt, double dval, char *comment)
{
Block *bp = add_block(block); /* find or add a block with this name */
char sval[MAXLEN];
sprintf(sval,fmt,dval);
add_par(bp,name,sval,comment); /* Add the name = value pair Parameter */
return;
}
CFGBlock* start_new_block(VMMethod::Iterator& iter) {
if(!iter.last_instruction()) {
CFGBlock* blk = add_block(iter.next_position());
close_current(iter, blk);
return blk;
}
return 0;
}
/**
* 非阻塞读取数据
* return 读取的总数据,错误设置在g_errorno上
*/
ssize_t read_buffer( int fd, buffer_t *pbuf ) {
assert(fd >= 0);
assert( pbuf != NULL);
block_t *pb = NULL;
int n, total, size;
total = 0;
g_errno = 1; //无错误
NONREAD:
pb = pbuf->tail;
if ( NULL == pb || BLOCK_FULL(pb) ) {
if ( add_block( pbuf ) < 0 ) {
return -1;
}
pb = pbuf->tail;
}
size = BLOCK_REMAIN(pb); //空闲位置是 [end, BLOCK_DATA]
n = read( fd, BLOCK_READADDR(pb), size );
log_message( LOG_DEBUG, "read %d bytes from fd[%d]", n, fd );
if ( n > 0 ) {
g_errno = 1;
total += n;
pb->end += n;
pbuf->size += n; //待发送数据大小
if ( n == size ) {
goto NONREAD; //epoll的ET mode
}
}
else if ( 0 == n ) { //已经关闭读
g_errno = 0;
}
else {
switch (errno) {
#ifdef EWOULDBLOCK
case EWOULDBLOCK:
#else
# ifdef EAGAIN
case EAGAIN:
# endif
#endif
case EINTR:
g_errno = 1; //不是错误，本次读取结束，等待下次事件
break;
default:
g_errno = -1;
log_message( LOG_ERROR, "readbuff: recv() error \"%s\" on file descriptor %d", strerror(errno), fd);
}
}
return total;
}
static void
check_buffer(EFLOWDESC *ex, void *mdl)
{
/*
* lookup for a item in the hash table with sequence number = ex->next_seq.
* if found, repeat until not found
*/
block_t * block;
hash_iter_t iterator;
block = (block_t *)hash_lookup_ulong(ex->htable, ex->next_seq);
while (block != NULL) {
if (block->seq == ex->next_seq) { /* must ALWAYS be true :) */
add_block(ex, block, mdl);
unbuffer_block(ex, block->seq, block->len);
}
block = (block_t *)hash_lookup_ulong(ex->htable, ex->next_seq);
}
/*
* in case there are overlapped packets, iterate on the hash table to look
* for sequence numbers < ex->next_seq
*/
hash_iter_init(ex->htable, &iterator);
while (hash_iter_next (&iterator)) {
block = (block_t *)hash_iter_get_value(&iterator);
if (block->seq <= ex->next_seq) {
add_block(ex, block, mdl);
/*
* remove from hash with current key value, because the sequence
* number could have changed (in case of overlap with valid data),
* so no longer would coincide with the hash key
*/
unbuffer_block(ex, hash_iter_get_ulong_key(&iterator), block->len);
/* start again */
hash_iter_init(ex->htable, &iterator);
}
}
}
int _DEC_L(cmem *b,uint32 l){
int i;
if (l>0x7F){
OPCODE_6 op;
op.o1=0xFF;
op.o2=0x8D;
op.s=l;
add_block(b,(uint8*)&op,sizeof(OPCODE_6));
i=6;
}else{
OPCODE_3 op;
op.o1=0xFF;
op.o2=0x4D;
op.o3=(uint8)l&0xFF;
add_block(b,(uint8*)&op,sizeof(OPCODE_3));
i=3;
}
return i;
}
int _OP_LR(cmem *b,uint32 o,uint32 l,uint8 r){
int i;
if (o==_TEST){
OPCODE_6 op;
op.o1=0x85;
op.o2=0x85+8*r;
op.s=l;
add_block(b,(uint8*)&op,sizeof(OPCODE_6));
i=6;
}else{
OPCODE_6 op;
op.o1=0x01+o&0xFF;
op.o2=0x85+8*r;
op.s=l;
add_block(b,(uint8*)&op,sizeof(OPCODE_6));
i=6;
}
return i;
}
int _POP_L(cmem *b,uint32 l){
int i;
if (l>0x7F){
OPCODE_6 op;
op.o1=0x8F;
op.o2=0x85;
op.s=l;
add_block(b,(uint8*)&op,sizeof(OPCODE_6));
i=6;
}else{
OPCODE_3 op;
op.o1=0x8F;
op.o2=0x45;
op.o3=l;
add_block(b,(uint8*)&op,sizeof(OPCODE_3));
i=3;
}
return i;
}
int _LEA_RRA(cmem *b,uint8 r1,uint8 r2,uint32 l){
int i;
if (r2==_ESP){
OPCODE_3 op;
op.o1=0x8D;
op.o2=0x84+8*r1;
op.o3=0x24;
add_block(b,(uint8*)&op,sizeof(OPCODE_3));
add_block(b,(uint8*)&l,4);
i=7;
}else{
OPCODE_6 op;
op.o1=0x8D;
op.o2=0x80+8*r1+r2;
op.s=l;
add_block(b,(uint8*)&op,sizeof(OPCODE_6));
i=6;
}
return i;
}
t_node *add_trigger(t_context *C,const char *name,void*(* f)(t_brick *brick))
{
// BLOCK
t_node *node_block = add_block(C,"trigger");
t_block *block = ( t_block *) node_block->data;
// LABEL
add_brick_trigger(C,block,name,f);
return node_block;
}
isb_allocator_t
isba_create(int element_size)
{
isb_allocator_t res = RTmalloc(sizeof *res);
res->el_size = element_size;
res->max_blocks = INIT_MAX_BLOCKS;
res->blocks = RTmalloc(res->max_blocks*sizeof(int*));
res->num_block = 0;
add_block(res);
return res;
}
t_node *add_label(t_context *C,const char *name)
{
// BLOCK
t_node *node_block = add_block(C,"label");
t_block *block = ( t_block *) node_block->data;
// LABEL
add_brick_label(C,block,name);
return node_block;
}
t_node *add_switch(t_context *C,const char *name,void *data, void *(* f)( t_brick *brick))
{
// BLOCK
t_node *node_block = add_block(C,"switch");
t_block *block = ( t_block *) node_block->data;
// BRICK SWICH
add_brick_switch(C,block,name,data, f);
return node_block;
}
void setup(void) {
add_area("2.4.5");
set_short("Room wiht black walls");
set_long("A room with black walls. There is a door to the east, " +
"and a door to the west.");
/* Need to do door stuff here XXX */
add_exit("east", DIR + "/rooms/well.c");
add_exit("west", DIR + "/rooms/sub/after_trap.c");
add_block("east");
}
int gen_call(cmem *b,GEN_CALL *gc,cmem *in){
int l=0;
gc->offset=b->size;
int n_loc=(rnd()%20)*4+gc->loc*4+4;
l+=_PUSH_R(b,_EBP);
l+=_OP_RR(b,_MOV,_EBP,_ESP);
l+=_OP_RC(b,_SUB,_ESP,n_loc);
l+=in->size;
add_block(b,in->data,in->size);
l+=_LEAVE(b);
l+=_RET_C(b,gc->narg*4);
gc->len=l;
return l;
}
std::shared_ptr<Matrix> ASD<VecType>::compute_1e_prop(std::shared_ptr<const Matrix> hAA, std::shared_ptr<const Matrix> hBB, std::shared_ptr<const Matrix> hAB, const double core) const {
auto out = std::make_shared<Matrix>(dimerstates_, dimerstates_);
for (auto iAB = subspaces_.begin(); iAB != subspaces_.end(); ++iAB) {
const int ioff = iAB->offset();
for (auto jAB = subspaces_.begin(); jAB != iAB; ++jAB) {
const int joff = jAB->offset();
// TODO remove this comment once the gammaforst issue has been fixed (bra and ket have been exchanged)
std::array<MonomerKey,4> keys {{ jAB->template monomerkey<0>(), jAB->template monomerkey<1>(),
iAB->template monomerkey<0>(), iAB->template monomerkey<1>() }};
std::shared_ptr<Matrix> out_block = compute_offdiagonal_1e<true>(keys, hAB);
out->add_block(1.0, joff, ioff, out_block->ndim(), out_block->mdim(), out_block);
out->add_block(1.0, ioff, joff, out_block->mdim(), out_block->ndim(), out_block->transpose());
}
std::shared_ptr<const Matrix> tmp = compute_diagonal_1e(*iAB, hAA->data(), hBB->data(), core);
out->add_block(1.0, ioff, ioff, tmp->ndim(), tmp->mdim(), tmp);
}
return out;
}
int _OP_AR(cmem *b,uint32 o,uint32 a,uint8 r){
int i;
switch(o){
case _TEST:{
OPCODE_6 op;
op.o1=0x85;
op.o2=0x05+r*8;
op.s=a;
add_block(b,(uint8*)&op,sizeof(OPCODE_6));
i=6;
break;
}
default:{
OPCODE_6 op;
op.o1=0x01+o&0xFF;
op.o2=0x05+r*8;
op.s=a;
add_block(b,(uint8*)&op,sizeof(OPCODE_6));
i=6;
}
}
return i;
}
/*** Reads the next CHRS chunk from clipboard ***/
BOOL CBReadCHRS( void *jbuf, LINE *st, ULONG pos, LONG *nbl )
{
struct ContextNode * cn;
BOOL ret = FALSE;
/* If clipboard not already allocated, makes it now */
if( clip == NULL && !CBOpen(STD_CLIP_UNIT) ) return FALSE;
if( !OpenIFF(clip, IFFF_READ) )
{
if( !StopChunk(clip, ID_FTXT, ID_CHRS) )
{
if( !ParseIFF(clip, IFFPARSE_SCAN) )
{
cn = CurrentChunk(clip);
if( cn->cn_Type == ID_FTXT && cn->cn_ID == ID_CHRS && cn->cn_Size > 0 )
{
STRPTR buf;
ULONG size = cn->cn_Size;
if( (buf = (STRPTR) AllocVec(size, MEMF_PUBLIC)) )
{
UBYTE eol;
ReadChunkBytes(clip, buf, size);
/* What's kind of paste method shall we used? */
{ register STRPTR s; register ULONG n;
for(s=buf,n=size; --n && *s!='\n' && *s!='\r'; s++);
eol = *s;
}
/* Add string to the buffer */
reg_group_by(jbuf);
if(eol == '\n') add_string(jbuf,st,pos,buf,size,nbl) ;
else add_block (jbuf,st,pos,buf,size,nbl) ;
reg_group_by(jbuf);
FreeVec(buf);
ret = TRUE;
}
else ThrowError(Wnd, ErrMsg(ERR_NOMEM));
}
else ThrowError(Wnd, ErrMsg(ERR_NOTXTINCLIP));
}
else ThrowError(Wnd, ErrMsg(ERR_NOTXTINCLIP));
}
else ThrowError(Wnd, ErrMsg(ERR_NOMEM));
CloseIFF(clip);
}
/* ThrowError(Wnd, ErrMsg(ERR_READCLIP)); */
return ret;
}
/*
* coalesce - Boundary tag coalescing. Return ptr to coalesced block
*/
static void *coalesce(void *bp)
{
void *prev = PREV_BLKP(bp);
void *next = NEXT_BLKP(bp);
size_t prev_alloc = GET_ALLOC(HDRP(prev));
size_t next_alloc = GET_ALLOC(HDRP(next));
size_t size = GET_SIZE(HDRP(bp));
if (prev_alloc && next_alloc) { /* Case 1 */
add_block(bp);
return bp;
}
else if (prev_alloc && !next_alloc) { /* Case 2 */
delete_block(next);
size += GET_SIZE(HDRP(next));
set_size(bp, size);
add_block(bp);
return bp;
}
else if (!prev_alloc && next_alloc) { /* Case 3 */
delete_block(prev);
size += GET_SIZE(HDRP(prev));
set_size(prev, size);
add_block(prev);
return prev;
}
else { /* Case 4 */
delete_block(next);
delete_block(prev);
size += GET_SIZE(HDRP(prev)) +
GET_SIZE(HDRP(next));
set_size(prev, size);
add_block(prev);
return prev;
}
}
void ChiPlotDataSet::load_data(std::istream &f)
{
string graph_title = trim_label(read_line(f));
string x_label = trim_label(read_line(f));
string y_label = trim_label(read_line(f));
string line = read_line(f);
string::size_type pos = line.find(',');
if (pos != string::npos)
line[pos] = ' ';
int n_points, n_ycols;
int r = sscanf(line.c_str(), "%d %d", &n_points, &n_ycols);
if (r == 1)
n_ycols = 1;
else if (r != 2)
throw FormatError("expected number(s) in line 4");
if (n_points <= 0 || n_ycols <= 0)
throw FormatError("expected positive number(s) in line 4");
vector<VecColumn*> cols(n_ycols + 1);
for (size_t i = 0; i != cols.size(); ++i)
cols[i] = new VecColumn;
try {
for (int i = 0; i != n_points; ++i) {
line = read_line(f);
const char* p = line.c_str();
for (int j = 0; j != n_ycols + 1; ++j) {
char *endptr = NULL;
while (isspace(*p) || *p == ',')
++p;
double val = strtod(p, &endptr);
if (endptr == p)
throw FormatError("line " + S(5+i) + ", column " + S(j+1));
cols[j]->add_val(val);
p = endptr;
}
}
}
catch (std::exception&) {
purge_all_elements(cols);
throw;
}
Block *blk = new Block;
blk->set_name(graph_title);
cols[0]->set_name(x_label);
cols[1]->set_name(y_label);
for (size_t i = 0; i != cols.size(); ++i)
blk->add_column(cols[i]);
add_block(blk);
}
void TreeSystem::make_ground(
float thickness,
float base_angle,
float delta_angle,
const sf::Color& base_color,
const ColorTransform& deltas)
{
const float density_factor = 1.5;
const float block_w = 5;
const float block_h = 1;
const float block_area = block_w * block_h;
const float underground_depth = 5;
auto phys = physicsDimensions();
auto phys2 = physicsHalfDimensions();
const float area = (thickness + underground_depth) * phys.x;
const unsigned density = (area * density_factor) / block_area;
blocks.reserve(blocks.size() + density + 1);
polygonDef def;
def.bodyDef.active = false;
def.bodyDef.fixedRotation = true;
def.bodyDef.type = b2_staticBody;
def.shape.SetAsBox(phys2.x, thickness/2);
def.bodyDef.angle = 0;
def.bodyDef.position.Set(phys2.x, phys.y - (thickness/2));
blocks.emplace_back(
make_shape(world(), def),
base_color);
def.shape.SetAsBox(block_w, block_h);
addProgress(1);
const b2Vec2 topLeft(0, phys.y - thickness);
const b2Vec2 bottomRight(phys.x, phys.y + underground_depth);
maxProgress(blocks.size() + density + 1);
setProgress(blocks.size());
for(int i = 0; i < density; ++i)
{
def.bodyDef.position = random_in(topLeft, bottomRight);
def.bodyDef.angle = to_radians(randcentered(base_angle, delta_angle));
add_block(def, deltas.apply(base_color));
addProgress(1);
}
}
uint64_t BlockchainDB::add_block( const block& blk
, const size_t& block_size
, const difficulty_type& cumulative_difficulty
, const uint64_t& coins_generated
, const std::vector<transaction>& txs
)
{
// sanity
if (blk.tx_hashes.size() != txs.size())
throw std::runtime_error("Inconsistent tx/hashes sizes");
block_txn_start(false);
TIME_MEASURE_START(time1);
crypto::hash blk_hash = get_block_hash(blk);
TIME_MEASURE_FINISH(time1);
time_blk_hash += time1;
uint64_t prev_height = height();
// call out to add the transactions
time1 = epee::misc_utils::get_tick_count();
add_transaction(blk_hash, blk.miner_tx);
int tx_i = 0;
crypto::hash tx_hash = crypto::null_hash;
for (const transaction& tx : txs)
{
tx_hash = blk.tx_hashes[tx_i];
add_transaction(blk_hash, tx, &tx_hash);
++tx_i;
}
TIME_MEASURE_FINISH(time1);
time_add_transaction += time1;
// call out to subclass implementation to add the block & metadata
time1 = epee::misc_utils::get_tick_count();
add_block(blk, block_size, cumulative_difficulty, coins_generated, blk_hash);
TIME_MEASURE_FINISH(time1);
time_add_block1 += time1;
m_hardfork->add(blk, prev_height);
block_txn_stop();
++num_calls;
return prev_height;
}
t_node *add_slider_char(t_context *C,const char *name,void *target_data)
{
// NEW BLOCK
t_node *node_block = add_block(C,name);
t_block *block = ( t_block *) node_block->data;
// NEW BRICK
t_node *node_brick=add_brick_slider_char(C,block,name,target_data);
t_brick *brick = ( t_brick *) node_brick->data;
// SET ACTION
brick->exe=op_slider;
return node_block;
}
// Same preconditions as 'segregate'
// Post: !empty()
void add_ordered_block(void * const block,
const size_type nsz, const size_type npartition_sz)
{
// This (slower) version of add_block segregates the
// block and merges its free list into our free list
// in the proper order
// Find where "block" would go in the free list
void * const loc = find_prev(block);
// Place either at beginning or in middle/end
if (loc == 0)
add_block(block, nsz, npartition_sz);
else
nextof(loc) = segregate(block, nsz, npartition_sz, nextof(loc));
}
void *ws_malloc_i(size_t size, const char *file, int line)
{
WsMemBlockHdr *b;
if (alloc_number++ >= num_successful_allocs)
return NULL;
b = malloc(SIZE(size));
if (b == NULL)
return NULL;
add_block(b, size, file, line);
return b + 1;
}
t_node *add_slider_float(t_context *C,const char *name,void *target_data)
{
// NEW BLOCK
t_node *node_block = add_block(C,name);
t_block *block = ( t_block *) node_block->data;
block->block_state.draw_outline = 1;
// NEW BRICK
t_node *node_brick=add_part_slider_float(C,block,name,target_data);
t_brick *brick = ( t_brick *) node_brick->data;
// SET ACTION
brick->act=op_slider;
return node_block;
}
t_node *add_brick_geo_edge(t_context *C,const char *name, void *data)
{
// NEW BLOCK
t_node *node_block = add_block(C,name);
t_block *block = ( t_block *) node_block->data;
block->block_state.draw_outline = 1;
// GEO POINT
add_brick_geo_point_bare(C,block,"point",NULL,1);
add_brick_geo_point_bare(C,block,"point",NULL,2);
// GEO EDGE
add_part_geo(C,block,"edge",data,dt_geo_edge);
return node_block;
}
