/*
* Lockfree
*/
int
lockfree_push_queue(QUEUE *queue, const void *item)
{
struct queue_node *n;
struct queue_node *node = malloc(sizeof(struct queue_node) + queue->item_size);
node->next = NULL;
//node->item = item;
node->item = node + sizeof(struct queue_node);
memcpy(&node->item, &item, queue->item_size);
while (1)
{
n = queue->tail;
if (_cas(&(n->next), NULL, node))
break;
else
_cas(&(queue->tail), n, n->next);
}
_cas(&(queue->tail), n, node);
_inc(&queue->size);
return 1;
}
void emplace_back(Args &&... args) {
if (_is_empty) {
_is_empty = false;
} else {
_inc();
}
new (_get_ptr()) T(std::forward<Args>(args)...);
}
/*
* Executes a given instruction, or errors out
* ins - instruction to run
*/
void
execute (unsigned short int ins)
{
/* seperate instruction into parts */
short int a0 = (ins >> 12) % 16;
short int a1 = (ins >> 8) % 16;
short int a2 = (ins >> 4) % 16;
short int a3 = (ins >> 0) % 16;
/* Run associated instruction */
switch(a0) {
case 0x0:
_add (a1, a2, a3);
break;
case 0x1:
_sub (a1, a2, a3);
break;
case 0x2:
_mul (a1, a2, a3);
break;
case 0x3:
_div (a1, a2, a3);
break;
case 0x6:
_beq (a1, a2, a3);
break;
case 0x7:
_bgt (a1, a2, a3);
break;
case 0x8:
_ld (a1, a2, a3);
break;
case 0x9:
_st (a1, a2, a3);
break;
case 0xa:
_lc (a1, a3);
break;
case 0xb:
_jmp (a1, a3);
break;
case 0xc:
_inc (a1, a3);
break;
case 0xf:
_sys (a1, a3);
break;
default:
printf ("Error: invalid opcode %#x.\n", a0);
sys_dump (0x0);
sys_halt (0x0);
}
}
// Allocate and initialize tunnel connection State object
struct telex_state *StateInit(struct telex_conf *conf)
{
struct telex_state *state;
_inc(STATE); state = calloc(1, sizeof(struct telex_state));
assert(state);
state->conf = conf;
state->id = state->conf->count_tunnels++;
state->conf->count_open_tunnels++;
state->start_ms = time_ms();
snprintf(state->name, sizeof(state->name), "tunnel %u", state->id);
// Random conn_id
get_random_conn_id(state);
LogInfo(state->name, "Opened (%u active)", state->conf->count_open_tunnels);
return state;
}
static gboolean _key_release_event(GtkWidget *widget,
GdkEventKey *event,
gpointer data)
{
(void)widget;
(void)data;
//*
switch(event->keyval) {
case GDK_Left :
case GDK_Right :
case GDK_Up :
case GDK_Down :_scroll(event); break;
case GDK_equal :
case GDK_plus :
case GDK_minus :_rotation(event); break;
case GDK_Page_Down:
case GDK_Page_Up:_zoom(event); break;
// case GDK_KEY_Escape:_resetView(&_engine.state); break;
case GDK_r : //gtk_widget_draw(widget, NULL);
break;
// case GDK_KEY_h :_doRenderHelp = !_doRenderHelp;
// _usage("s52gtk2");
// break;
case GDK_v :g_print("%s\n", S52_version()); break;
case GDK_x :_dumpParam(); break;
case GDK_q :gtk_main_quit(); break;
case GDK_w :_toggle(S52_MAR_TWO_SHADES); break;
case GDK_s :_toggle(S52_MAR_SHALLOW_PATTERN); break;
case GDK_o :_toggle(S52_MAR_SHIPS_OUTLINE); break;
case GDK_l :_toggle(S52_MAR_FULL_SECTORS); break;
case GDK_b :_toggle(S52_MAR_SYMBOLIZED_BND); break;
case GDK_p :_toggle(S52_MAR_SYMPLIFIED_PNT); break;
case GDK_n :_toggle(S52_MAR_FONT_SOUNDG); break;
case GDK_u :_toggle(S52_MAR_SCAMIN); break;
case GDK_i :_toggle(S52_MAR_ANTIALIAS); break;
case GDK_j :_toggle(S52_MAR_QUAPNT01); break;
case GDK_z :_toggle(S52_MAR_DISP_OVERLAP); break;
//case GDK_1 :_toggle(S52_MAR_DISP_LAYER_LAST); break;
case GDK_1 :_meterInc(S52_MAR_DISP_LAYER_LAST);break;
case GDK_exclam:_meterDec(S52_MAR_DISP_LAYER_LAST);break;
case GDK_2 :_inc(S52_MAR_ROT_BUOY_LIGHT); break;
case GDK_3 :_toggle(S52_MAR_DISP_CRSR_POS);
_toggle(S52_MAR_DISP_LEGEND);
_toggle(S52_MAR_DISP_CALIB);
_toggle(S52_MAR_DISP_DRGARE_PATTERN);
break;
case GDK_4 :_toggle(S52_MAR_DISP_GRATICULE); break;
case GDK_5 :_toggle(S52_MAR_HEADNG_LINE); break;
//case GDK_t :_meterInc(S52_MAR_SHOW_TEXT); break;
//case GDK_T :_meterDec(S52_MAR_SHOW_TEXT); break;
case GDK_t :
case GDK_T :_toggle (S52_MAR_SHOW_TEXT); break;
case GDK_c :_meterInc(S52_MAR_SAFETY_CONTOUR); break;
case GDK_C :_meterDec(S52_MAR_SAFETY_CONTOUR); break;
case GDK_d :_meterInc(S52_MAR_SAFETY_DEPTH); break;
case GDK_D :_meterDec(S52_MAR_SAFETY_DEPTH); break;
case GDK_a :_meterInc(S52_MAR_SHALLOW_CONTOUR);break;
case GDK_A :_meterDec(S52_MAR_SHALLOW_CONTOUR);break;
case GDK_e :_meterInc(S52_MAR_DEEP_CONTOUR); break;
case GDK_E :_meterDec(S52_MAR_DEEP_CONTOUR); break;
case GDK_f :_meterInc(S52_MAR_DISTANCE_TAGS); break;
case GDK_F :_meterDec(S52_MAR_DISTANCE_TAGS); break;
case GDK_g :_meterInc(S52_MAR_TIME_TAGS); break;
case GDK_G :_meterDec(S52_MAR_TIME_TAGS); break;
case GDK_y :_meterInc(S52_MAR_BEAM_BRG_NM); break;
case GDK_Y :_meterDec(S52_MAR_BEAM_BRG_NM); break;
case GDK_m :_meterInc(S52_MAR_DATUM_OFFSET); break;
case GDK_M :_meterDec(S52_MAR_DATUM_OFFSET); break;
//case GDK_7 :_disp(S52_MAR_DISP_CATEGORY, 'D'); break; // DISPLAYBASE
//case GDK_8 :_disp(S52_MAR_DISP_CATEGORY, 'S'); break; // STANDARD
//case GDK_9 :_disp(S52_MAR_DISP_CATEGORY, 'O'); break; // OTHER
//case GDK_0 :_disp(S52_MAR_DISP_CATEGORY, 'A'); break; // OTHER (all)
//case GDK_7 :_disp(S52_MAR_DISP_CATEGORY, 0); break; // DISPLAYBASE
//case GDK_8 :_disp(S52_MAR_DISP_CATEGORY, 1); break; // STANDARD
//case GDK_9 :_disp(S52_MAR_DISP_CATEGORY, 2); break; // OTHER
//case GDK_0 :_disp(S52_MAR_DISP_CATEGORY, 3); break; // OTHER (all)
case GDK_7 :_disp(S52_MAR_DISP_CATEGORY, S52_MAR_DISP_CATEGORY_BASE); break; // DISPLAYBASE
case GDK_8 :_disp(S52_MAR_DISP_CATEGORY, S52_MAR_DISP_CATEGORY_STD); break; // STANDARD
case GDK_9 :_disp(S52_MAR_DISP_CATEGORY, S52_MAR_DISP_CATEGORY_OTHER); break; // OTHER
case GDK_0 :_disp(S52_MAR_DISP_CATEGORY, S52_MAR_DISP_CATEGORY_SELECT); break; // OTHER (all)
case GDK_k :_cpal(S52_MAR_COLOR_PALETTE, 1.0);break;
case GDK_K :_cpal(S52_MAR_COLOR_PALETTE, -1.0);break;
case GDK_6 :_meterInc(S52_MAR_DISP_WHOLIN); break;
case GDK_asciicircum:
case GDK_question:
case GDK_caret :_meterDec(S52_MAR_DISP_WHOLIN); break;
//case GDK_3 :_cpal("S52_MAR_COLOR_PALETTE", 2.0); break; // DAY_WHITEBACK
//case GDK_4 :_cpal("S52_MAR_COLOR_PALETTE", 3.0); break; // DUSK
//case GDK_5 :_cpal("S52_MAR_COLOR_PALETTE", 4.0); break; // NIGHT
//case GDK_F1 :S52_doneCell("/home/vitaly/CHARTS/for_sasha/GB5X01SE.000"); break;
//case GDK_F2 :S52_doneCell("/home/vitaly/CHARTS/for_sasha/GB5X01NE.000"); break;
case GDK_F1 :S52_setMarinerParam(S52_CMD_WRD_FILTER, S52_CMD_WRD_FILTER_SY); break;
case GDK_F2 :S52_setMarinerParam(S52_CMD_WRD_FILTER, S52_CMD_WRD_FILTER_LS); break;
case GDK_F3 :S52_setMarinerParam(S52_CMD_WRD_FILTER, S52_CMD_WRD_FILTER_LC); break;
case GDK_F4 :S52_setMarinerParam(S52_CMD_WRD_FILTER, S52_CMD_WRD_FILTER_AC); break;
case GDK_F5 :S52_setMarinerParam(S52_CMD_WRD_FILTER, S52_CMD_WRD_FILTER_AP); break;
case GDK_F6 :S52_setMarinerParam(S52_CMD_WRD_FILTER, S52_CMD_WRD_FILTER_TX); break;
case GDK_F7 :_mmInc(S52_MAR_DOTPITCH_MM_X); break;
case GDK_F8 :_mmInc(S52_MAR_DOTPITCH_MM_Y); break;
case GDK_F9 :_toggle(S52_MAR_DISP_NODATA_LAYER); break;
default:
g_print("key: 0x%04x\n", event->keyval);
}
//*/
// redraw
_engine.do_S52draw = TRUE;
return TRUE;
}
// This starts a new TCP/TLS connection to notblocked
// It is called both when a new local proxy connection is accepted
// and when we need to re-open an existing telex transport (state->local is reused)
void make_new_telex_conn(struct telex_state *state)
{
struct telex_conf *conf = state->conf;
HexDump(LOG_TRACE, state->name, "Opening telex id:", state->remote_conn_id, sizeof(state->remote_conn_id));
state->remotetcp = bufferevent_socket_new(state->base, -1,
BEV_OPT_CLOSE_ON_FREE|BEV_OPT_DEFER_CALLBACKS);
if (!state->remotetcp) {
LogError(state->name, "Could not create remote bufferevent socket");
StateCleanup(&state);
return;
}
_inc(BEV);
// TODO: make nonblocking lookup?
bufferevent_socket_connect_hostname(state->remotetcp, NULL, AF_INET, conf->notblocked_host, conf->notblocked_port);
// After resolution...
/*
struct sockaddr_in sin;
if (getpeername(bufferevent_getfd(state->remotetcp), (struct sockaddr *)&sin, (socklen_t*)sizeof(sin)) < 0) {
perror("getpeername");
LogError("proxy", "getpeername failed");
StateCleanup(&state);
return;
}
char ip_p[INET_ADDRSTRLEN];
LogTrace(state->name, "Connecting to %s:%d",
evutil_inet_ntop(AF_INET, server_ip, ip_p, sizeof(ip_p)), state->conf->notblocked_port);
//bufferevent_socket_connect(state->remotetcp, ai->ai_addr, (int)ai->ai_addrlen);
*/
if (ssl_new_telex(state) < 0) {
ssl_log_errors(LOG_ERROR, state->name);
LogError(state->name, "Could not create new telex SSL connection object");
StateCleanup(&state);
return;
}
_inc(SSL);
state->remote = bufferevent_openssl_filter_new(state->base, state->remotetcp,
state->ssl, BUFFEREVENT_SSL_CONNECTING, BEV_OPT_DEFER_CALLBACKS);
// Not BEV_OPT_CLOSE_ON_FREE!
if (!state->remote) {
LogError(state->name, "Could not create remote SSL bufferevent filter");
StateCleanup(&state);
return;
}
_inc(BEV);
// First, set our read_cb to something that receives the SPTelex init message
bufferevent_setcb(state->remote, (bufferevent_data_cb)first_read_cb, NULL,
(bufferevent_event_cb)event_cb, state);
// Disable until SPTelex init msg
bufferevent_disable(state->local, EV_READ|EV_WRITE);
bufferevent_setcb(state->local, (bufferevent_data_cb)read_cb, NULL,
(bufferevent_event_cb)event_cb, state);
// Hmm...we should make a second one of these
state->in_local = 0;
}
void VMDriver::execute(){
if( this->m_state == STATE_IDLE ){
printf( "Error: state is idle. \n");
return;
}
assert( this->currentAssembly() );
while( this->isActive() ){
if( this->isBreak() ){
break;
}
unsigned char content = this->getByte( m_funcAddr , m_pc );
m_pc++;
switch( content ){
case EMnemonic::MovPtr :
_mov_ptr();
break;
case EMnemonic::Mov :
_mov();
break;
case EMnemonic::Add :
_add();
break;
case EMnemonic::Sub :
_sub();
break;
case EMnemonic::Mul :
_mul();
break;
case EMnemonic::Div :
_div();
break;
case EMnemonic::Rem :
_rem();
break;
case EMnemonic::Inc :
_inc();
break;
case EMnemonic::Dec :
_dec();
break;
case EMnemonic::Push :
_push();
break;
case EMnemonic::PushPtr :
_push_ptr();
break;
case EMnemonic::Pop :
_pop();
break;
case EMnemonic::Call :
_call();
break;
case EMnemonic::ST :
_st();
break;
case EMnemonic::LD :
_ld();
break;
case EMnemonic::EndFunc :
_endFunc();
break;
case EMnemonic::CmpGeq :
case EMnemonic::CmpG :
case EMnemonic::CmpLeq :
case EMnemonic::CmpL :
case EMnemonic::CmpEq :
case EMnemonic::CmpNEq :
_cmp( content );
break;
case EMnemonic::Not :
_not();
break;
case EMnemonic::Minus :
_minus();
break;
case EMnemonic::LogOr :
case EMnemonic::LogAnd :
_log( content );
break;
case EMnemonic::Jmp :
_jmp();
break;
case EMnemonic::JumpZero :
_jumpzero();
break;
case EMnemonic::JumpNotZero :
_jumpnotzero();
break;
case EMnemonic::RET :
_ret();
break;
}
}
}
const ATextOdometer& ATextOdometer::operator ++(void)
{
_inc();
return *this;
}
const ATextOdometer ATextOdometer::operator ++(int)
{
ATextOdometer cRet(*this);
_inc();
return cRet;
}
