//////////////////////////////////
// Cast an expression to a type //
//////////////////////////////////
TNode *CastNode::translate( Codegen *g ){
TNode *t=expr->translate( g );
if( expr->sem_type==Type::float_type && sem_type==Type::int_type ){
//float->int
return d_new TNode( IR_CAST,t,0 );
}
if( expr->sem_type==Type::int_type && sem_type==Type::float_type ){
//int->float
return d_new TNode( IR_FCAST,t,0 );
}
if( expr->sem_type==Type::string_type && sem_type==Type::int_type ){
//str->int
return call( "__bbStrToInt",t );
}
if( expr->sem_type==Type::int_type && sem_type==Type::string_type ){
//int->str
return strcall( "__bbStrFromInt",t );
}
if( expr->sem_type==Type::string_type && sem_type==Type::float_type ){
//str->float
return fcall( "__bbStrToFloat",t );
}
if( expr->sem_type==Type::float_type && sem_type==Type::string_type ){
//float->str
return strcall( "__bbStrFromFloat",t );
}
if( expr->sem_type->structType() && sem_type==Type::string_type ){
//obj->str
return strcall( "__bbObjToStr",t );
}
return t;
}
TNode *CallNode::translate( Codegen *g ){
FuncType *f=sem_decl->type->funcType();
TNode *t;
TNode *l=global( "_f"+ident );
TNode *r=exprs->translate( g,f->userlib );
if( f->userlib ){
l=d_new TNode( IR_MEM,l );
usedfuncs.insert( ident );
}
if( sem_type==Type::float_type ){
t=d_new TNode( IR_FCALL,l,r,exprs->size()*4 );
}else{
t=d_new TNode( IR_CALL,l,r,exprs->size()*4 );
}
if( f->returnType->stringType() ){
if( f->userlib ){
t=strcall( "__bbStrFromCStr",t );
}else{
t=strcall( "__bbStrTmp",t );
}
}
return t;
}
/////////////////////////////////////////////////
// Bipartite graph
int TBPGraph::AddNode(int NId, const bool& LeftNode) {
if (NId == -1) { NId = MxNId; MxNId++; }
else if (IsLNode(NId)) { IAssertR(LeftNode, TStr::Fmt("Node with id %s already exists on the 'left'.", NId)); return NId; }
else if (IsRNode(NId)) { IAssertR(! LeftNode, TStr::Fmt("Node with id %s already exists on the 'right'.", NId)); return NId; }
else { MxNId = TMath::Mx(NId+1, MxNId()); }
if (LeftNode) { LeftH.AddDat(NId, TNode(NId)); }
else { RightH.AddDat(NId, TNode(NId)); }
return NId;
}
// add a node with a list of neighbors
// (use TNGraphMP::IsOk to check whether the graph is consistent)
void TNEANetMP::AddNodeWithEdges(const TInt& NId, TIntV& InEIdV, TIntV& OutEIdV) {
int NodeIdx = abs((NId.GetPrimHashCd()) % Reserved());
int NodeKeyId = NodeH.AddKey13(NodeIdx, NId);
NodeH[NodeKeyId] = TNode(NId);
NodeH[NodeKeyId].InEIdV.MoveFrom(InEIdV);
NodeH[NodeKeyId].OutEIdV.MoveFrom(OutEIdV);
}
int TUNGraph::AddNode(int NId) {
if (NId == -1) { NId = MxNId; MxNId++; }
else if (IsNode(NId)) { return NId; } // already a node
else { MxNId = TMath::Mx(NId+1, MxNId()); }
NodeH.AddDat(NId, TNode(NId));
return NId;
}
const TNode ArrayInfo::getModelRep(const TNode a) const
{
CNodeInfoMap::const_iterator it = info_map.find(a);
if(it!= info_map.end()) {
return (*it).second->modelRep;
}
return TNode();
}
void NodeValue::toStream(std::ostream& out, int toDepth, bool types, size_t dag,
OutputLanguage language) const {
// Ensure that this node value is live for the length of this call.
// It really breaks things badly if we don't have a nonzero ref
// count, even just for printing.
RefCountGuard guard(this);
Printer::getPrinter(language)->toStream(out, TNode(this), toDepth, types, dag);
}
// Add a node of ID NId to the graph.
int TUNGraph::AddNode(int NId) {
if (NId == -1) {
NId = MxNId; MxNId++;
} else {
IAssertR(!IsNode(NId), TStr::Fmt("NodeId %d already exists", NId));
MxNId = TMath::Mx(NId+1, MxNId());
}
NodeH.AddDat(NId, TNode(NId));
return NId;
}
void
CSlmBuilder::AddNGram(TSIMWordId* ngram, FREQ_TYPE fr)
{
int ch;
bool brk = isExcludeId(*ngram);
for (int i = 1; i < nlevel; ++i) {
TNodeLevel* pnl = (TNodeLevel*)(level[i]);
if (pnl->capacity() == pnl->size()) {
size_t newsz = 2 * pnl->capacity();
if (pnl->capacity() > 1024 * 1024)
newsz = pnl->capacity() + 1024 * 1024;
pnl->reserve(newsz);
}
}
TLeafLevel* pll = (TLeafLevel*)(level[nlevel]);
if (pll->capacity() == pll->size()) {
size_t newsz = 2 * pll->capacity();
if (pll->capacity() > 1024 * 1024)
newsz = pll->capacity() + 1024 * 1024;
pll->reserve(newsz);
}
if (!brk)
(*(TNodeLevel*)(level[0]))[0].freq += fr;
bool branch = false;
for (int i = 1; (!brk && i < nlevel); ++i) {
std::vector<TNode> & pv = *(TNodeLevel*)(level[i - 1]);
std::vector<TNode> & v = *(TNodeLevel*)(level[i]);
branch = branch || (pv.back().child >= (int) v.size()) ||
(v.back().id != ngram[i - 1]);
if (branch) {
if (i == nlevel - 1)
ch = ((TLeafLevel*)(level[i + 1]))->size();
else
ch = ((TNodeLevel*)(level[i + 1]))->size();
v.push_back(TNode(ngram[i - 1], ch, fr));
} else {
v.back().freq += fr;
}
brk = (i > 1 && isBreakId(ngram[i - 1])) || isExcludeId(ngram[i]);
}
// Insert to the leaf level
if (!brk) {
if (fr > cut[nlevel]) {
TLeafLevel& v = *(TLeafLevel*)(level[nlevel]);
v.push_back(TLeaf(ngram[nlevel - 1], fr));
} else {
nr[nlevel][0] += fr;
nr[nlevel][fr] += fr;
}
}
}
void*
CSlmBuilder::FindChild(int lvl, TNode* root, TSIMWordId id)
{
int chh = root->child, cht = (root + 1)->child;
if (lvl == nlevel - 1) {
TLeaf* pleaf = &((*(TLeafLevel*)level[lvl + 1])[0]);
return (void*)binary_find(pleaf, chh, cht, TLeaf(id));
} else {
TNode* pnode = &((*(TNodeLevel*)level[lvl + 1])[0]);
return (void*)binary_find(pnode, chh, cht, TNode(id));
}
}
TNode *ExprSeqNode::translate( Codegen *g,bool userlib ){
TNode *t=0,*l=0;
for( int k=0;k<exprs.size();++k ){
TNode *q=exprs[k]->translate(g);
//USERLIB!
if( userlib ){
Type *ty=exprs[k]->sem_type;
if( ty->stringType() ){
q=call( "__bbStrToCStr",q );
}else if( ty->structType() ){
q=d_new TNode( IR_MEM,q );
}else if( ty==Type::void_type ){
q=d_new TNode( IR_MEM,add(q,iconst(28)) );
}
}
TNode *p;
p=d_new TNode( IR_ARG,0,0,k*4 );
p=d_new TNode( IR_MEM,p,0 );
p=d_new TNode( IR_MOVE,q,p );
p=d_new TNode( IR_SEQ,p,0 );
if( l ) l->r=p;
else t=p;
l=p;
}
return t;
}
int TNEANetMP::AddNode(int NId) {
int i;
if (NId == -1) {
NId = MxNId;
MxNId++;
} else {
IAssertR(!IsNode(NId), TStr::Fmt("NodeId %d already exists", NId));
MxNId = TMath::Mx(NId+1, MxNId());
}
// update attribute columns
NodeH.AddDat(NId, TNode(NId));
for (i = 0; i < VecOfIntVecsN.Len(); i++) {
TVec<TInt>& IntVec = VecOfIntVecsN[i];
IntVec.Ins(NodeH.GetKeyId(NId), TInt::Mn);
}
TVec<TStr> DefIntVec = TVec<TStr>();
IntDefaultsN.GetKeyV(DefIntVec);
for (i = 0; i < DefIntVec.Len(); i++) {
TStr attr = DefIntVec[i];
TVec<TInt>& IntVec = VecOfIntVecsN[KeyToIndexTypeN.GetDat(DefIntVec[i]).Val2];
IntVec[NodeH.GetKeyId(NId)] = GetIntAttrDefaultN(attr);
}
for (i = 0; i < VecOfStrVecsN.Len(); i++) {
TVec<TStr>& StrVec = VecOfStrVecsN[i];
StrVec.Ins(NodeH.GetKeyId(NId), TStr::GetNullStr());
}
TVec<TStr> DefStrVec = TVec<TStr>();
IntDefaultsN.GetKeyV(DefStrVec);
for (i = 0; i < DefStrVec.Len(); i++) {
TStr attr = DefStrVec[i];
TVec<TStr>& StrVec = VecOfStrVecsN[KeyToIndexTypeN.GetDat(DefStrVec[i]).Val2];
StrVec[NodeH.GetKeyId(NId)] = GetStrAttrDefaultN(attr);
}
for (i = 0; i < VecOfFltVecsN.Len(); i++) {
TVec<TFlt>& FltVec = VecOfFltVecsN[i];
FltVec.Ins(NodeH.GetKeyId(NId), TFlt::Mn);
}
TVec<TStr> DefFltVec = TVec<TStr>();
FltDefaultsN.GetKeyV(DefFltVec);
for (i = 0; i < DefFltVec.Len(); i++) {
TStr attr = DefFltVec[i];
TVec<TFlt>& FltVec = VecOfFltVecsN[KeyToIndexTypeN.GetDat(DefFltVec[i]).Val2];
FltVec[NodeH.GetKeyId(NId)] = GetFltAttrDefaultN(attr);
}
return NId;
}
void
CSlmBuilder::AppendTails()
{
printf("\nAppending psuedo tail node for each level..."); fflush(stdout);
for (int lvl = 0; lvl < nlevel; ++lvl) {
int child_size = 0;
if (lvl == nlevel - 1) {
child_size = ((TLeafLevel*)(level[lvl + 1]))->size();
} else {
child_size = ((TNodeLevel*)(level[lvl + 1]))->size();
}
TNodeLevel& v = *(TNodeLevel*)(level[lvl]);
v.push_back(TNode(0x00FFFFFF, child_size, 1));
}
//also make a psuedo tail node for the leaf level
((TLeafLevel*)(level[nlevel]))->push_back(TLeaf(0, 1));
printf("\n"); fflush(stdout);
}
TNode *UniExprNode::translate( Codegen *g ){
int n=0;
TNode *l=expr->translate( g );
if( sem_type==Type::int_type ){
switch( op ){
case '+':return l;
case '-':n=IR_NEG;break;
case ABS:return call( "__bbAbs",l );
case SGN:return call( "__bbSgn",l );
}
}else{
switch( op ){
case '+':return l;
case '-':n=IR_FNEG;break;
case ABS:return fcall( "__bbFAbs",l );
case SGN:return fcall( "__bbFSgn",l );
}
}
return d_new TNode( n,l,0 );
}
// n=1 for unigram, n=2 for bigram;
// level[0] is for psuedo 0 gram, ...
void
CSlmBuilder::Create(int n)
{
assert(n != 0);
nlevel = n;
level = new void * [n + 1];
for (int i = 0; i < n; ++i) {
level[i] = new std::vector<TNode>;
if (i) ((TNodeLevel*)level[i])->reserve(1024);
}
//Add leaf level
level[n] = new std::vector<TLeaf>;
((TLeafLevel*)level[n])->reserve(1024);
//Add psuedo root node
((TNodeLevel*)level[0])->push_back(TNode(0, 0, 0));
//Initialize the nr[n+1][SLM_MAX_R] 2-D array
nr = new FREQ_TYPE[n + 1][SLM_MAX_R];
for (int lvl = 0; lvl < n + 1; ++lvl)
for (int r = 0; r < SLM_MAX_R; ++r)
nr[lvl][r] = 0;
}
TNode TNode::ConstructProgramTNode(string name) {
return TNode(TNode::PROGRAM, ":" + EnumToString(TNode::PROGRAM));
}
TNode TNode::ConstructStmtListTNode(string name) {
return TNode(TNode::STMT_LIST, name +":" + EnumToString(TNode::STMT_LIST));
}
int TNGraph::AddNodeUnchecked(int NId) {
if (IsNode(NId)) { return NId;}
MxNId = TMath::Mx(NId+1, MxNId());
NodeH.AddDat(NId, TNode(NId));
return NId;
}
TNode *IntConstNode::translate( Codegen *g ){
return d_new TNode( IR_CONST,0,0,value );
}
TNode *FloatConstNode::translate( Codegen *g ){
return d_new TNode( IR_CONST,0,0,*(int*)&value );
}
