TEST(TypeStructTest, map)
{
// packing
auto p=refrange::msgpack::create_vector_packer();
p << refrange::msgpack::map(1) << "key" << 1;
// unpack
auto u = refrange::msgpack::create_unpacker(p.pointer(), p.size());
std::stringstream ss;
refrange::msgpack::typestruct(u, ss);
EXPECT_STREQ("{string:int}", ss.str().c_str());
}
void Test::assignmentTest() {
{
RefPtr pointer( new RefTest );
{
RefPtr pointer2;
pointer2 = pointer;
}
}
assert( 0 == s_construct );
}
pointer allocate(size_type obj_size)
{
if (is_memory_available()) {
pointer ptr = m_chunk + (m_head * obj_size);
m_head = ptr[0];
m_available--;
return ptr;
}
return pointer(nullptr);
}
void displayMenu(int y, int x, char title[],int numOfOpt, char *options[], void (*p[])(void)){
int i,c;
WINDOW *menuWindow;
MENU *myMenu;
ITEM **myOptions;
ITEM *currentOption;
initscr();
noecho();
cbreak();
keypad(stdscr,TRUE);
init_pair(1,COLOR_CYAN,COLOR_BLACK);
myOptions=(ITEM **)calloc(numOfOpt+1,sizeof(ITEM *));
for(i=0;i<numOfOpt;i++){
myOptions[i]=new_item(options[i]," ");
set_item_userptr(myOptions[i],p[i]);
}
myOptions[numOfOpt]=(ITEM *)NULL;
myMenu=new_menu(myOptions);
menuWindow = newwin(8,20,(LINES-y)/2,(COLS-x)/2);
keypad(menuWindow,TRUE);
set_menu_win(myMenu,menuWindow);
set_menu_sub(myMenu, derwin(menuWindow,y-4,x-2,3,1));
set_menu_format(myMenu,numOfOpt,1);
menu_opts_off(myMenu, O_SHOWDESC);
set_menu_mark(myMenu," * ");
post_menu(myMenu);
wrefresh(menuWindow);
while((c=wgetch(menuWindow))!=KEY_F(2)){
switch(c){
case KEY_UP:
menu_driver(myMenu,REQ_UP_ITEM);
break;
case KEY_DOWN:
menu_driver(myMenu,REQ_DOWN_ITEM);
break;
case 10:{
ITEM *temp;
temp=current_item(myMenu);
void(*pointer)(void);
pointer=item_userptr(temp);
pointer();
pos_menu_cursor(myMenu);
menu_driver(myMenu,REQ_DOWN_ITEM);
break;
}
wrefresh(menuWindow);
}
}
/*unpost_menu(myMenu);*/
/*for(i=0;i<numOfOpt;++i){*/
/*free_item(myOptions[i]);*/
/*}*/
/*free_menu(myMenu);*/
/*free(optionsNumbers);*/
}
// if sizes==0, then keep current shape
int Data::realloc(Data::Type t, const int * sizes, int n){
Data old(*this); // REV0
if(sizes){ // new shape requested
clear();
shape(sizes, n);
}
else{ // just changing type, leave shape unchanged
// Data old(*this); // REV0
clear();
shape(old.mSizes, old.maxDim());
}
if(size()){
mType = t;
mStride= 1;
switch(type()){
case Data::BOOL: mData = pointer(new bool[size()]); break;
case Data::INT: mData = pointer(new int[size()]); break;
case Data::FLOAT: mData = pointer(new float[size()]); break;
case Data::DOUBLE: mData = pointer(new double[size()]); break;
case Data::STRING: mData = pointer(new std::string[size()]); break;
default: goto end;
}
acquire(mData);
offset(0);
// if(hasData() && isNumerical()) assignAll(0); // REV0
if(hasData() && isNumerical()){
if(old.hasData()){
assign(old); // copy over as many old elements as possible
if(size() > old.size()) slice(old.size()).assignAll(0);
}
else{
assignAll(0);
}
}
}
end:
return sizeBytes() - old.sizeBytes();
}
//static const u32 mb_sz = 0x1000000;
bool CMemoryWriter::save_to(LPCSTR fn)
{
IWriter* F = FS.w_open(fn);
if (F)
{
F->w(pointer(), size());
FS.w_close(F);
return true;
}
return false;
}
bool NearSpansUnordered::isPayloadAvailable()
{
SpansCellPtr pointer(min());
while (pointer)
{
if (pointer->isPayloadAvailable())
return true;
pointer = pointer->_next;
}
return false;
}
IPC::MessagePointer IPC::IPCExceptionToMessage(const IPCException& exception)
{
IPC::Exception * const message = new IPC::Exception();
IPC::MessagePointer pointer(message);
message->set_context(exception.context());
message->set_object(exception.object());
message->set_reason(exception.reason());
message->set_request_id(exception.messageID());
return pointer;
}
Ghost::Ghost(Math::Point pos, Pointer<Entity> parent, QString name)
: Actor(parent, name),
mKillCount(0)
{
subclass();
setPos(pos);
setMaxSpeed(9.0);
mPursue = new Pursue(pointer());
mWander = new Wander(pointer());
addSteeringBehavior(mPursue);
addSteeringBehavior(mWander);
PersonView* view = new PersonView(pointer(), Qt::green);
//view->setColor(Qt::green); // HULK SMASH! -- 20070108 iank
setView(view);
setVisible(true);
newTarget();
}
//---------------------------------------------------
// base stream
IReader* IReader::open_chunk(u32 ID)
{
BOOL bCompressed;
u32 dwSize = find_chunk(ID, &bCompressed);
if (dwSize != 0)
{
if (bCompressed)
{
BYTE* dest;
unsigned dest_sz;
_decompressLZ(&dest, &dest_sz, pointer(), dwSize);
return xr_new<CTempReader>(dest, dest_sz, tell() + dwSize);
}
else
{
return xr_new<IReader>(pointer(), dwSize, tell() + dwSize);
}
}
else return 0;
};
/*
* (prepare-call-interface
* <foreign function ABI>
* <type of return value>
* (<type of input argument> ...))
*
*
* TODO:
* - Put ABI parameter last.
* - If there is no input-value list, then ignore it.
*/
cons_t* proc_ffi_prep_cif(cons_t* p, environment_t*)
{
assert_length(p, 2, 3);
ffi_abi abi = FFI_DEFAULT_ABI;
/*
* ARGUMENT 1: ABI for foreign function
*/
abi = parse_ffi_abi(car(p));
/*
* ARGUMENT 2:
* Return type for foreign function
*/
ffi_type* rtype = parse_ffi_type(cadr(p));
/*
* ARGUMENT 3:
* Types for foreign function's input parameters.
*/
ffi_type** argtypes = NULL;
unsigned int nargs = 0;
if ( length(p) >= 3 ) {
cons_t *args = caddr(p);
assert_type(PAIR, args);
nargs = length(args);
if ( nargs > 0 ) {
argtypes = static_cast<ffi_type**>(malloc(nargs*sizeof(ffi_type*)));
for ( unsigned int n=0; n<nargs; ++n ) {
argtypes[n] = parse_ffi_type(car(args));
args = cdr(args);
}
}
}
/*
* Initialize returned struct
*/
ffi_cif *cif = new ffi_cif();
memset(cif, 0, sizeof(ffi_cif));
check(ffi_prep_cif(cif, abi, nargs, rtype, argtypes));
return pointer(tag_ffi_cif, cif);
/*
* In the future, the malloced argtypes should be added to the
* pointer-return value here, so that it too can be freed.
*/
}
int main(){
double x=3.1, y=5.1;
void (*pointer)(double, double);
printf("add 함수의 주소 : %x\n",add);
printf("함수 포인터의 주소 : %x\n",&pointer);
pointer=add;
pointer(x,y);
return 0;
}
void retcode(Tree p) {
Type ty;
if (p == NULL) {
if (events.returns)
apply(events.returns, cfunc, NULL);
return;
}
p = pointer(p);
ty = assign(freturn(cfunc->type), p);
if (ty == NULL) {
error("illegal return type; found `%t' expected `%t'\n",
p->type, freturn(cfunc->type));
return;
}
p = cast(p, ty);
if (retv)
{
if (iscallb(p))
p = tree(RIGHT, p->type,
tree(CALL+B, p->type,
p->kids[0]->kids[0], idtree(retv)),
rvalue(idtree(retv)));
else
p = asgntree(ASGN, rvalue(idtree(retv)), p);
walk(p, 0, 0);
if (events.returns)
apply(events.returns, cfunc, rvalue(idtree(retv)));
return;
}
if (events.returns)
{
Symbol t1 = genident(AUTO, p->type, level);
addlocal(t1);
walk(asgn(t1, p), 0, 0);
apply(events.returns, cfunc, idtree(t1));
p = idtree(t1);
}
if (!isfloat(p->type))
p = cast(p, promote(p->type));
if (isptr(p->type))
{
Symbol q = localaddr(p);
if (q && (q->computed || q->generated))
warning("pointer to a %s is an illegal return value\n",
q->scope == PARAM ? "parameter" : "local");
else if (q)
warning("pointer to %s `%s' is an illegal return value\n",
q->scope == PARAM ? "parameter" : "local", q->name);
}
walk(tree(mkop(RET,p->type), p->type, p, NULL), 0, 0);
}
/*
* (set-video-mode <width> <height> <bits per pixel>?) or
* (set-video-mode <width> <height> <bits per pixel> <mode flags>+)
*
* where <symbols> are:
* swsurface
* hwsurface
* asyncblit
* anyformat
* hwpalette
* doublebuf
* fullscreen
* opengl
* openglblit
* resizable
* noframe
*
*/
cons_t* set_video_mode(cons_t* p, environment_t*)
{
assert_length_min(p, 2);
assert_type(INTEGER, car(p));
assert_type(INTEGER, cadr(p));
// dimension
int x = intval(car(p));
int y = intval(cadr(p));
// default values
int bits = 32;
uint32_t mode = 0;
// bits per pixel
if ( length(p) > 2 && integerp(caddr(p)) )
bits = intval(caddr(p));
// mode options
if ( length(p) > 3 ) {
cons_t *opts = symbolp(caddr(p))? cddr(p) :
symbolp(cadddr(p))? cdddr(p) : nil();;
DPRINT(opts);
for ( cons_t *s = opts; !nullp(s); s = cdr(s) ) {
assert_type(SYMBOL, car(s));
std::string sym = symbol_name(car(s));
for ( size_t n=0; n < num_sdl_flags; ++n )
if ( sym == sdl_flags[n].key ) {
mode |= sdl_flags[n].value;
goto NEXT_FLAG;
}
raise(runtime_exception("Unknown SDL video mode flag: " + sym));
NEXT_FLAG:
continue;
}
}
SDL_Surface *screen = SDL_SetVideoMode(x, y, bits, mode);
if ( screen == NULL )
raise(runtime_exception(SDL_GetError()));
return pointer(
new pointer_t("sdl-surface",
reinterpret_cast<void*>(screen)));
}
uint32 SymbianStdioStream::write(const void *ptr, uint32 len) {
TPtrC8 pointer( (unsigned char*) ptr, len);
((TSymbianFileEntry *)(_handle))->_inputPos = KErrNotFound;
((TSymbianFileEntry *)(_handle))->_lastError = ((TSymbianFileEntry *)(_handle))->_fileHandle.Write(pointer);
((TSymbianFileEntry *)(_handle))->_eofReached = EFalse;
if (((TSymbianFileEntry *)(_handle))->_lastError == KErrNone) {
return len;
}
return 0;
}
void tst_QExplicitlySharedDataPointer::clone() const
{
/* holding a base element */
{
QExplicitlySharedDataPointer<Base> pointer(new Base);
QVERIFY(pointer->isBase());
QExplicitlySharedDataPointer<Base> copy(pointer);
pointer.detach();
QVERIFY(pointer->isBase());
}
/* holding a derived element */
{
QExplicitlySharedDataPointer<Base> pointer(new Derived);
QVERIFY(!pointer->isBase());
QExplicitlySharedDataPointer<Base> copy(pointer);
pointer.detach();
QVERIFY(!pointer->isBase());
}
}
static Tree expr3(int k) {
int k1;
Tree p = unary();
for (k1 = prec[t]; k1 >= k; k1--)
while (prec[t] == k1 && *cp != '=') {
Tree r;
Coordinate pt;
int op = t;
t = gettok();
pt = src;
p = pointer(p);
if (op == ANDAND || op == OROR) {
r = pointer(expr3(k1));
if (events.points)
apply(events.points, &pt, &r);
} else
r = pointer(expr3(k1 + 1));
p = (*optree[op])(oper[op], p, r);
}
return p;
}
int CMSimulationArray::MakeKey(const CMTime& t,int var)
{
if (var<0 || var>=nvars || t<beg || t>end || !array || Fail())
return 0;
if (key) delete key;
long ntrials = Trials();
key = new CMVSBigArray<pointer>(ntrials,1);
for (long i=0;key && i<ntrials;i++)
key->Add(pointer(At(t,var,i),i));
key->Sort();
return (key != 0);
}
void do_release() {
size_t total_bytes = *count_ * sizeof(T);
RequestArgs args;
args.request_address = *request_address_;
DVLOG(5) << "Computing request_bytes from block_max " << request_address_->first_byte().block_max() << " and " << *request_address_;
args.reply_address = make_global( this );
size_t offset = 0;
size_t request_bytes = 0;
for( size_t i = 0;
offset < total_bytes;
offset += request_bytes, i++) {
request_bytes = args.request_address.first_byte().block_max() - args.request_address.first_byte();
if( request_bytes > total_bytes - offset ) {
request_bytes = total_bytes - offset;
}
DVLOG(5) << "sending release request with " << request_bytes
<< " of total bytes = " << *count_ * sizeof(T)
<< " to " << args.request_address;
Grappa::send_heap_message(args.request_address.core(),
[args](void * payload, size_t payload_size) {
IRMetrics::count_release_ams( payload_size );
DVLOG(5) << "Worker " << Grappa::current_worker()
<< " received release request to " << args.request_address
<< " reply to " << args.reply_address;
memcpy( args.request_address.pointer(), payload, payload_size );
auto reply_address = args.reply_address;
Grappa::send_heap_message(args.reply_address.core(), [reply_address]{
DVLOG(5) << "Worker " << Grappa::current_worker() << " received release reply to " << reply_address;
reply_address.pointer()->release_reply();
});
DVLOG(5) << "Worker " << Grappa::current_worker()
<< " sent release reply to " << reply_address;
},
(char*)(*pointer_) + offset, request_bytes
);
// TODO: change type so we don't screw with pointer like this
args.request_address = GlobalAddress<T>::Raw( args.request_address.raw_bits() + request_bytes );
}
DVLOG(5) << "release started for " << args.request_address;
// blocks here waiting for messages to be sent
}
pointer allocate()
{
if (m_last_used_chunk.is_valid() && m_last_used_chunk.get_chunk()->is_memory_available()) {
return m_last_used_chunk.get_chunk()->allocate(m_obj_size);
}
for (auto& block: m_blocks) {
if (block.is_memory_available()) {
auto res = block.allocate(m_obj_size);
m_last_used_chunk.set_chunk(res.second);
return res.first;
}
}
return pointer(nullptr);
}
Tree asgntree(int op, Tree l, Tree r) {
Type aty, ty;
r = pointer(r);
ty = assign(l->type, r);
if (ty)
r = cast(r, ty);
else {
typeerror(ASGN, l, r);
if (r->type == voidtype)
r = retype(r, inttype);
ty = r->type;
}
if (l->op != FIELD)
l = lvalue(l);
aty = l->type;
if (isptr(aty))
aty = unqual(aty)->type;
if (isconst(aty)
|| (isstruct(aty) && unqual(aty)->u.sym->u.s.cfields)) {
if (isaddrop(l->op)
&& !l->u.sym->computed && !l->u.sym->generated)
error("assignment to const identifier `%s'\n",
l->u.sym->name);
else
error("assignment to const location\n");
}
if (l->op == FIELD) {
long n = 8 * l->u.field->type->size - fieldsize(l->u.field);
if (n > 0 && isunsigned(l->u.field->type))
r = bittree(BAND, r,
cnsttree(r->type, (unsigned long)fieldmask(l->u.field)));
else if (n > 0) {
if (r->op == CNST + I) {
n = r->u.v.i;
if (n & (1 << (fieldsize(l->u.field) - 1)))
n |= ~0UL << fieldsize(l->u.field);
r = cnsttree(r->type, n);
} else
r = shtree(RSH,
shtree(LSH, r, cnsttree(inttype, n)),
cnsttree(inttype, n));
}
}
if (isstruct(ty) && isaddrop(l->op) && iscallb(r))
return tree(RIGHT, ty,
tree(CALL + B, ty, r->kids[0]->kids[0], l),
idtree(l->u.sym));
return tree(mkop(op, ty), ty, l, r);
}
static Tree expr2(void) {
Tree p = expr3(4);
if (t == '?') {
Tree l, r;
Coordinate pts[2];
if (Aflag > 1 && isfunc(p->type))
warning("%s used in a conditional expression\n",
funcname(p));
p = pointer(p);
t = gettok();
pts[0] = src;
l = pointer(expr(':'));
pts[1] = src;
r = pointer(expr2());
if (events.points) {
apply(events.points, &pts[0], &l);
apply(events.points, &pts[1], &r);
}
p = condtree(p, l, r);
}
return p;
}
void IReader::r (void *p,int cnt)
{
VERIFY (Pos+cnt<=Size);
CopyMemory (p,pointer(),cnt);
advance (cnt);
#ifdef DEBUG
BOOL bShow = FALSE ;
if (dynamic_cast<CFileReader*>(this)) bShow = TRUE;
if (dynamic_cast<CVirtualFileReader*>(this)) bShow = TRUE;
if (bShow) {
FS.dwOpenCounter ++ ;
}
#endif
};
TEST(TypeStructTest, vec3)
{
// packing
auto p=refrange::msgpack::create_vector_packer();
p << refrange::msgpack::array(3) << 1.0f << 1.0f << 1.0f;
// unpack
auto u = refrange::msgpack::create_unpacker(p.pointer(), p.size());
std::stringstream ss;
refrange::msgpack::typestruct(u, ss);
EXPECT_STREQ("[float,float,float]", ss.str().c_str());
}
Tree expr(int tok) {
static char stop[] = { IF, ID, '}', 0 };
Tree p = expr1(0);
while (t == ',') {
Tree q;
t = gettok();
q = pointer(expr1(0));
p = tree(RIGHT, q->type, root(value(p)), q);
}
if (tok)
test(tok, stop);
return p;
}
GhostTrap::GhostTrap(Math::Point pos, Pointer<Entity> parent, QString name)
: LimitedLifetimeTrigger(parent, 20.0, name),
mDetonated(false),
mKillTimer(0),
mKillCount(0)
{
subclass();
setPos(pos);
setTriggerRegion(new TriggerRegionCircle(pos, 7));
mView = new CircleView(pointer(), 7, Qt::darkGreen, 0.5);
setView(mView);
setVisible(true);
}
// -----------------------------------------------------------------------------
// CCbsTopicMessages::GetMessageContentsL
// Returns the content of the message to the client.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsTopicMessages::GetMessageContentsL()
{
// Read the parameters from the client side.
TPckgBuf< TCbsMessageHandle > pckgHandle( 0 );
Message().ReadL( 0, pckgHandle );
TInt bufSize( 0 );
bufSize = Message().Int1();
TCbsDbMessage message;
iMessages.FindMessageByHandleL( pckgHandle(), message );
if ( message.iLength != 0 )
{
// Message is not empty.
// First allocate memory and then get the contents.
// Finally write data to client side.
TInt size ( ( message.iLength < bufSize ) ?
message.iLength : bufSize );
// guaranteed to allocate n bytes, n >= size
HBufC* buffer = HBufC::NewLC( size ); // on CS
TPtr16 pointer( buffer->Des() );
pointer.Zero();
// Note: parameter 'size' required, since MaxLength
// may be > bufSize
iMessages.GetMessageContentsL( pckgHandle(), pointer, size );
#ifndef _DEBUG
Message().WriteL( 2, pointer );
#else
TRAPD( result, Message().WriteL( 2, pointer ) );
if ( result != KErrNone )
{
RDebug::Print(_L("Server buffer length: %d, max: %d"),
pointer.Length(), pointer.MaxLength());
__DEBUGGER();
User::Leave( result );
}
#endif
CleanupStack::PopAndDestroy(); // buffer
}
// Complete the request.
Message().Complete( KErrNone );
}
SEXP get_attribute_container(SEXP processStateManager_, SEXP name_) {
BEGIN_RCPP
ProcessStateManager * processStateManager =
Rcpp::XPtr<ProcessStateManager>(processStateManager_);
std::string name = Rcpp::as<std::string>(name_);
AttributeContainer * attributeContainer = processStateManager->getAttributeContainer(name);
Rcpp::XPtr<AttributeContainer> pointer(attributeContainer, false);
pointer.attr("class") = "NetSimAttributeContainer";
return pointer;
END_RCPP
}
SEXP set_value(SEXP attributeContainer_, SEXP i_, SEXP value_) {
BEGIN_RCPP
AttributeContainer * attributeContainer = Rcpp::XPtr<AttributeContainer>(attributeContainer_);
int i = Rcpp::as<int>(i_);
double value = Rcpp::as<double>(value_);
attributeContainer->setValue(i, value);
Rcpp::XPtr<AttributeContainer> pointer(attributeContainer, false);
pointer.attr("class") = "NetSimAttributeContainer";
return pointer;
END_RCPP
}
bool ListOfGroups::add(Stone &stone, const List<Stone> &freedom, const List<Stone> &jail) {
if(pointer()==0) {
Group *group=new Group;
setPointer(group);
return pointer()->add(stone,freedom,jail);
}
List<Group> *last=this;
bool inserted=false;
for(List<Group> *it=this;it!=0;it=it->next()) {
if(it->pointer()->nextTo(stone)) {
it->pointer()->add(stone,freedom,jail);
inserted=true;
}
last=it;
}
if(!inserted) {
List<Group> *list=new List<Group>;
last->setNext(list);
Group *group=new Group;
last->next()->setPointer(group);
return last->next()->pointer()->add(stone,freedom,jail);
}
return inserted;
}
