示例#1
0
void *dlopen(const char* pathname, int mode)
{
    message_start();
    message_string("Warning: dummy dlopen called with argument `");
    message_string(pathname);
    message_string("'.\n");
    message_string(" The statically-linked runtime has failed to load this library.");
    message_end();
    return 0;
}
示例#2
0
// ---------------------------------------------------------------------------
// Constructeur
// ------------
bStdAlert::bStdAlert(int kind, 
					 int def_btn, 
					 bool has_cancel, 
					 const char* error_string, 
					 const char* explanation_string,
					 bool silent,
					 UInt32 delay){
	_res=false;
	
	if(silent){
fprintf(stderr,"ALERT : %s\n",error_string);
fprintf(stderr,"%s\n",explanation_string);
		_res=true;
		return;
	}
	
AlertStdCFStringAlertParamRec	prm;
	
    (void)GetStandardAlertDefaultParams(&prm,kStdCFStringAlertVersionOne);

	prm.defaultButton=def_btn;
	if(def_btn==kAlertStdAlertOKButton){
		prm.cancelButton=kAlertStdAlertCancelButton;
	}
	else if(def_btn==kAlertStdAlertCancelButton){
		prm.cancelButton=kAlertStdAlertOKButton;
	}
	
char	msg[__MESSAGE_STRING_LENGTH_MAX__];
	message_string(kMsgOk,msg,1);
	prm.defaultText=CFStringCreateWithCString(kCFAllocatorDefault,msg,kCFStringEncodingMacRoman);
	if(has_cancel){
		message_string(kMsgCancel,msg,1);
		prm.cancelText=CFStringCreateWithCString(kCFAllocatorDefault,msg,kCFStringEncodingMacRoman);
	}
	
CFStringRef	err=CFStringCreateWithCString(kCFAllocatorDefault,error_string,kCFStringEncodingMacRoman);
CFStringRef	exp=CFStringCreateWithCString(kCFAllocatorDefault,explanation_string,kCFStringEncodingMacRoman);

DialogRef	alrt;
	
    (void)CreateStandardAlert(kind,err,exp,&prm,&alrt);
		
	SetDialogTimeout(alrt,def_btn,delay);
	
    (void)RunStandardAlert(alrt,NULL,&_hit);
	
	_res=(_hit==def_btn);
	CFRelease(err);
	CFRelease(exp);		
}
// ---------------------------------------------------------------------------
// 
// ------------
void bvDefScaleRef::wd_init(WindowRef wd){
	_idx=1;
	read();
	
ControlRef	c;
	if(_set==1){
		c=get_control(kvDefScaleRefViewSignature,kvDefScaleRefTypeNameLegendID);
		HideControl(c);
		c=get_control(kvDefScaleRefViewSignature,kvDefScaleRefTypeNameID);
		HideControl(c);
	}
	else{
		c=get_control(kvDefScaleRefViewSignature,kvDefScaleRefTypeNameID);
char		name[256];
		if(_tp){
			_tp->name(name);
		}
		else{
			message_string(kMsgVirtual,name,1);
		}
		SetTextControlValue(c,name);
	}
	
	c=get_control(kvDefScaleRefViewSignature,kvDefScaleRefPopupID);
	PopulatePopupControlWithScales(_gapp,c,_idx);
}
// ---------------------------------------------------------------------------
// 
// -----------
void bToolPrintArea::set_as_ppsz(WindowRef wd){
ControlRef	c;
ControlID	cid={kPrintAreaSignature,0};
i2dvertex	ivxa={_vxr.left,_vxr.bottom};
i2dvertex	ivxb={_vxr.right,_vxr.top};
CGPoint		pa,pb;
char		val[256];
float		m;

	Convert(&pa,&ivxa);
	Convert(&pb,&ivxb);

	cid.id=kPrintAreaWID;
	GetControlByID(wd,&cid,&c);
	m=pb.x-pa.x;
	m*=(2.54/72.0);
	sprintf(val,"%.2f",m);
	SetTextControlValue(c,val);

	cid.id=kPrintAreaHID;
	GetControlByID(wd,&cid,&c);
	m=pb.y-pa.y;
	m*=(2.54/72.0);
	sprintf(val,"%.2f",m);
	SetTextControlValue(c,val);

	message_string(kMsgCentimetersAB,val,0);
	for(int i=kPrintAreaWUnitID;i<=kPrintAreaHUnitID;i++){
		cid.id=i;
		GetControlByID(wd,&cid,&c);
		SetTextControlValue(c,val);
	}
}
示例#5
0
PFPSimDebugger::DebugMsg* DebuggerIPCServer::recv() {
  struct nn_pollfd pfd;
  pfd.fd     = socket;
  pfd.events = NN_POLLIN;

  auto rc = nn_poll(&pfd, 1, 100);
  if (rc == 0) {
    return nullptr;
  }

  if (rc == -1) {
    // TODO(gordon)
    printf("Error!");
    exit(1);
  }

  if (pfd.revents & NN_POLLIN) {
    char *buf;
    int bytes = nn_recv(socket, &buf, NN_MSG, 0);
    if (bytes != -1) {
      std::string message_string(buf, bytes);
      nn_freemsg(buf);

      PFPSimDebugger::DebugMsg *message = new PFPSimDebugger::DebugMsg();
      message->ParseFromString(message_string);
      return message;
    } else {
      return nullptr;
    }
  } else {
    return nullptr;
  }
}
示例#6
0
void LLMessageTemplateParserTestObject::test<4>()
// tests variable parsing method
{
    LLTemplateTokenizer tokens(std::string("{    Test0  \n\t\n   U32 \n\n }"));
    LLMessageVariable * var = LLTemplateParser::parseVariable(tokens);

    ensure("test0 var parsed", var != 0);
    ensure_equals("name of variable", std::string(var->getName()), std::string("Test0"));
    ensure_equals("type of variable is U32", var->getType(), MVT_U32);
    ensure_equals("size of variable", var->getSize(), 4);

    delete var;

    std::string message_string("\n\t{ \t   Test1 Fixed \n 523 }\n\n");
    tokens = LLTemplateTokenizer(message_string);
    var = LLTemplateParser::parseVariable(tokens);

    ensure("test1 var parsed", var != 0);
    ensure_equals("name of variable", std::string(var->getName()), std::string("Test1"));
    ensure_equals("type of variable is Fixed", var->getType(), MVT_FIXED);
    ensure_equals("size of variable", var->getSize(), 523);

    delete var;

    // *NOTE: the parsers call llerrs on invalid input, so we can't really
    // test that  :-(
}
// ---------------------------------------------------------------------------
//
// ------------
bool bXMapCloneDetector::detect(clonedetector_prm* prm){
bArray				sel(*(_gapp->selMgr()->elements()));
bArray*				arr;
char				msg[__MESSAGE_STRING_LENGTH_MAX__];
    message_string(kMsgProgress,msg,1);
bProgressWait wt("",msg,true,true,sel.count());
    _gapp->cntMgr()->flush();
    
bGenericGeoElement	*oa,*ob;
bGenericType*		tp;
ivx_rect			vxr;
int					i,j;
bool				flg=false;
    
    for(i=1;i<=sel.count();i++){
        if(!wt.set_progress(i)){
            break;
        }
        sel.get(i,&oa);
        if(oa->contrasted()){
            continue;
        }
        tp=_gapp->typesMgr()->get(oa->getType());
        oa->getBounds(&vxr);
        tp->iterator()->objs_in_rect(&arr,&vxr);
        if(!arr){
            continue;
        }
        for(j=1;j<=arr->count();j++){
            arr->get(j,&ob);
            if(oa==ob){
                continue;
            }
            if(ob->contrasted()){
                continue;
            }
            if(obj_comp(oa,ob,prm)){
                flg=true;
                if(ob->masked()){
                    ob->setmasked(false,true);
                }
                ob->setcontrast(true,true);
            }
        }
        delete arr;
    }
    if(flg){
        b_message_string(kXMapCloneFoundMessageID,msg,getbundle(),0);
    }
    else{
        b_message_string(kXMapNoCloneFoundMessageID,msg,getbundle(),0);
    }
bAlertStop	alrt(msg,"");
    return(true);
}
示例#8
0
void context_lua_t::on_received(message_t& message)
{
	switch (message_raw_type(message)) {
	case LUA_CTX_INIT:
		lua_ctx_init(message);
		return;
	case CONTEXT_QUERY:
		response_context_query(message);
		break;
	case CONTEXT_REPLY:
		response_context_reply(message);
		break;
	case LUA_CTX_WAIT:
		response_context_wait(message);
		break;
	case LUA_CTX_WAKEUP:
		response_context_wakeup(message);
		break;
	case RESPONSE_TCP_LISTEN:
		response_tcp_listen(message);
		break;
	case RESPONSE_TCP_ACCEPT:
		response_tcp_accept(message);
		break;
	case RESPONSE_TCP_CONNECT:
		response_tcp_connect(message);
		break;
	case RESPONSE_TCP_READ:
		response_tcp_read(message);
		break;
	case RESPONSE_TCP_WRITE:
		response_tcp_write(message);
		break;
	case RESPONSE_HANDLE_CLOSE:
		response_handle_close(message);
		break;
	case RESPONSE_TCP_CLOSING:
		response_tcp_closing(message);
		break;
	case RESPONSE_TIMEOUT:
		response_timeout(message);
		break;
	case SYSTEM_CTX_DESTROY:
		singleton_ref(node_lua_t).context_destroy(this, message.m_source, message_string(message));
		return;
	default:
		break;
	}
	if (!is_active()) {
		singleton_ref(node_lua_t).context_destroy(this, m_handle, "lua context exit normally");
	}
}
示例#9
0
void context_lua_t::lua_pushmessage(lua_State *L, message_t& message)
{
	message_array_t *array = NULL;
	switch (message_data_type(message)) {
	case NIL:
		lua_pushnil(L);
		return;
	case TBOOLEAN:
		lua_pushboolean(L, message_bool(message));
		return;
	case USERDATA:
		lua_pushlightuserdata(L, message_userdata(message));
		return;
	case NUMBER:
		lua_pushnumber(L, message_number(message));
		return;
	case INTEGER:
		lua_pushinteger(L, message_integer(message));
		return;
	case BUFFER:
		create_buffer(L, message_buffer(message));
		return;
	case STRING:
		lua_pushstring(L, message_string(message));
		return;
	case BSON:
		if (message_bson(message)->extract) {
			bson_decode(message_bson(message), L);
		} else {
			create_bson(message_bson(message), L);
		}
		return;
	case TERROR:
		lua_pushinteger(L, message_error(message));
		return;
	case ARRAY:
		array = message_array(message);
		if (array != NULL && array->m_count > 0) {
			for (int32_t i = 0; i < array->m_count; ++i) { //extract them
				lua_pushmessage(L, array->m_array[i]);
			}
		} else {
			lua_pushnil(L);
		}
		return;
	default:
		lua_pushnil(L);
		return;
	}
}
示例#10
0
// ---------------------------------------------------------------------------
// 
// -----------
bool bMacMapType::load(){
_bTrace_("bMacMapType::load",true);
bool		k,b;
long		i,n;
char		cftitle[__MESSAGE_STRING_LENGTH_MAX__],cfprompt[__MESSAGE_STRING_LENGTH_MAX__];
	
_tm_(_idx+" "+_name);

	message_string(kMsgOpen,cftitle,true);
	strcpy(cfprompt,_name);
	
	k=true;
	n=_bse.count_records();

bProgressWait	wait(cftitle,cfprompt,true,true,n);
	
	for(i=1;i<=n;i++){
		if(!wait.set_progress(i)){
			_iter->flush();
			break;
		}
		if(!load_object(i,&b)){
			k=false;
_te_("false at load_object "+i);
			break;
		}
		if(!b){
			continue;
		}
	}
	
	if(k){
		_iter->start();
		
		_bounds.top=_bounds.left=_bounds.bottom=_bounds.right;
		_iter->iterate(&_bounds,get_rect);
		_iter->set_bounds(&_bounds);
	}
	
	
	(void)_styles->load();
		
	return(k);
}
示例#11
0
static void ReportException(Environment* env, v8::Handle<v8::Value> er, v8::Handle<v8::Message> message)
{
    v8::HandleScope scope(env->isolate());

    AppendExceptionLine(env, er, message);

    v8::Local<v8::Value> trace_value;

    if (er->IsUndefined() || er->IsNull())
        trace_value = Undefined(env->isolate());
    else
        trace_value = er->ToObject()->Get(env->stack_string());

    v8::String::Utf8Value trace(trace_value);

    // range errors have a trace member set to undefined
    if (trace.length() > 0 && !trace_value->IsUndefined()) {
        fprintf(stderr, "%s\n", *trace);
    } else {
        // this really only happens for RangeErrors, since they're the only
        // kind that won't have all this info in the trace, or when non-Error
        // objects are thrown manually.
        v8::Local<v8::Value> message;
        v8::Local<v8::Value> name;

        if (er->IsObject()) {
            v8::Local<v8::Object> err_obj = er.As<v8::Object>();
            message = err_obj->Get(env->message_string());
            name = err_obj->Get(FIXED_UTF8_STRING(env->isolate(), "name"));
        }

        if (message.IsEmpty() || message->IsUndefined() || name.IsEmpty() || name->IsUndefined()) {
            // Not an error object. Just print as-is.
            v8::String::Utf8Value message(er);
            fprintf(stderr, "%s\n", *message);
        } else {
            v8::String::Utf8Value name_string(name);
            v8::String::Utf8Value message_string(message);
            fprintf(stderr, "%s: %s\n", *name_string, *message_string);
        }
    }

    fflush(stderr);
}
示例#12
0
// ---------------------------------------------------------------------------
// 
// ------------
void bXMapReverse::reverse(int dummy){
ivertices*			vxs;
bGenericGeoElement*	o;
bArray				sel(*(_gapp->selMgr()->elements()));
char				mess[__MESSAGE_STRING_LENGTH_MAX__];
	message_string(kMsgProgress,mess,1);
bProgressWait		wt("",mess,true,false,sel.count());

	_gapp->layersMgr()->SetObjInvalidation(false);
	for(int i=1;i<=sel.count();i++){
		if(!wt.set_progress(i)){
			break;
		}
		sel.get(i,&o);
		o->getVertices(&vxs);
		ivs_reverse(vxs);
		o->setVertices(vxs);
	}
	_gapp->layersMgr()->SetObjInvalidation(true);
}
示例#13
0
void ZmqServer::serve()
{

  while (1)
  {
    try
    {
      zmq::message_t message;

      if (!rep_socket)
      {
        throw std::runtime_error("ZMQ RPC server reply socket is null");
      }
      while (rep_socket->recv(&message))
      {
        std::string message_string(reinterpret_cast<const char *>(message.data()), message.size());

        MDEBUG(std::string("Received RPC request: \"") + message_string + "\"");

        std::string response = handler.handle(message_string);

        zmq::message_t reply(response.size());
        memcpy((void *) reply.data(), response.c_str(), response.size());

        rep_socket->send(reply);
        MDEBUG(std::string("Sent RPC reply: \"") + response + "\"");

      }
    }
    catch (const boost::thread_interrupted& e)
    {
      MDEBUG("ZMQ Server thread interrupted.");
    }
    catch (const zmq::error_t& e)
    {
      MERROR(std::string("ZMQ error: ") + e.what());
    }
    boost::this_thread::interruption_point();
  }
}
示例#14
0
// ---------------------------------------------------------------------------
// Destructeur
// -----------
bMacMapType::~bMacMapType(){
_bTrace_("bMacMapType::~bMacMapType",true);

_tm_("deleting "+_idx+" "+_name);

	if(_iter){
bMacMapGeoElement*	geo;
bArray				arr(sizeof(bMacMapGeoElement*));
char				cftitle[__MESSAGE_STRING_LENGTH_MAX__];
char				cfprompt[__MESSAGE_STRING_LENGTH_MAX__];
		message_string(kMsgClose,cftitle,true);
		strcpy(cfprompt,_name);

_tm_("iterate");
		_iter->iterate(&arr,add_to_array);
_tm_("flush iterator");
		_iter->flush();
_tm_((int)arr.count()+" objects to delete");

bProgressWait	wait(cftitle,cfprompt,true,false,arr.count());
		for(long i=1;i<=arr.count();i++){
//_tm_(i);
			wait.set_progress(i);
			if(arr.get(i,&geo)){
				delete geo;
			}
		}
		arr.reset();
_tm_("deleting _iter");
		extmgr->get_component(kComponentGeoIterator)->i_free(_iter);
	}
	
	if(_styles){
_tm_("deleting _styles");
		_styles->unload();
		delete _styles;
	}
}
// ---------------------------------------------------------------------------
// 
// ------------
void bXMapLineUp::make(){
bGenericGeoElement* o;
ivx_rect			vr,vrb,bnd;
bArray				arr(*_gapp->selMgr()->elements());
int					i,j,ko,kv;
int					imax,jmax,n=0;
insidePtr			inside;
ivertices			*ref,*vxs;
i2dvertex			p,lp;
bool				end=false;
int					hd=round(Measure_d2i(_gapp,_hd));
int					vd=round(Measure_d2i(_gapp,_vd));

	if(_use_surf){
		inside=ivx_in_ivs;
		_gapp->cntMgr()->elements()->get(1,&o);
		o->getBounds(&bnd);
		o->getVertices(&ref);
		imax=1+(bnd.bottom-bnd.top)/vd;
		jmax=1+(bnd.right-bnd.left)/hd;
	}
	else{
		inside=dummy_ivx_in_ivs;
		arr.get(1,&o);
		o->getBounds(&bnd);
		vr=bnd;
		o->getVertices(&vxs);
		n+=vxs->nv;
		for(i=2;i<arr.count();i++){
			arr.get(i,&o);
			o->getBounds(&vrb);
			ivr_union(&vrb,&vr,&bnd);
			vr=bnd;
			o->getVertices(&vxs);
			n+=vxs->nv;
		}
		ref=NULL;
		if(_kind==kXMapLineUpKindLine){
			imax=ceil((double)n/_nb);
			jmax=_nb;
		}
		else{
			imax=_nb;
			jmax=ceil((double)n/_nb);	
		}
	}
		
	_gapp->layersMgr()->SetObjInvalidation(false);	
	
char			msg[__MESSAGE_STRING_LENGTH_MAX__];
char			ttl[__MESSAGE_STRING_LENGTH_MAX__];
    get_localized_name(ttl,getbundle());
	message_string(kMsgProgress,msg,1);
bProgressWait	wt(ttl,msg,true,true,arr.count());	

bEventLog	log(_gapp,this);
	
	ko=1;
	kv=0;
	arr.get(ko,&o);
	o->getVertices(&vxs);
	lp.h=bnd.left;
	lp.v=bnd.top;
	for(i=0;i<imax;i++){
		for(j=0;j<jmax;j++){
			p.h=bnd.left+j*hd;
			p.v=bnd.top+i*vd;
			if(!inside(&p,ref,1)){
				continue;
			}
			lp=p;
			vxs->vx.vx2[kv]=p;
			kv++;
			if(kv==vxs->nv){
				kv=0;
				ko++;
				o->setVertices(vxs);
				if(!wt.set_progress(ko)){
					end=true;
					break;
				}
				if(!arr.get(ko,&o)){
					end=true;
					break;
				}
				o->getVertices(&vxs);
			}
		}
		if(end){
			break;
		}
	}
	
	if(!end){
		if(kv<vxs->nv){
			for(i=kv;i<vxs->nv;i++){
				vxs->vx.vx2[kv]=lp;
			}
			o->setVertices(vxs);
			ko++;
		}
		for(i=ko;i<=arr.count();i++){
			if(!wt.set_progress(i)){
				break;
			}	
			arr.get(i,&o);
			o->getVertices(&vxs);
			for(j=0;j<vxs->nv;j++){
				vxs->vx.vx2[j]=lp;
			}
			o->setVertices(vxs);
		}
	}
	_gapp->layersMgr()->SetObjInvalidation(true);	
	log.close();
}
示例#16
0
int32_t context_lua_t::context_query_yield_finalize(lua_State *root_coro, lua_State *main_coro, void *userdata, uint32_t destination)
{
	if (root_coro != NULL) {
		context_lua_t* lctx = context_lua_t::lua_get_context(root_coro);
		message_t& message = lctx->get_yielding_message();
		message.m_session = context_lua_t::lua_ref_yield_coroutine(root_coro);
		bool ret;
		if (message_is_string(message)) {
			ret = singleton_ref(node_lua_t).context_send_string_safe(destination, lctx->get_handle(), message.m_session, CONTEXT_QUERY, message_string(message));
		} else if (message_is_bson(message)) {

		} else {
			ret = singleton_ref(node_lua_t).context_send(destination, message);
		}
		if (ret) {
			int64_t timeout = lctx->get_yielding_timeout();
			if (timeout > 0) {
				context_lua_t::lua_ref_timer(main_coro, message.m_session, timeout, 0, false);
			}
			return UV_OK;
		} else {
			lua_free_ref_session(main_coro, message.m_session);
			return NL_ENOCONTEXT;
		}
	}
	return UV_OK;
}
// ---------------------------------------------------------------------------
// 
// ------------
bool bMacMapLayerAccessContext::add(int tidx, int sidx){
_bTrace_("bMacMapLayerAccessContext::add",true);
bGenericType*	tp=typesmgr->get(tidx);
bStyle*			style;

	if(tp){
		style=new bStyle();
	}
	else{
		style=new bVirtualStyle();
	}
	
	if(!style){
		return(false);
	}
	if(!_elts->add(&style)){
		delete style;
		return(false);
	}
	
bArray  arr(sizeof(xmlelt));

	if(tp){
		add_cdesc(arr,0,"layer","");
	}
	else{
		add_cdesc(arr,0,"virtuallayer","");
	}

char name[256];

	if(tp){
		tp->name(name);
	}
	else{
		message_string(kMsgVirtual,name,1);
	}
	style->settype(name);
	if(tp){
		add_cdesc(arr,1,"type",name);
	}
	
	if(tp){
		tp->styles()->get_name(sidx,name);
	}
	else{
		map_doc->styles()->get_name(sidx,name);
	}
	style->setname(name);
	add_cdesc(arr,1,"style",name);
	style->setvisible(true);
	add_idesc(arr,1,"visible",1);
	style->setselectable(true);
	add_idesc(arr,1,"selectable",(tp!=0));
	
bGenericXMLBaseElement	*root=clssmgr->ParseXMLDescriptors(&arr);
	free_descs(arr);
	if(!root){
		delete style;
		_elts->rmv(_elts->count());
		return(false);
	}
	style->setlayer(root);
	_array->addelement(root);
	parse(_elts->count());
	//	map_wd->inval();
	_MMAPP_->mapIntf()->inval();
	return(true);
}