SEXP
R_createFunction(SEXP r_module, SEXP r_name, SEXP r_retType, SEXP r_types, SEXP r_varArgs)
{
llvm::Function *ans;
//
llvm::Module *module;
module = GET_REF(r_module, Module); // llvm::cast<llvm::Module>
llvm::Type *rtype = GET_TYPE(r_retType);
int nargs = Rf_length(r_types);
std::vector<llvm::Type *> params(nargs);
for(int i = 0; i < nargs; i++)
params[i] = GET_TYPE(VECTOR_ELT(r_types, i));
#if 1
llvm::FunctionType * fsig;
fsig = llvm::FunctionType::get(rtype, params, INTEGER(r_varArgs)[0]);
ans = llvm::cast<llvm::Function>( module->getOrInsertFunction(CHAR(STRING_ELT(r_name, 0)), fsig) );
#else
llvm::FunctionType * fty;
// fty = llvm::FunctionType::get(rtype, params, false); //xxx
llvm::ArrayRef<llvm::Type*> paramsRef = makeArrayRef(params);
fty = llvm::FunctionType::get(rtype, paramsRef, false); //xxx
ans = llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, strdup(CHAR(STRING_ELT(r_name, 0))), module);
#endif
return(R_createRef(ans, "Function"));
}
void cg_label_writer::operator()(std::ostream& out, const vertex& v) const
{
bool is_critical = GET_CRITICAL(g, v);
if (GET_TYPE(g, v) == TYPE_ENTRY || GET_TYPE(g, v) == TYPE_EXIT)
{
out << "[color=" << (is_critical ? "red" : "blue") << ",shape=Msquare";
}
else
{
out << "[shape=box";
if (is_critical) out << ",color=red";
}
out << ", label=\"" << GET_NAME(g, v) << " \\n" << GET_OPERATION(g, v) << "\"]" ;
}
SEXP
R_Type_dump(SEXP r_val)
{
llvm::Type *type = GET_TYPE(r_val);
type->dump();
return(R_NilValue);
}
VOID copy_spec(LONG tree, WORD obj)
{
WORD type;
LONG obspec;
type = LLOBT(GET_TYPE(tree, obj));
obspec = GET_SPEC(tree, obj);
switch (type)
{
case G_TEXT:
case G_BOXTEXT:
case G_FTEXT:
case G_FBOXTEXT:
obspec = copy_ti(obspec);
break;
case G_ICON:
obspec = copy_ib(obspec);
break;
case G_IMAGE:
obspec = copy_bb(obspec);
break;
default:
return;
}
SET_SPEC(tree, obj, obspec);
}
SEXP
R_IRBuilder_createLocalVariable(SEXP r_builder, SEXP r_type, SEXP r_size, SEXP r_id, SEXP r_beforeTerminator)
{
llvm::IRBuilder<> *builder;
builder = GET_REF(r_builder, IRBuilder<>);
llvm::Type *type = GET_TYPE(r_type);
llvm::AllocaInst *ans;
if(Rf_length(r_size)) {
llvm::Value *size = GET_REF(r_size, Value);
ans = new llvm::AllocaInst(type, size, makeTwine(r_id));
} else
ans = new llvm::AllocaInst(type, makeTwine(r_id));
if(LOGICAL(r_beforeTerminator)[0]) {
llvm::BasicBlock *block;
block = builder->GetInsertBlock();
llvm::TerminatorInst *inst = block->getTerminator();
if(inst)
block->getInstList().insert(inst, ans);
else
builder->Insert(ans);
} else
ans = builder->Insert(ans);
if(Rf_length(r_id))
ans->setName(makeTwine(r_id));
return(R_createRef(ans, "AllocaInst"));
}
VOID trans_obj(LONG tree, WORD obj)
{
WORD type, wb, hl;
LONG taddr, obspec;
type = LLOBT(GET_TYPE(tree, obj));
if ( (obspec = GET_SPEC(tree, obj)) != -1L)
{
switch (type)
{
case G_IMAGE:
trans_bitblk(obspec);
break;
case G_ICON:
hl = LWGET(IB_HICON(obspec));
wb = (LWGET(IB_WICON(obspec)) + 7) >> 3;
if ( (taddr = LLGET(IB_PDATA(obspec))) != -1L)
gsx_trans(taddr, wb, taddr, wb, hl);
if ( (taddr = LLGET(IB_PMASK(obspec))) != -1L)
gsx_trans(taddr, wb, taddr, wb, hl);
break;
default:
break;
}
}
}
int
send_msg_tcp(struct author *author, int fd)
{
ushort id, typeoff, temp, type;
uchar *buffer = author->tmpbuffer;
int len, ret;
mbuf_type *mbuf;
uchar *domain;
ret = author->eptcpfds[fd].ret;
if (ret <= 0)
return -1;
domain = author->eptcpfds[fd].domain;
id = GET_IDX(ret);
typeoff = GET_TYPE(ret);
ret = htable_find_list(author->s->qlist, domain, typeoff, id, (uchar **)&mbuf);
if (ret < 0)
return ret;
type = mbuf->qtype;
if (mbuf->qname == Q_NS)
type = A;
len = make_dns_msg_for_new(buffer + 2, mbuf->aid, mbuf->qing, mbuf->qlen, type);
temp = htons(len);
memcpy(buffer, &temp, sizeof(ushort));
mbuf->fd = fd;
mbuf->buf = buffer;
mbuf->buflen = len + 2;
tcp_write_info(mbuf, 0);
return 0;
}
//---------------------------------------------------------
bool CShapes_Create_Empty::On_Execute(void)
{
TSG_Vertex_Type Vertex;
switch( Parameters("VERTEX")->asInt() )
{
default:
case 0: Vertex = SG_VERTEX_TYPE_XY; break;
case 1: Vertex = SG_VERTEX_TYPE_XYZ; break;
case 2: Vertex = SG_VERTEX_TYPE_XYZM; break;
}
//-----------------------------------------------------
CSG_Shapes *pShapes;
switch( Parameters("TYPE")->asInt() )
{
default: return( false );
case 0: pShapes = SG_Create_Shapes(SHAPE_TYPE_Point , Parameters("NAME")->asString(), NULL, Vertex); break;
case 1: pShapes = SG_Create_Shapes(SHAPE_TYPE_Points , Parameters("NAME")->asString(), NULL, Vertex); break;
case 2: pShapes = SG_Create_Shapes(SHAPE_TYPE_Line , Parameters("NAME")->asString(), NULL, Vertex); break;
case 3: pShapes = SG_Create_Shapes(SHAPE_TYPE_Polygon, Parameters("NAME")->asString(), NULL, Vertex); break;
}
//-----------------------------------------------------
int i, n;
TSG_Data_Type Type;
CSG_Parameters *pAttributes;
pAttributes = Parameters("FIELDS")->asParameters();
n = pAttributes->Get_Count() / 3;
for(i=0; i<n; i++)
{
switch( pAttributes->Get_Parameter(GET_TYPE(i))->asInt() )
{
default:
case 0: Type = SG_DATATYPE_String; break;
case 1: Type = SG_DATATYPE_Date; break;
case 2: Type = SG_DATATYPE_Color; break;
case 3: Type = SG_DATATYPE_Byte; break;
case 4: Type = SG_DATATYPE_Char; break;
case 5: Type = SG_DATATYPE_Word; break;
case 6: Type = SG_DATATYPE_Short; break;
case 7: Type = SG_DATATYPE_DWord; break;
case 8: Type = SG_DATATYPE_Int; break;
case 9: Type = SG_DATATYPE_ULong; break;
case 10: Type = SG_DATATYPE_Long; break;
case 11: Type = SG_DATATYPE_Float; break;
case 12: Type = SG_DATATYPE_Double; break;
case 13: Type = SG_DATATYPE_Binary; break;
}
pShapes->Add_Field(pAttributes->Get_Parameter(GET_NAME(i))->asString(), Type);
}
Parameters("SHAPES")->Set_Value(pShapes);
return( true );
}
SEXP
R_Argument_mutateType(SEXP r_arg, SEXP r_type)
{
llvm::Argument *arg = GET_REF(r_arg, Argument);
llvm::Type *ty = GET_TYPE(r_type);
arg->mutateType(ty);
return(R_NilValue);
}
//---------------------------------------------------------
CTable_Create_Empty::CTable_Create_Empty(void)
{
//-----------------------------------------------------
Set_Name (_TL("Create New Table"));
Set_Author (SG_T("O. Conrad (c) 2005"));
Set_Description (CSG_String::Format(_TW(
"Creates a new empty table.\n\n"
"Possible field types are:\n"
"- %s\n- %s\n- %s\n- %s\n- %s\n- %s\n- %s\n- %s\n- %s\n- %s\n- %s\n- %s\n- %s\n- %s\n"),
SG_Data_Type_Get_Name(SG_DATATYPE_String).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Date ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Color ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Byte ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Char ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Word ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Short ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_DWord ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Int ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_ULong ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Long ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Float ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Double).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Binary).c_str()
));
//-----------------------------------------------------
Parameters.Add_Table_Output(
NULL , "TABLE" , _TL("Table"),
_TL("")
);
Parameters.Add_String(
NULL , "NAME" , _TL("Name"),
_TL(""),
_TL("New Table")
);
Parameters.Add_Value(
NULL , "NFIELDS" , _TL("Number of Attributes"),
_TL(""),
PARAMETER_TYPE_Int , 2, 1, true
);
Parameters.Add_Parameters(
NULL , "FIELDS" , _TL("Attributes"),
_TL("")
);
//-----------------------------------------------------
CSG_Parameters *pAttributes = Parameters("FIELDS")->asParameters();
_Set_Field_Count(pAttributes, Parameters("NFIELDS")->asInt());
pAttributes->Get_Parameter(GET_NAME(0))->Set_Value(_TL("ID"));
pAttributes->Get_Parameter(GET_TYPE(0))->Set_Value(3);
}
void
load_gravity_well (BYTE selector)
{
COUNT i;
RES_TYPE rt;
RES_INSTANCE ri;
RES_PACKAGE rp;
MEM_HANDLE hLastIndex;
hLastIndex = SetResourceIndex (hResIndex);
if (selector == NUMBER_OF_PLANET_TYPES)
{
planet[0] = CaptureDrawable (
LoadGraphic (SAMATRA_BIG_MASK_PMAP_ANIM)
);
planet[1] = planet[2] = 0;
}
else
{
if (selector & PLANET_SHIELDED)
{
rt = GET_TYPE (SHIELDED_BIG_MASK_PMAP_ANIM);
ri = GET_INSTANCE (SHIELDED_BIG_MASK_PMAP_ANIM);
rp = GET_PACKAGE (SHIELDED_BIG_MASK_PMAP_ANIM);
}
else
{
rt = GET_TYPE (PLANET00_BIG_MASK_PMAP_ANIM);
ri = GET_INSTANCE (PLANET00_BIG_MASK_PMAP_ANIM)
+ (selector * NUM_VIEWS);
rp = GET_PACKAGE (PLANET00_BIG_MASK_PMAP_ANIM)
+ selector;
}
for (i = 0; i < NUM_VIEWS; ++i, ++ri)
{
planet[i] = CaptureDrawable (
LoadGraphic (MAKE_RESOURCE (rp, rt, ri))
);
}
}
SetResourceIndex (hLastIndex);
}
SEXP
R_convertNativeValuePtrToR(SEXP r_ptr, SEXP r_type)
{
void *ptr = R_ExternalPtrAddr(r_ptr);
llvm::Type *ty = GET_TYPE(r_type);
if(ty->getTypeID() == llvm::Type::PointerTyID)
ptr = * ((void **) ptr);
return(convertNativeValuePtrToR(ptr, ty));
}
void check_unmarked_block(Block **blocks)
{
int size;
for(size=MIN_TERM_SIZE; size<MAX_TERM_SIZE; size++) {
Block *block = blocks[size];
header_type *end = NULL;
if(blocks == at_blocks) {
end = top_at_blocks[size];
} else {
if(block) {
end = block->end;
}
}
while(block) {
header_type *cur;
for(cur=block->data ; cur<end ; cur+=size) {
ATerm t = (ATerm)cur;
if(IS_MARKED(t->header)) {
#ifdef GC_VERBOSE
fprintf(stderr,"block = %p\tdata = %p\tblock->end = %p\tend = %p\n",block,block->data,block->end,end);
fprintf(stderr,"type = %d\n",GET_TYPE(t->header));
fprintf(stderr,"t = %p\n",t);
#endif
}
if(blocks==at_old_blocks) {
assert(GET_TYPE(t->header)==AT_FREE || IS_OLD(t->header));
}
assert(!IS_MARKED(t->header));
}
block = block->next_by_size;
if(block) {
end = block->end;
}
}
}
}
// TBD - GLControl
void SlvPainter::paintPiece(int f, BaseGLWidget* context, bool fTargets) const
{
const PicDef *pdef = m_scube->dt[f].sdef();
Shape::FaceDef *face = &m_scube->shape->faces[f];
auto cd = m_scube->shape->scdrToBuildCoord(face->ex, face->dr);
auto bldtype = CubeDocBase::s_instance->getBuild().get(cd);
if (GET_TYPE(bldtype) != TYPE_REAL)
return; // the piece is not in the build shape (happens in a generate error), don't display the solution piece
//int rtnindx = m_scube->dt[f].abs_rt;
//rtnindx += pdef->dispRot;
int rtnindx = rotationSub(m_scube->dt[f].abs_rt, pdef->dispRot);
MatStack& model = context->model;
//cout << "START-MODEL " << model.cur() << endl;
model.push();
model.translate(0.5,0.5,-0.5);
model.cur().mult(m_mats[f]);
model.translate(-0.5,-0.5,0.5);
model.rotate(90, 0, 1, 0);
model.translate(0.5, 2.5, 2.5);
model.rotate(rtnindx * -90, 1, 0, 0);
if (rtnindx >= 4) {
model.rotate(180, 0, 0, 1);
model.rotate(90, 1, 0, 0);
}
model.translate(-0.5, -2.5, -2.5);
Vec3b nameb = Vec3b::fromName(f + 1);
Vec3 name = Vec3(nameb.x/255.0, nameb.y/255.0, nameb.z/255.0);
//printf("%d %d %d\n", name.x, name.y, name.z);
int flag = 0;
if (f < CubeDocBase::s_instance->m_flagPiece.size()) // can happen if not generated yet
flag = CubeDocBase::s_instance->m_flagPiece[f]; // flag to be marked in red for remove
mglCheckErrorsC("x6");
// if dispRot >= 4 it means the real part we're drawing is inverted from the model so we need to draw the texture on the other side
bool isFlipped = (pdef->dispRot >= 4);
// (for blake piece lighting) flip XOR facing out, if its flipped we want to light the other face in absolue piece coordinates
// need the rtnindx flip since we're rendering the unified mesh
bool faceOut = (rtnindx >= 4) == (face->facing == Shape::FACING_IN);
PicPainter(pdef).paint(fTargets, name, context, isFlipped, flag, pdef->dispRot, faceOut );
mglCheckErrorsC("x7");
model.pop();
}
Profile *
tracker_create_profile (tracker_t *tracker)
{
uint8_t *end = tracker->events + tracker->n_event_bytes;
StackStash *resolved_stash;
Profile *profile;
state_t *state;
uint8_t *event;
state = state_new ();
resolved_stash = stack_stash_new (g_free);
event = tracker->events;
while (event < end)
{
event_type_t type = GET_TYPE (*(uint32_t *)event);
switch (type)
{
case NEW_PROCESS:
create_process (state, (new_process_t *)event);
event += sizeof (new_process_t);
break;
case NEW_MAP:
create_map (state, (new_map_t *)event);
event += sizeof (new_map_t);
break;
case FORK:
process_fork (state, (fork_t *)event);
event += sizeof (fork_t);
break;
case EXIT:
process_exit (state, (exit_t *)event);
event += sizeof (exit_t);
break;
case SAMPLE:
process_sample (state, resolved_stash, (sample_t *)event);
event += sizeof (sample_t);
break;
}
}
profile = profile_new (resolved_stash);
state_free (state);
stack_stash_unref (resolved_stash);
return profile;
}
VOID open_obj(WORD sobj)
{
LONG tree;
WORD type;
if (rcs_state == MENU_STATE)
if (!in_bar(ad_view, sobj))
if (!menu_ok(ad_view, sobj))
return;
if (rcs_state == FREE_STATE)
if (sobj == ROOT)
return;
tree = ad_view;
obj_redraw(tree, sobj);
type = LLOBT(GET_TYPE(tree, sobj));
switch (type)
{
case G_TITLE:
case G_STRING:
case G_BUTTON:
edit_str(tree, sobj);
break;
case G_IBOX:
case G_BOX:
case G_BOXCHAR:
edit_box(tree, sobj);
break;
case G_TEXT:
case G_BOXTEXT:
case G_FTEXT:
case G_FBOXTEXT:
edit_text(tree, sobj);
break;
case G_IMAGE:
edit_bit(tree, sobj);
break;
case G_ICON:
edit_icon(tree, sobj);
break;
default:
break;
}
if (rcs_state == MENU_STATE || rcs_state == ALRT_STATE)
view_objs();
else
obj_redraw(ad_view, sobj);
}
/*
* lsa_handler - Handler for any incoming LSA from other nodes.
*
* @param sockfd routing daemon socket identifier
* @param dl pointer to direct neighbors table
* @param rt pointer to routing table
* @param ht pointer to objects hash table
* @return 1 when successful, othersize -1
*/
int lsa_handler(int sockfd, direct_links *dl, routing_table *rt, liso_hash *ht)
{
int forwarder_id;
int type;
int lsa_size;
LSA *lsa;
int i;
int tmp_type, new_ttl;
routing_entry * entry;
link_entry *src_link;
lsa = rt_recvfrom(sockfd, &forwarder_id, dl, &lsa_size);
type = GET_TYPE(lsa->version_ttl_type);
entry = get_routing_entry(rt, lsa->sender_node_id);
if(entry != NULL && entry->lsa!= NULL && ((type == TYPE_LSA && lsa->sequence_num <= entry->lsa->sequence_num) || (type == TYPE_ACK && lsa->sequence_num != entry->lsa->sequence_num))){
return -1;
}
if (type == TYPE_LSA)
{
tmp_type = lsa->version_ttl_type;
lsa->version_ttl_type = SET_TYPE(lsa->version_ttl_type,TYPE_ACK);
src_link = lookup_link_entry_node_id(dl,forwarder_id);
rt_sendto(sockfd, lsa, src_link->host, src_link->route_p, lsa_size);
lsa->version_ttl_type = SET_TYPE(lsa->version_ttl_type, tmp_type);
new_ttl = GET_TTL(lsa->version_ttl_type) - 1;
lsa->version_ttl_type = SET_TTL(lsa->version_ttl_type, new_ttl);
update_entry(entry, rt, dl, lsa, lsa_size, forwarder_id);
store_node_objects(ht,lsa);
}
else if (type == TYPE_ACK)
{
for (i = 0; i < entry->checkers_list->num_links; i++)
{
if (entry->checkers_list->checkers[i].id == forwarder_id)
{
rt->table[0].checkers_list->checkers[i].ack_received = ACK_RECEIVED;
rt->table[0].checkers_list->checkers[i].retransmit = 0;
}
}
}
return 1;
}
SEXP
R_IRBuilder_CreateIntCastInst(SEXP r_builder, SEXP r_val, SEXP r_type, SEXP r_isSigned, SEXP r_id)
{
llvm::IRBuilder<> *builder;
builder = GET_REF(r_builder, IRBuilder<>);
llvm::Value *val = GET_REF(r_val, Value);
llvm::Type *type = GET_TYPE(r_type);
llvm::Value* ans = builder->CreateIntCast(val, type, LOGICAL(r_isSigned)[0]);
if(Rf_length(r_id))
ans->setName(makeTwine(r_id));
return(R_createRef(ans, "CastInst"));
}
void Stage1_6Layer::PlayerWithPropsBeginContactCallback( GameObject* player, CCSprite *ob, b2Contact* contact, b2Vec2 localNormalToPlayer )
{
int obType = GET_TYPE(ob);
int obTag = GET_TAG(ob);
if(obType == kGameObjectUnkownBrick)
{
if(obTag == UNKNOWN_1 && localNormalToPlayer.y > 0)
{
UnknownBrick* brick = (UnknownBrick*)ob;
++m_nKnockOn1;
if(m_nKnockOn1 <= TOTAL_COUNT - 2)
{
m_needToDo.push_back(callfunc_selector(Stage1_6Layer::refresh));
}
if(m_nKnockOn1 == TOTAL_COUNT - 2)
{
m_needToDo.push_back(callfunc_selector(Stage1_6Layer::showAnother));
}
else if(m_nKnockOn1 > TOTAL_COUNT - 2)
{
m_needToDo.push_back(callfunc_selector(Stage1_6Layer::tooYoungTooSimple));
}
}
if(obTag == UNKNOWN_2 && localNormalToPlayer.y > 0)
{
m_nKnockOn2 = 1;
m_needToDo.push_back(callfunc_selector(Stage1_6Layer::refresh));
if(!m_bHasShowMonster)
{
m_bHasShowMonster = true;
m_needToDo.push_back(callfunc_selector(Stage1_6Layer::showMonster));
}
}
if (obTag == UNKNOWN_3 && localNormalToPlayer.y > 0)
{
m_nKnockOn3 = 1;
m_needToDo.push_back(callfunc_selector(Stage1_6Layer::refresh));
}
}
else if(obType == kGameObjectMonster)
{
gotoDead();
}
// 这一句要写最后
PlatformStageLayer::PlayerWithPropsBeginContactCallback(player, ob, contact, localNormalToPlayer);
}
SEXP
R_IRBuilder_CreateZExt(SEXP r_builder, SEXP r_val, SEXP r_type, SEXP r_id)
{
llvm::IRBuilder<> *builder;
builder = GET_REF(r_builder, IRBuilder<>);
llvm::Value *val = GET_REF(r_val, Value);
llvm::Type *type = GET_TYPE(r_type);
llvm::Value *ans;
ans = builder->CreateZExt(val, type);
if(Rf_length(r_id))
ans->setName(makeTwine(r_id));
return(R_createRef(ans, "Value"));
}
//---------------------------------------------------------
bool CTable_Create_Empty::On_Execute(void)
{
CSG_Table *pTable = SG_Create_Table();
pTable->Set_Name(Parameters("NAME")->asString());
//-----------------------------------------------------
int i, n;
TSG_Data_Type Type;
CSG_Parameters *pAttributes;
pAttributes = Parameters("FIELDS")->asParameters();
n = pAttributes->Get_Count() / 3;
for(i=0; i<n; i++)
{
switch( pAttributes->Get_Parameter(GET_TYPE(i))->asInt() )
{
default:
case 0: Type = SG_DATATYPE_String; break;
case 1: Type = SG_DATATYPE_Date; break;
case 2: Type = SG_DATATYPE_Color; break;
case 3: Type = SG_DATATYPE_Byte; break;
case 4: Type = SG_DATATYPE_Char; break;
case 5: Type = SG_DATATYPE_Word; break;
case 6: Type = SG_DATATYPE_Short; break;
case 7: Type = SG_DATATYPE_DWord; break;
case 8: Type = SG_DATATYPE_Int; break;
case 9: Type = SG_DATATYPE_ULong; break;
case 10: Type = SG_DATATYPE_Long; break;
case 11: Type = SG_DATATYPE_Float; break;
case 12: Type = SG_DATATYPE_Double; break;
case 13: Type = SG_DATATYPE_Binary; break;
}
pTable->Add_Field(pAttributes->Get_Parameter(GET_NAME(i))->asString(), Type);
}
Parameters("TABLE")->Set_Value(pTable);
return( true );
}
//-1 error
//-2 tc
//0 continue
//1 normal
int
check_enter(struct author *author, uchar * buf, int *idx, mbuf_type **mbuf, packet_type *lowerdomain)
{
int32_t id, typeoff;
int /*off, */ret;
int tx = 0;
dnsheader *hdr = (dnsheader *) buf;
*idx = hdr->id;
id = GET_IDX(hdr->id);
typeoff = GET_TYPE(hdr->id);
if (id >= QLIST_TABLE_SIZE || typeoff >= SUPPORT_TYPE_NUM)
return -1;
ret = check_dns_name(buf + sizeof(dnsheader), lowerdomain);
if (ret < 0)
return -1;
ret = htable_find_list(author->s->qlist, lowerdomain->domain, typeoff, id, (uchar **)mbuf);
if (ret < 0)
return -1;
if ((*mbuf)->stat == NEW_QUERY)
{
*mbuf = NULL;
return -1;
}
//-1 error
//1 tc
//0 normal
//2 retry
ret = check_an_msg(hdr->flags, NULL, &tx);
if (ret < 0)
return -1; //error
if (ret == 1) //tc
return -2;
if ((ret == 2) && (tx == 1)) //server error ,continue
return -3;
(*mbuf)->socktype = UDP; //default
return 1;
}
//clear the querying bit, free struct
//clear the querying bit, free struct
int
release_qoutinfo(struct author *author, mbuf_type *mbuf, uint32_t idx)
{
int fd = mbuf->tcpfd, epfd;
int id, typeoff;
uchar *val;
if (fd > 0)
{
struct epoll_event ev = {0};
epfd = author->bdepfd;
author->tcpinuse--;
epoll_ctl(epfd, EPOLL_CTL_DEL, fd, &ev);
author->eptcpfds[fd].ret = 0;
close(fd);
}
id = GET_IDX(idx);
typeoff = GET_TYPE(idx);
val = htable_delete_list(author->s->qlist, mbuf->lowerdomain.domain, typeoff, id);
assert(val == NULL || val == (void *)mbuf);
mbuf_free(mbuf);
return 0;
}
/* getFile()
* naplní ukazatele na FileSystem a FileNode, patřící k souboru, předanému
* přes fpath
*
* pokud filesystém k danému archivu ještě není vytvořen, zkusí jej vytvořit
*
* v pokud se patřičné objekty nepodaří nalézt, vrací false
*/
bool getFile(char* fpath, FileSystem** fs, FileNode** node) {
FusePrivate* fuse_data = PRIVATE_DATA;
ArchiveType* archive_type = NULL;
char* fpath_dup = strdup(fpath);
char* file = NULL;
if (!parsePathName(fpath_dup, &file)) {
free((void*)fpath_dup);
return false;
}
*fs = fuse_data->filesystems->find(fpath_dup);
if (*fs == NULL) {
/* Pokud nebyl odpovídající FileSystem nalezen, je možné, že
* ještě nebyl vytvořen ==> zkusím jej vytvořit.
* Pokud bude vyvolána vyjímka SourceFileError, znamená to, že
* FileSystem nemohl být vytvořen - není třeba jej uvolňovat.
* Pokud je zachycena jakákoliv jiná vyjímka, musel ji vyvolat ovladač
* patříčného archivu, přičemž objekt již byl vytvořen, proto jej
* třeba uvolnit.
*/
if ((archive_type = GET_TYPE(fpath_dup)) != NULL) {
try {
*fs = new FileSystem(fpath_dup, false, archive_type);
}
catch (ArchiveDriver::ArchiveError&) {
free((void*)fpath_dup);
return false;
}
if (fuse_data->keep_trash) FileSystem::keep_trash = true;
fuse_data->filesystems->insert(*fs);
} else {
free((void*)fpath_dup);
*fs = NULL;
return false;
}
}
// Neni potřeba vyhledavat soubor
if (node == NULL) {
free((void*)fpath_dup);
return true;
}
// Pokud je cesta prázdná - jedná se o kořen filesystému
if (file == NULL)
(*node) = (*fs)->getRoot();
else
(*node) = (*fs)->find(file);
free((void*)fpath_dup);
if (*node == NULL) {
return false;
} else {
return true;
}
}
static void dec_process(MSFilter *f) {
DecData *d = (DecData*)f->data;
mblk_t *im = NULL;
MSQueue nalus;
mblk_t *decodeM = NULL;
int in_size = 0;
jint out_size = 0;
mblk_t *oneNalu = NULL;
JNIEnv *jni_env = NULL;
JavaVM *jvm = ms_get_jvm();
static char start_code[4] = {0, 0, 0, 1};
(*jvm)->AttachCurrentThread(jvm, &jni_env, NULL);
ms_queue_init(&nalus);
while((im = ms_queue_get(f->inputs[0])) != NULL) {
/*push the sps/pps given in sprop-parameter-sets if any*/
if (d->packet_num == 0 && d->sps && d->pps) {
mblk_set_timestamp_info(d->sps,mblk_get_timestamp_info(im));
mblk_set_timestamp_info(d->pps,mblk_get_timestamp_info(im));
rfc3984_unpack(&d->unpacker,d->sps,&nalus);
rfc3984_unpack(&d->unpacker,d->pps,&nalus);
d->sps = NULL;
d->pps = NULL;
}
rfc3984_unpack(&d->unpacker,im,&nalus);
while((oneNalu = ms_queue_get(&nalus)) != NULL) {
in_size = oneNalu->b_wptr - oneNalu->b_rptr;
if (GET_TYPE(oneNalu->b_rptr[0]) == SPS_TYPE) {
if (d->sps == NULL) {
FMS_WARN("dec_process get sps\n");
d->sps = allocb(in_size + START_CODE_LEN, 0);
if (d->sps) {
memcpy(d->sps->b_rptr, start_code, START_CODE_LEN);
memcpy(d->sps->b_rptr + START_CODE_LEN, oneNalu->b_rptr, in_size);
d->sps->b_wptr += in_size + START_CODE_LEN;
}
} else {
freemsg(oneNalu);
continue;
}
} else if (GET_TYPE(oneNalu->b_rptr[0]) == PPS_TYPE) {
if (d->pps == NULL && d->sps != NULL) {
FMS_WARN("dec_process get pps\n");
d->pps = allocb(in_size + START_CODE_LEN, 0);
if (d->pps) {
memcpy(d->pps->b_rptr, start_code, START_CODE_LEN);
memcpy(d->pps->b_rptr + START_CODE_LEN, oneNalu->b_rptr, in_size);
d->pps->b_wptr += in_size + START_CODE_LEN;
}
} else {
freemsg(oneNalu);
continue;
}
}
if (d->sps == NULL || (GET_TYPE(oneNalu->b_rptr[0]) != SPS_TYPE && d->pps == NULL)) {
FMS_WARN("skip frame without no sps and pps\n");
freemsg(oneNalu);
continue;
}
if (!d->IsRecivedFirstIframe && GET_TYPE(oneNalu->b_rptr[0]) != SPS_TYPE
&& GET_TYPE(oneNalu->b_rptr[0]) != PPS_TYPE) {
if (GET_TYPE(oneNalu->b_rptr[0]) == IDR_TYPE) {
d->IsRecivedFirstIframe = TRUE;
} else {
FMS_WARN("skip frame without the first IDR\n");
freemsg(oneNalu);
continue;
}
}
(*jni_env)->SetByteArrayRegion(jni_env, d->input_data, 0, START_CODE_LEN, (jbyte*)start_code);
(*jni_env)->SetByteArrayRegion(jni_env, d->input_data, START_CODE_LEN, in_size, (jbyte*)oneNalu->b_rptr);
out_size = (*jni_env)->CallIntMethod(jni_env, d->h264_decode_obj, d->h264_decode_id,
d->input_data, in_size + START_CODE_LEN, d->output_data);
if (out_size <= 0) {
freemsg(oneNalu);
continue;
}
(*jni_env)->GetByteArrayRegion(jni_env, d->output_data, 0, out_size,
(jbyte*)d->bitstream);
if (FALSE == d->IsFirstImageDec) {
d->IsFirstImageDec = TRUE;
//ms_filter_notify_no_arg(f, MS_VIDEO_DECODER_GET_FIRST_VIDEO_FRAME);
}
decodeM = get_as_yuvmsg(f, d, d->bitstream, out_size);
if (decodeM) {
ms_queue_put(f->outputs[0], decodeM);
}
freemsg(oneNalu);
}
d->packet_num++;
}
(*jvm)->DetachCurrentThread(jvm);
}
bool initialize(FusePrivate* data) {
int ret;
ArchiveType* archive_type = NULL;
if (data->drivers_path)
path_to_drivers = realpath(data->drivers_path, NULL);
LOAD_STANDARD_DRIVERS();
if (drivers->empty()) return false;
FileSystem::setBufferLimit(data->buffer_limit);
if (data->keep_trash) FileSystem::keep_trash = true;
if (data->respect_rights) ArchiveDriver::respect_rights = true;
if (data->keep_original) ArchiveDriver::keep_original = true;
/* První část inicializace */
if (data->create_archive) {
data->mode = FusePrivate::ARCHIVE_MOUNTED;
char* path = (char*)malloc(PATH_MAX);
memset(path, 0, PATH_MAX);
getcwd(path, PATH_MAX);
strcat(path, "/");
strcat(path, data->mounted);
data->mounted = path;
/* soubor již existuje */
if (access(path, F_OK) == 0) {
cerr << "Archive file with specified name already exist" << endl;
return false;
}
/* Najdeme koncovku a ovladač */
const char* ext = findFileExt(data->mounted, NULL);
archive_type = TYPE_BY_EXT(ext);
if (archive_type == NULL) {
cerr << "Error: this type of archive files is not supported" << endl;
/* Při destrukci FusePrivate bude data->mounted uvolňován */
data->mounted = NULL;
return false;
}
if (!archive_type->write_support) {
/* Při destrukci FusePrivate bude data->mounted uvolňován */
data->mounted = NULL;
cerr << "Write support for this type of archive is not implemented, sorry" << endl;
return false;
}
} else {
data->mounted = realpath(data->mounted, NULL);
ret = errno;
if (data->mounted == NULL) {
cerr << "Error: " << strerror(ret) << endl;
return false;
}
ret = setMountMode(data);
if (ret == -1) {
cerr << "Unsupported type of source file, sorry" << endl;
return false;
} else if (ret > 0) {
cerr << "Error: " << strerror(errno) << endl;
return false;
}
}
/* Kontrola kombinace parametrů */
if (!controlArgs(data)) {
cerr << "Invalid combination of parameters" << endl;
return false;
}
/* Druhá část inicializace - budování FileSystémů ze zdrojů */
FileSystem* fs = NULL;
if (data->mode == FusePrivate::ARCHIVE_MOUNTED) {
/* Pokud se vytváří nový archiv, ovladač je již načten.
* Pokud ne, je třeba jej načíst.
*/
if (!data->create_archive) {
/* data->mounted už je realpath-ed */
archive_type = GET_TYPE(data->mounted);
if (archive_type == NULL) {
cerr << "Error: Could not load driver for " << data->mounted << endl;
return false;
}
}
try {
fs = new FileSystem(data->mounted, data->create_archive, archive_type);
}
catch (ArchiveDriver::ArchiveError&) {
cerr << "Error: Failed to open/process archive file" << endl;
return false;
}
data->filesystems->insert(fs);
} else {
DIR* dir;
struct dirent* file;
struct stat info;
char filename[PATH_MAX];
char* filename_ptr;
unsigned mounted_len = strlen(data->mounted);
strcpy(filename, data->mounted);
filename[mounted_len] = '/';
filename_ptr = filename + mounted_len + 1;
/* Projdu celý připojený adresář a pokud obsahuje archivy podporovaných typů
* vytvořím jejich filesystémy */
dir = opendir(data->mounted);
while ((file = readdir(dir)) != NULL) {
if (strcmp(file->d_name, ".") == 0 || strcmp(file->d_name, "..") == 0)
continue;
archive_type = NULL;
// Získání celé cesty k archivu
strcpy(filename_ptr, file->d_name);
if (stat(filename, &info) != 0) continue;
if (S_ISREG(info.st_mode) || S_ISLNK(info.st_mode)) {
archive_type = GET_TYPE(filename);
if (archive_type != NULL) {
try {
fs = new FileSystem(filename, false, archive_type);
}
catch (...) {
continue;
}
data->filesystems->insert(fs);
}
}
}
closedir(dir);
}
// cout << "FILESYSTEM IS INITIALIZED" << endl;
return true;
}
static void do_work(Proc_t *proc, int additionalWork)
{
Heap_t *srcRange = (GCType == Minor) ? nursery : fromSpace;
if (additionalWork <= 0)
return;
addMaxWork(proc, additionalWork);
procChangeState(proc, GCWork, 612);
proc->segmentType |= (GCType == Major) ? MajorWork : MinorWork;
if (collectDiag >= 2)
printf("GC %4d/%6d: Entered do_work(%d) updateWorkDone = %5d\n",
NumGC, proc->segmentNumber, additionalWork, updateGetWorkDone(proc));
while (!reachMaxWork(proc)) {
ploc_t rootLoc, globalLoc, backLoc;
ptr_t backObj, gray;
int largeStart, largeEnd;
Stacklet_t *stacklet;
/* Get shared work */
popSharedStack(workStack, &proc->work);
if ((GCStatus == GCPendingOn || GCStatus == GCPendingOff) &&
isLocalWorkEmpty(&proc->work))
break;
/* Do the thread stacklets - we can afford to call updateWorkDone often */
while (!reachCheckWork(proc) &&
((stacklet = (Stacklet_t *) SetPop(&proc->work.stacklets)) != NULL)) {
if (!work_root_scan(proc, stacklet))
SetPush(&proc->work.stacklets, (ptr_t) stacklet);
}
/* Do the rootLocs */
if (GCType == Minor) {
while (!reachCheckWork(proc) &&
((rootLoc = (ploc_t) SetPop(&proc->work.roots)) != NULL)) {
locAlloc1_copyCopySync_primarySet(proc,rootLoc,srcRange);
proc->segUsage.fieldsScanned++;
}
}
else {
while (!reachCheckWork(proc) &&
((rootLoc = (ploc_t) SetPop(&proc->work.roots)) != NULL)) {
locAlloc1L_copyCopySync_primarySet(proc,rootLoc,srcRange,largeSpace);
proc->segUsage.fieldsScanned++;
}
}
/* Do the backObjs and backLocs */
if (GCType == Minor) {
while (!updateReachCheckWork(proc) &&
((backObj = (ptr_t) SetPop(&proc->work.backObjs)) != NULL)) {
selfTransferScanObj_locAlloc1_copyCopySync_primarySet(proc,backObj,srcRange);
}
while (!reachCheckWork(proc) &&
((backLoc = (ploc_t) SetPop(&proc->work.backLocs)) != NULL)) {
ploc_t mirrorBackLoc = backLoc + ((primaryArrayOffset == 0) ? 1 : -1);
*mirrorBackLoc = *backLoc;
locAlloc1_copyCopySync_primarySet(proc,mirrorBackLoc,srcRange);
proc->segUsage.fieldsScanned += 2;
}
}
else {
SetReset(&proc->work.backObjs);
SetReset(&proc->work.backLocs);
}
/* Do the globalLocs */
if (GCType == Minor)
while (!reachCheckWork(proc) &&
((globalLoc = (ploc_t) SetPop(&proc->work.globals)) != NULL)) {
ploc_t replicaLoc = (ploc_t) DupGlobal((ptr_t) globalLoc);
locAlloc1_copyCopySync_primarySet(proc,replicaLoc,srcRange);
proc->segUsage.globalsProcessed++;
}
else
while (!reachCheckWork(proc) &&
((globalLoc = (ploc_t) SetPop(&proc->work.globals)) != NULL)) {
ploc_t replicaLoc = (ploc_t) DupGlobal((ptr_t) globalLoc);
locAlloc1L_copyCopySync_primarySet(proc,replicaLoc,srcRange,largeSpace);
proc->segUsage.globalsProcessed++;
}
/* Do the large objects - don't need to optimize loop */
while (!updateReachCheckWork(proc) &&
(gray = SetPop3(&proc->work.segments,(ptr_t *)&largeStart,(ptr_t *)&largeEnd))) {
if (GCType == Minor) {
int isMirrorPtrArray = (GET_TYPE(gray[-1]) == MIRROR_PTR_ARRAY_TYPE);
if (isMirrorPtrArray) {
fastAssert(inHeap(gray, fromSpace));
selfTransferScanSegment_copyWriteSync_locAlloc1_copyCopySync_primarySet(proc,gray,largeStart,largeEnd,srcRange);
}
else
transferScanSegment_copyWriteSync_locAlloc1_copyCopySync_primarySet(proc,gray,largeStart,largeEnd,srcRange);
}
else
transferScanSegment_copyWriteSync_locAlloc1L_copyCopySync_primarySet(proc,gray,largeStart,largeEnd,srcRange, largeSpace);
}
/* Work on the gray objects */
if (GCType == Minor)
while (!reachCheckWork(proc) &&
((gray = SetPop(&proc->work.objs)) != NULL))
transferScanObj_copyWriteSync_locAlloc1_copyCopySync_primarySet(proc,gray,srcRange);
else
while (!reachCheckWork(proc) &&
((gray = SetPop(&proc->work.objs)) != NULL))
transferScanObj_copyWriteSync_locAlloc1L_copyCopySync_primarySet(proc,gray,srcRange,largeSpace);
/* Put work back on shared stack */
if (pushSharedStack(0,workStack,&proc->work)) {
if (GCStatus == GCAgressive)
GCStatus = GCPendingOn;
else if (GCStatus == GCOn)
GCStatus = GCPendingOff;
}
}
assert(isLocalWorkEmpty(&proc->work));
if (collectDiag >= 2)
printf("GC %d Seg %d: Completed do_work(%d) segWork = %5d sharedStack(%4ld items %2ld segs) %ld alloc %ld copied\n",
NumGC, proc->segmentNumber, additionalWork, updateGetWorkDone(proc),
SetLength(&workStack->work.objs), SetLength(&workStack->work.segments),
proc->cycleUsage.bytesAllocated + proc->segUsage.bytesAllocated,
bytesCopied(&proc->cycleUsage) + bytesCopied(&proc->segUsage));
}
void GCRelease_GenConc(Proc_t *proc)
{
mem_t allocCurrent = proc->allocStart;
mem_t allocStop = proc->allocCursor;
ploc_t writelistCurrent = proc->writelistStart;
ploc_t writelistStop = proc->writelistCursor;
int isGCAgressive = (GCType == Major ? doAgressive : doMinorAgressive) ?
(GCStatus == GCAgressive) || (GCStatus == GCPendingOn) : 0;
int isGCOn = isGCAgressive || (GCStatus == GCOn) || (GCStatus == GCPendingOff);
Heap_t *srcRange = (GCType == Minor) ? nursery : fromSpace;
int numWrites = (proc->writelistCursor - proc->writelistStart) / 3;
/* Reset cursors */
proc->allocStart = proc->allocCursor;
proc->writelistCursor = proc->writelistStart;
/* Replicate objects allocated by mutator when the collector is on */
if (isGCOn && !isGCAgressive) {
procChangeState(proc, GCReplicate, 613);
if (collectDiag >= 2)
printf("GC %4d/%6d: Double-allocating %lx to %lx\n",
NumGC, proc->segmentNumber, (long)allocCurrent,(long)allocStop);
proc->segUsage.bytesReplicated += sizeof(val_t) * (allocStop - allocCurrent);
while (allocCurrent + 1 <= allocStop) { /* There may be no data for empty array */
int objSize;
ptr_t obj = allocCurrent; /* Eventually becomes start of object */
tag_t tag = *obj;
if (IS_SKIP_TAG(tag)) {
allocCurrent += GET_SKIPWORD(tag);
continue;
}
while (tag == SEGPROCEED_TAG || tag == SEGSTALL_TAG)
tag = *(++obj); /* Skip past segment tags */
obj++; /* Skip past object tag */
alloc_copyCopySync_primarySet(proc,obj);
objSize = proc->bytesCopied;
if (objSize == 0) {
mem_t dummy = NULL;
objSize = objectLength(obj, &dummy);
fastAssert(dummy == allocCurrent);
}
allocCurrent += objSize / sizeof(val_t);
}
}
/* Process writes */
if (collectDiag >= 2 && writelistCurrent < writelistStop)
printf("Proc %d: Processing %d writes from %lx to %lx\n",
proc->procid,numWrites,(long)writelistCurrent,(long)writelistStop);
procChangeState(proc, GCWrite, 614);
while (writelistCurrent < writelistStop) {
ptr_t mutatorPrimary = *writelistCurrent++; /* Global, nursery, or fromSpace */
int byteDisp = (int) *writelistCurrent++;
ptr_t possPrevPtrVal = (ptr_t) *writelistCurrent++; /* Pointer value only if pointer array was modified */
int wordDisp = byteDisp / sizeof(val_t);
int mirrorWordDisp = (primaryArrayOffset == 0) ? wordDisp + 1 : wordDisp - 1;
int doubleWordDisp = byteDisp / (sizeof(double));
int byteLen; /* Length of data portion of array */
int syncIndex;
if (IsGlobalData(mutatorPrimary)) {
add_global_root(proc,mutatorPrimary);
continue;
}
if (inHeap(mutatorPrimary, largeSpace))
continue;
if (!isGCOn) { /* Record back-pointers when GC is off for roots of next GC */
if (GCType == Minor && /* If next GC is major, no backLocs needed */
inHeap(mutatorPrimary, fromSpace)) {
tag_t tag = mutatorPrimary[-1];
if (GET_TYPE(tag) == MIRROR_PTR_ARRAY_TYPE) {
SetPush(&proc->work.backLocs, (ptr_t) &mutatorPrimary[wordDisp]);
SetPush(&proc->work.nextBackLocs, (ptr_t) &mutatorPrimary[mirrorWordDisp]);
}
else
fastAssert((GET_TYPE(tag) == WORD_ARRAY_TYPE ||
GET_TYPE(tag) == QUAD_ARRAY_TYPE));
}
}
else {
vptr_t nurseryPrimary = NULL; /* Used if primary was in nursery */
vptr_t fromSpaceEither = NULL; /* Used for primaryReplica or (minor replica/major primary) */
vptr_t toSpaceReplica = NULL; /* Used only during major GC*/
tag_t tag; /* Actual tag deteremined after traversing forwarding pointers */
/* Make a copy of the modified arrays and get tag */
if (inHeap(mutatorPrimary, nursery)) {
fastAssert(GCType == Minor);
nurseryPrimary = mutatorPrimary;
tag = nurseryPrimary[-1];
/* If object has not been copied, simply gray previous pointer value */
switch (GET_TYPE(tag)) {
case PTR_ARRAY_TYPE:
case MIRROR_PTR_ARRAY_TYPE:
alloc1_copyCopySync_primarySet(proc,possPrevPtrVal, srcRange);
continue;
case WORD_ARRAY_TYPE:
case QUAD_ARRAY_TYPE:
continue;
}
while ((val_t)(fromSpaceEither = (ptr_t) nurseryPrimary[-1]) == STALL_TAG)
;
tag = fromSpaceEither[-1];
}
else if (inHeap(mutatorPrimary,fromSpace)) {
fromSpaceEither = mutatorPrimary;
if (GCType == Major) {
alloc1_copyCopySync_primarySet(proc,(ptr_t) fromSpaceEither,srcRange);
toSpaceReplica = (ptr_t) fromSpaceEither[-1];
tag = toSpaceReplica[-1];
}
else
tag = fromSpaceEither[-1];
}
else
DIE("mutatorPrimary in neither fromSpace nor nursery");
/* Copy-Write synchronization on replica object */
byteLen = GET_ANY_ARRAY_LEN(tag);
syncIndex = (byteLen <= arraySegmentSize) ? -1 : -2-(DivideDown(byteDisp, arraySegmentSize));
if (nurseryPrimary)
while (fromSpaceEither[syncIndex] == SEGSTALL_TAG)
;
else if (toSpaceReplica)
while (toSpaceReplica[syncIndex] == SEGSTALL_TAG)
;
switch (GET_TYPE(tag)) {
case WORD_ARRAY_TYPE:
if (nurseryPrimary) {
if (fromSpaceEither[0] == (val_t) nurseryPrimary) /* Backpointer present indicates object not yet scanned - can/must skip replica update */
break;
fromSpaceEither[wordDisp] = nurseryPrimary[wordDisp];
}
if (toSpaceReplica)
toSpaceReplica[wordDisp] = fromSpaceEither[wordDisp];
break;
case QUAD_ARRAY_TYPE:
if (nurseryPrimary) {
if (fromSpaceEither[0] == (val_t) nurseryPrimary) /* Backpointer present indicates object not yet scanned - can/must skip replica update */
break;
((double *)fromSpaceEither)[doubleWordDisp] = ((double *)nurseryPrimary)[doubleWordDisp];
}
if (toSpaceReplica)
((double *)toSpaceReplica)[doubleWordDisp] = ((double *)fromSpaceEither)[doubleWordDisp];
break;
case PTR_ARRAY_TYPE:
DIE("pointer array");
case MIRROR_PTR_ARRAY_TYPE: {
/* Snapshot-at-the-beginning (Yuasa) write barrier requires copying prevPtrVal
even if it might die to prevent the mutator from hiding live data.
There are several cases:
(1) MinorGC: The original array is in nursery/fromSpace.
(i) (a) The field is in nursery. Update new/existing array (replica entry) with new (fromSpace) field.
(b) The field is in fromSpace. Update new/existing array (replica entry) with same field.
(c) The field is in global/largeSpace. Update new/existing array (replica entry) with same field.
(ii) If original array in fromSpace, add location to backLocs for replication. Same as when GC is off.
(3) MajorGC: The original array must be in fromSpace.
(a) The field is in fromSpace. Update new array (replica entry) with new (toSpace) field.
(b) The field is in global/largeSpace. Update new array with field. (toSpaceField is NULL).
*/
ptr_t mutatorField = (ptr_t) mutatorPrimary[wordDisp];
fastAssert(((byteDisp - primaryArrayOffset) % (2 * sizeof(val_t))) == 0);
/* Snapshot-at-the-beginning (Yuasa) write barrier requires copying prevPtrVal
even if it might die to prevent the mutator from hiding live data */
alloc1_copyCopySync_primarySet(proc,possPrevPtrVal,srcRange);
if (GCType == Minor) {
ptr_t newField = mutatorField;
if (inHeap(newField, nursery)) {
alloc1_copyCopySync_primarySet(proc,mutatorField,srcRange);
newField = (ptr_t) mutatorField[-1];
}
fastAssert(!inHeap(newField, nursery));
if (fromSpaceEither[0] == (val_t) mutatorPrimary) /* Backpointer present indicates object not yet scanned - can/must skip replica update */
break;
fromSpaceEither[mirrorWordDisp] = (val_t) newField;
if (inHeap(mutatorPrimary, nursery))
fromSpaceEither[wordDisp] = (val_t) newField;
else {
fastAssert(inHeap(mutatorPrimary, fromSpace));
SetPush(&proc->work.backLocs, (ptr_t) &mutatorPrimary[wordDisp]);
SetPush(&proc->work.nextBackLocs, (ptr_t) &mutatorPrimary[mirrorWordDisp]);
}
}
else { /* GCType == Major */
ptr_t newField = mutatorField;
fastAssert(inHeap(mutatorPrimary,fromSpace));
if (inHeap(newField,fromSpace)) {
alloc1L_copyCopySync_primarySet(proc,mutatorField,srcRange,largeSpace);
newField = (ptr_t) mutatorField[-1];
}
if (toSpaceReplica[0] == (val_t) mutatorPrimary) /* Backpointer present indicates object not yet scanned - can/must skip replica update */
break;
toSpaceReplica[wordDisp] = (val_t) newField;
toSpaceReplica[mirrorWordDisp] = (val_t) newField;
}
break;
}
default:
DIE("bad tag type");
} /* else */
} /* switch */
} /* while */
if (isGCOn)
pushSharedStack(1,workStack, &proc->work);
}
//---------------------------------------------------------
void CTable_Create_Empty::_Set_Field_Count(CSG_Parameters *pAttributes, int nAttributes)
{
//-----------------------------------------------------
CSG_String Types;
Types = CSG_String::Format(SG_T("%s|%s|%s|%s|%s|%s|%s|%s|%s|%s|%s|%s|%s|%s|"),
SG_Data_Type_Get_Name(SG_DATATYPE_String).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Date ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Color ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Byte ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Char ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Word ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Short ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_DWord ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Int ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_ULong ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Long ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Float ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Double).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Binary).c_str()
);
//-----------------------------------------------------
if( pAttributes && nAttributes > 0 )
{
int nCurrent = pAttributes->Get_Count() / 3;
if( nCurrent < nAttributes )
{
for(int i=nCurrent; i<nAttributes; i++)
{
CSG_Parameter *pNode = pAttributes->Add_Node(
NULL , GET_NODE(i), CSG_String::Format(SG_T("%i. %s"), i + 1, _TL("Attribute")), _TL("")
);
pAttributes->Add_String(
pNode , GET_NAME(i), _TL("Name"), _TL(""), _TL("Name")
);
pAttributes->Add_Choice(
pNode , GET_TYPE(i), _TL("Type"), _TL(""), Types
);
}
}
else if( nCurrent > nAttributes )
{
CSG_Parameters Tmp;
Tmp.Assign(pAttributes);
pAttributes->Destroy();
pAttributes->Set_Name(Tmp.Get_Name());
for(int i=0; i<nAttributes; i++)
{
CSG_Parameter *pNode = pAttributes->Add_Node(
NULL , GET_NODE(i), CSG_String::Format(SG_T("%i. %s"), i + 1, _TL("Attribute")), _TL("")
);
pAttributes->Add_String(
pNode , GET_NAME(i), _TL("Name"), _TL(""), Tmp(GET_NAME(i)) ? Tmp(GET_NAME(i))->asString() : _TL("Name")
);
pAttributes->Add_Choice(
pNode , GET_TYPE(i), _TL("Type"), _TL(""), Types, Tmp(GET_TYPE(i)) ? Tmp(GET_TYPE(i))->asInt() : 0
);
}
}
}
}
/* Show the object whose raw beginning (i.e. including tag(s)) is at s */
static mem_t
show_obj(mem_t start, ptr_t* objRef, int show, ShowType_t replicaType,
Heap_t** legalHeaps, Bitmap_t** legalStarts)
{
int i, type;
mem_t temp, end = NULL;
tag_t tag;
ptr_t obj, replica;
/* Skip past all extra tags (belonging to the obj) at the beginning */
temp = start;
while(*temp == SEGSTALL_TAG || *temp == SEGPROCEED_TAG)
temp++;
tag = *temp;
obj = temp + 1;
replica = obj; /* replica ultimately is 0 if equal to obj */
if(show && !IS_SKIP_TAG(tag)){
printf("%lx: ", (long)start);
if(start < obj - 1){
printf("[");
for (temp=start; temp < start - 1; temp++)
printf("%d%s", *temp, (temp < start - 2) ? ", " : "");
printf("]");
}
}
while(TAG_IS_FORWARD(tag)){
assert(replica != (ptr_t) tag);
replica = (ptr_t) tag;
tag = replica[-1];
if(show)
printf( " -> %lx", (long)replica);
if(0 && inHeaps(replica, legalHeaps, NULL))
trace_error("forwarding pointer is in same heap(s): %lx -> %lx",
obj, replica);
}
if(obj==replica || replicaType==NoReplica)
replica = 0;
if(show)
printf (": ");
type = GET_TYPE(tag);
switch(type){
case RECORD_TYPE:{
int len = GET_RECLEN(tag);
int mask = GET_RECMASK(tag);
if(mask >> len){
trace_error("bad record tag %d at %lx\n", tag, (long)start);
DIE("bad record tag in show_obj");
}
if(show)
printf("REC(%d) %lx: ", len, (long)obj);
for(i=0; i<len; i++){
int isPointer = 1 & (mask >> i);
show_field(show,
isPointer ? PointerField : IntField,
obj, replica, i, i, legalHeaps, legalStarts);
}
if(show)
printf("\n");
end = obj + len;
break;
}
case MIRROR_PTR_ARRAY_TYPE:{
unsigned int bytelen = GET_ANY_ARRAY_LEN(tag);
unsigned int wordlen = (bytelen + 3) / 4;
unsigned int loglen = wordlen / 2;
int i;
if(show)
printf("MPA(%ld/%ld) %lx: ",
(long)wordlen,(long)loglen,(long)obj);
for(i=0; i<loglen; i++){
if(show && i != 0 && i % 4 == 0)
printf(" ");
if(!mirrorArray){
assert(primaryArrayOffset == 0);
show_field(show, PointerField, obj, replica,
2*i, 2*i, legalHeaps, legalStarts);
}
else{
int doReplica = replicaType != NoReplica;
if(replicaType == SelfReplica && replica == NULL)
/* self is replica if in tenured space */
replica = obj;
if(primaryArrayOffset == 0){
show_field(show,
doReplica ? OldPointerField : PointerField,
obj, replica, 2*i, 2*i+1,
legalHeaps, legalStarts);
show_field(show,
doReplica ? PointerField : IntField,
obj, NULL, 2*i+1, 2*i,
legalHeaps, legalStarts);
}
else{
show_field(show,
doReplica ? PointerField : IntField,
obj, NULL, 2*i, 2*i+1,
legalHeaps, legalStarts);
show_field(show,
doReplica ? OldPointerField : PointerField,
obj, replica, 2*i+1, 2*i,
legalHeaps, legalStarts);
}
if(show)
printf(" ");
}
}
if(show)
printf("\n");
end = obj + wordlen;
break;
}
case WORD_ARRAY_TYPE:
case QUAD_ARRAY_TYPE:
case PTR_ARRAY_TYPE:{
unsigned int bytelen = GET_ANY_ARRAY_LEN(tag);
unsigned int wordlen = (bytelen + 3) / 4;
unsigned int loglen, fieldlen;
char *typeDesc = NULL;
switch(type){
case WORD_ARRAY_TYPE:
loglen = bytelen;
fieldlen = wordlen;
typeDesc = "IAR";
break;
case QUAD_ARRAY_TYPE:
loglen = bytelen / 8;
fieldlen = loglen;
typeDesc = "RAR";
break;
case PTR_ARRAY_TYPE:
loglen = bytelen / 4;
fieldlen = loglen;
typeDesc = "PAR";
break;
default:
DIE("impossible");
}
if(show)
printf("%s(%ld/%ld) %lx: ",
typeDesc,(long)wordlen,(long)loglen,(long)obj);
for(i=0; i<fieldlen; i++){
if(show && i != 0 && i%8 == 0)
printf(" ");
switch(type){
case WORD_ARRAY_TYPE:
show_field(show,IntField,obj,replica,i,i,
legalHeaps,legalStarts);
break;
case PTR_ARRAY_TYPE:
show_field(show,PointerField,obj,replica,i,i,
legalHeaps,legalStarts);
break;
case QUAD_ARRAY_TYPE:
show_field(show,DoubleField,obj,replica,i,i,
legalHeaps,legalStarts);
break;
default :
DIE("impossible");
}
if(show && (i+1)%8 == 0)
printf("\n");
}
if(show)
printf("\n");
end = obj + wordlen;
break;
}
case OTHER_TYPE:
if(IS_SKIP_TAG(tag)){
int wordsSkipped = GET_SKIPWORD(tag);
end = start + wordsSkipped;
if(show)
printf("%lx - %lx: SKIP %d words\n",
(long)start, (long)end, wordsSkipped);
assert(wordsSkipped > 0);
}
else if(tag==MIRROR_GLOBAL_PTR_TAG){
if(show)
printf("MIRROR_GLOBAL %lx: ", (long)obj);
if(!mirrorGlobal){
assert(primaryGlobalOffset == 0);
show_field(show, PointerField, obj, replica, 0, 0,
legalHeaps, legalStarts);
}
else{
int doReplica = replicaType != NoReplica;
if(replicaType == SelfReplica && replica == NULL)
/* self is replica if in tenured space */
replica = obj;
if(primaryGlobalOffset == 0){
show_field(show,
doReplica ? OldPointerField : PointerField,
obj, replica, 0, 1, legalHeaps, legalStarts);
show_field(show,
doReplica ? PointerField : IntField,
obj, NULL, 1, 0, legalHeaps, legalStarts);
}
else{
show_field(show,
doReplica ? PointerField : IntField,
obj, NULL, 0, 1, legalHeaps, legalStarts);
show_field(show,
doReplica ? OldPointerField : PointerField,
obj, replica, 1, 0, legalHeaps, legalStarts);
}
}
if(show)
printf("\n");
end = obj + 2;
}
else{
trace_error("bad tag %d(%d) at address = %lx",
tag,GET_TYPE(tag),(long)obj);
DIE("bad tag in show_obj");
}
break;
}
*objRef = obj;
return end;
}
