void HashGraph::RefreshVertices(unsigned minCount)
{
#pragma omp parallel for
for (int64 i = 0; i < (int64)table_size; ++i)
{
HashNode *node = table[i];
HashNode *prev = NULL;
while (node != NULL)
{
if (node->IsDead() || node->Count() < minCount)
{
#pragma omp atomic
--num_nodes;
if (prev == NULL)
{
table[i] = node->next;
FreeNode(node, omp_get_thread_num());
node = table[i];
}
else
{
prev->next = node->next;
FreeNode(node, omp_get_thread_num());
node = prev->next;
}
}
else
{
node->ClearStatus();
prev = node;
node = prev->next;
}
}
}
}
void resize() {
int new_length = 4;
while(new_length < elems_) {
new_length <<= 1;
}
HashNode** new_list = new HashNode*[new_length];
memset(new_list, 0, sizeof(new_list[0]) * new_length);
int count = 0;
for(int i=0; i<length_; ++i) {
HashNode* now = list_[i];
while(now != NULL) {
HashNode* next = now->next_hash;
Slice key = now->key();
int hash = now->hash;
HashNode** ptr = &new_list[hash & (new_length - 1)];
now->next_hash = *ptr;
*ptr = now;
now = next;
count++;
}
}
assert(elems_ == count);
delete[] list_;
list_ = new_list;
length_ = new_length;
}
void HashGraph::ClearGraph()
{
for (unsigned i = 0; i < table_size; ++i)
{
for (HashNode *node = table[i]; node != NULL; node = node->next)
{
node->Clear();
node->SetCount(1);
}
}
num_edges = 0;
}
void HashGraph::AddAllEdges()
{
num_edges = 0;
#pragma omp parallel for
for (int64 i = 0; i < (int64)table_size; ++i)
{
for (HashNode *node = table[i]; node; node = node->next)
{
node->SetInEdges(15);
node->SetOutEdges(15);
}
}
}
void GrCCPathCache::evict(const GrCCPathCache::Key& key, GrCCPathCacheEntry* entry) {
if (!entry) {
HashNode* node = fHashTable.find(key);
SkASSERT(node);
entry = node->entry();
}
SkASSERT(*entry->fCacheKey == key);
SkASSERT(!entry->hasBeenEvicted());
entry->fCacheKey->markShouldUnregisterFromPath(); // Unregister the path listener.
entry->releaseCachedAtlas(this);
fLRU.remove(entry);
fHashTable.remove(key);
}
double HashGraph::AverageCoverage()
{
long long sum = 0;
uint64 valid = 0;
for (int64 i = 0; i < table_size; ++i)
{
for (HashNode *node = table[i]; node; node = node->next)
{
sum += node->Count();
++valid;
}
}
return 1.0 * sum / valid;
}
int CTECHashTable<Type>:: findPosition(HashNode<Type> currentNode){
int position = 0;
position = currentNode.getKey()%capacity;
return position;
}
double HashGraph::MedianCoverage()
{
vector<int> v;
v.reserve(num_nodes);
for (int64 i = 0; i < table_size; ++i)
{
for (HashNode *node = table[i]; node; node = node->next)
{
v.push_back(node->Count());
}
}
nth_element(v.begin(), v.begin() + v.size()/2, v.end());
return *(v.begin() + v.size()/2);
}
HashNode* insert(const Slice& key, int& hit_id, int& rep_id) {
HashNode* e = reinterpret_cast<HashNode*>(malloc(sizeof(HashNode) - 1 + key.size()));
e->key_length = key.size();
e->hash = hash_slice(key);
memcpy(e->key_data, key.data(), key.size());
lru_append(e);
HashNode* old = table_.insert(e);
if(old != NULL) {
//命中缓存
e->cache_id = old->cache_id;
hit_id = e->cache_id;
rep_id = -1;
lru_remove(old);
lru_release(old);
//update hit ratio
hit_cnt++;
}
else {
//没有命中缓存
hit_id = -1;
//如果当前的缓存数量超过capacity，把lru_后面的那个缓存单元淘汰掉
if(table_.size() > capacity_) {
HashNode* cursor = lru_.next;
lru_remove(cursor);
table_.remove(cursor->key(), cursor->hash);
e->cache_id = cursor->cache_id;
lru_release(cursor);
}
else {
e->cache_id = last_id++; //TODO 会无限增长?
}
rep_id = e->cache_id;
//update hit ratio
set_cnt++;
}
return e;
}
long HashTable<Type> :: findPosition(Type data)
{
long insertedPosition;
unsigned long address =(long)&data;
insertedPosition = address % capacity;
HashNode<Type>* indexPointer = front;
for (long index = 0; index < insertedPosition; index++)
{
indexPointer = indexPointer->getNode();
}
if (indexPointer->hasStuffed())
{
insertedPosition = handleCollision(data, insertedPosition);
}
return insertedPosition;
}
int HashTable<Type> :: findPosition(HashNode<Type> currentNode)
{
//We are going "hash" the key of the HashNode to find its value.
int position = 0;
position = currentNode.getKey() % capacity;
return position;
}
int CTECHashTable<Type>::findTablePosition(HashNode<Type> currentNode)
{
//We are going to "hash" the key of the hashnode to find its storage spot.
int position = 0;
position = currentNode.getKey() % tableCapacity;
return position;
}
void HashGraph::RefreshEdges()
{
num_edges = 0;
#pragma omp parallel for
for (int64 i = 0; i < (int64)table_size; ++i)
{
for (HashNode *node = table[i]; node; node = node->next)
{
KmerNodeAdapter curr(node);
for (int strand = 0; strand < 2; ++strand)
{
Kmer kmer;
curr.GetKmer(kmer);
unsigned edges = curr.OutEdges();
for (int x = 0; x < 4; ++x)
{
if (edges & (1 << x))
{
Kmer next = kmer;
next.AddRight(x);
if (GetNode(next) == NULL)
curr.RemoveOutEdge(x);
else
{
#pragma omp atomic
++num_edges;
}
}
}
curr.ReverseComplement();
}
if (node->kmer.IsPalindrome())
{
unsigned edges = node->InEdges() | node->OutEdges();
node->SetInEdges(edges);
node->SetOutEdges(edges);
}
}
}
num_edges >>= 1;
}
bool CTECHashTable<Type>:: contains(HashNode<Type> currentNode){
bool isInTable = false;
int possibleLocation = findPosition(currentNode);
while(internalStorage[possibleLocation] != nullptr && !isInTable){
if(internalStorage[possibleLocation] == currentNode.getValue()){
isInTable = true;
}
possibleLocation = (possibleLocation + 1) % capacity;
}
return isInTable;
}
bool CTECHashTable<Type>:: remove(HashNode<Type> currentNode){
bool hasBeenRemoved = false;
int possibleLocation = findPosition(currentNode);
if(contains(currentNode)){
while(internalStorage[possibleLocation] != nullptr && !hasBeenRemoved){
if(internalStorage[possibleLocation] == currentNode.getValue()){
hasBeenRemoved = true;
internalStorage[possibleLocation] = nullptr;
}
possibleLocation = (possibleLocation + 1) % capacity;
}
}
return hasBeenRemoved;
}
bool CTECHashTable<Type>::contains(HashNode<Type> currentNode)
{
bool isInTable = false;
int index = findPosition(currentNode);
while (internalStorage[index] != nullptr&& !isInTable)
{
if(internalStorage[index]->getValue() == currentNode.getValue())
{
isInTable = true;
}
else
{
index = (index + 1) % capacity;
}
}
return isInTable;
}
bool HashTable<Type> :: contains(HashNode<Type> currentNode)
{
bool wasRemoved = false;
int index = findPosition(currentNode);
while(internalStorage[index] != nullptr && !wasRemoved)
{
if(internalStorage[index]->getValue() == currentNode.getValue())
{
wasRemoved = true;
internalStorage[index] = nullptr;
size--;
}
else
{
index = (index + 1) % capacity;
}
}
return wasRemoved;
}
int64 HashGraph::Assemble(vector<Contig> &contigs)
{
contigs.resize(0);
int tangle = 0;
omp_lock_t lockContigs;
omp_init_lock(&lockContigs);
#pragma omp parallel for
for (int64 i = 0; i < (int64)table_size; ++i)
{
for (HashNode *node = table[i]; node != NULL; node = node->next)
{
if (!node->Lock(omp_get_thread_num()))
continue;
Contig contig;
contig.SetContent(node->kmer, kmerLength);
contig.sum_coverage = node->Count();
contig.is_tangle = false;
if (!node->kmer.IsPalindrome())
{
for (int strand = 0; strand < 2; ++strand)
{
KmerNodeAdapter adp = GetNodeAdapter(contig.GetEndKmer());
KmerNodeAdapter next(NULL);
while (true)
{
if (!GetNextNodeAdapter(adp, next))
break;
if (next.GetLockID() == omp_get_thread_num() && IsLoop(contig, next))
break;
if (!next.LockPreempt(omp_get_thread_num()))
goto FAIL;
contig.AddNucleotide(BitOperation::bitToIndex[adp.OutEdges()]);
adp = next;
contig.sum_coverage += next.Count();
}
if (adp.OutDegree() == 0)
contig.is_tangle = true;
contig.ReverseComplement();
}
}
if (contig.is_tangle)
{
#pragma omp atomic
++tangle;
}
omp_set_lock(&lockContigs);
contigs.push_back(contig);
omp_unset_lock(&lockContigs);
FAIL:
;
}
}
omp_destroy_lock(&lockContigs);
ClearStatus();
LogMessage("tangle %d total %d\n", tangle, contigs.size());
return contigs.size();
}
int HashTable<Type> :: findTablePosition(HashNode<Type> currentNode)
{
int position = 0;
position = currentNode.getKey() % tableCapacity;
}
void parser_dump(mrb_state *mrb, mrb_ast_node *tree, int offset)
{
#ifdef ENABLE_STDIO
if (!tree) return;
again:
dump_prefix(offset);
node_type n = tree->getType();
mrb_ast_node *orig = tree;
if(dynamic_cast<UpdatedNode *>(tree)==0)
tree = tree->right();
switch (n) {
case NODE_BEGIN: parser_dump(mrb,(BeginNode *)orig,offset); break;
case NODE_RESCUE: parser_dump(mrb,(RescueNode *)orig,offset); break;
case NODE_ENSURE: parser_dump(mrb,(EnsureNode *)orig,offset); break;
case NODE_LAMBDA:
printf("NODE_LAMBDA:\n");
goto block;
case NODE_BLOCK:
printf("NODE_BLOCK:\n");
block:
parser_dump(mrb,(LambdaCommonNode *)orig,offset);
break;
case NODE_IF:
{
IfNode *in = (IfNode *)orig;
printf("NODE_IF:\n");
dump_prefix(offset+1);
printf("cond:\n");
parser_dump(mrb, in->cond(), offset+2); //tree->left()
dump_prefix(offset+1);
printf("then:\n");
parser_dump(mrb, in->true_body(), offset+2); //tree->right()->left()
if (in->false_body()) {
dump_prefix(offset+1);
printf("else:\n");
parser_dump(mrb, in->false_body() , offset+2); //tree->right()->right()->left()
}
}
break;
case NODE_AND:
{
AndNode *an = (AndNode *)orig;
printf("NODE_AND:\n");
parser_dump(mrb, an->lhs(), offset+1);
parser_dump(mrb, an->rhs(), offset+1);
}
break;
case NODE_OR:
{
OrNode *an = (OrNode *)orig;
printf("NODE_OR:\n");
parser_dump(mrb, an->lhs(), offset+1);
parser_dump(mrb, an->rhs(), offset+1);
}
break;
case NODE_CASE: {
CaseNode *cn = (CaseNode *)orig;
printf("NODE_CASE:\n");
if (cn->switched_on()) {
parser_dump(mrb, cn->switched_on(), offset+1);
}
tree = cn->cases();
while (tree) {
dump_prefix(offset+1);
printf("case:\n");
dump_recur(mrb, tree->left()->left(), offset+2);
dump_prefix(offset+1);
printf("body:\n");
parser_dump(mrb, tree->left()->right(), offset+2);
tree = tree->right();
}
}
break;
case NODE_WHILE:
{
WhileNode *n = (WhileNode *)orig;
printf("NODE_WHILE:\n");
dump_prefix(offset+1);
printf("cond:\n");
parser_dump(mrb, n->lhs(), offset+2);
dump_prefix(offset+1);
printf("body:\n");
parser_dump(mrb, n->rhs(), offset+2);
}
break;
case NODE_UNTIL:
{
UntilNode *n = (UntilNode *)orig;
printf("NODE_UNTIL:\n");
dump_prefix(offset+1);
printf("cond:\n");
parser_dump(mrb, n->lhs(), offset+2);
dump_prefix(offset+1);
printf("body:\n");
parser_dump(mrb, n->rhs(), offset+2);
}
break;
case NODE_FOR:
printf("NODE_FOR:\n");
dump_prefix(offset+1);
parser_dump(mrb,(ForNode *)orig,offset);
break;
case NODE_SCOPE:
printf("NODE_SCOPE:\n");
{
ScopeNode *ns = (ScopeNode *)orig;
const tLocals &n2(ns->locals());
if ( !n2.empty() ) {
dump_prefix(offset+1);
printf("local variables:\n");
dump_prefix(offset+2);
for(auto iter=n2.begin(); iter!=n2.end(); ++iter) {
if ( (iter+1) != n2.end() )
printf(", ");
printf("%s", mrb_sym2name(mrb, *iter));
}
printf("\n");
}
tree = ns->body();
}
offset++;
goto again;
case NODE_FCALL:
case NODE_CALL:
{
CallCommonNode *cn = (CallCommonNode *)orig;
printf("NODE_CALL:\n");
parser_dump(mrb, cn->m_receiver, offset+1);
dump_prefix(offset+1);
printf("method='%s' (%d)\n",
mrb_sym2name(mrb, cn->m_method),
cn->m_method);
CommandArgs *ca = cn->m_cmd_args;
if (ca) {
dump_prefix(offset+1);
printf("args:\n");
dump_recur(mrb, ca->m_args, offset+2);
if (ca->m_blk) {
dump_prefix(offset+1);
printf("block:\n");
parser_dump(mrb, ca->m_blk, offset+2);
}
}
}
break;
case NODE_DOT2:
{
printf("NODE_DOT2:\n");
Dot2Node *nd = (Dot2Node *)orig;
parser_dump(mrb, nd->lhs(), offset+1);
parser_dump(mrb, nd->rhs(), offset+1);
}
break;
case NODE_DOT3:
{
printf("NODE_DOT3:\n");
Dot3Node *nd = (Dot3Node *)orig;
parser_dump(mrb, nd->lhs(), offset+1);
parser_dump(mrb, nd->rhs(), offset+1);
}
break;
case NODE_COLON2:
{
Colon2Node *cn = (Colon2Node *)orig;
printf("NODE_COLON2:\n");
parser_dump(mrb, cn->m_val, offset+1);
dump_prefix(offset+1);
printf("::%s\n", mrb_sym2name(mrb, cn->m_sym));
}
break;
case NODE_COLON3:{
printf("NODE_COLON3:\n");
dump_prefix(offset+1);
Colon3Node *n = (Colon3Node *)orig;
printf("::%s\n", mrb_sym2name(mrb, n->sym()));
}
break;
case NODE_ARRAY:
printf("NODE_ARRAY:\n");
dump_recur(mrb, ((ArrayNode *)orig)->child(), offset+1);
break;
case NODE_HASH:
{
HashNode *nd = (HashNode *)orig;
printf("NODE_HASH:\n");
tree = nd->child();
while (tree) {
dump_prefix(offset+1);
printf("key:\n");
parser_dump(mrb, tree->left()->left(), offset+2);
dump_prefix(offset+1);
printf("value:\n");
parser_dump(mrb, tree->left()->right(), offset+2);
tree = tree->right();
}
}
break;
case NODE_SPLAT:
printf("NODE_SPLAT:\n");
parser_dump(mrb, ((SplatNode *)orig)->child(), offset+1);
break;
case NODE_ASGN:
{
AsgnNode *an = (AsgnNode *)orig;
printf("NODE_ASGN:\n");
dump_prefix(offset+1);
printf("lhs:\n");
parser_dump(mrb, an->lhs(), offset+2);
dump_prefix(offset+1);
printf("rhs:\n");
parser_dump(mrb, an->rhs(), offset+2);
}
break;
case NODE_MASGN:
{
printf("NODE_MASGN:\n");
dump_prefix(offset+1);
printf("mlhs:\n");
MAsgnNode *mn = (MAsgnNode *)orig;
mrb_ast_node *n2 = mn->lhs();
if (n2->left()) {
dump_prefix(offset+2);
printf("pre:\n");
dump_recur(mrb, n2->left(), offset+3);
}
n2 = n2->right();
if (n2) {
if (n2->left()) {
dump_prefix(offset+2);
printf("rest:\n");
if (n2->left() == (mrb_ast_node*)-1) {
dump_prefix(offset+2);
printf("(empty)\n");
}
else {
parser_dump(mrb, n2->left(), offset+3);
}
}
n2 = n2->right();
if (n2) {
if (n2->left()) {
dump_prefix(offset+2);
printf("post:\n");
dump_recur(mrb, n2->left(), offset+3);
}
}
}
dump_prefix(offset+1);
printf("rhs:\n");
parser_dump(mrb, mn->rhs(), offset+2);
}
break;
case NODE_OP_ASGN: {
OpAsgnNode *opasgn = static_cast<OpAsgnNode *>(tree);
printf("NODE_OP_ASGN:\n");
dump_prefix(offset+1);
printf("lhs:\n");
parser_dump(mrb, opasgn->lhs(), offset+2);
dump_prefix(offset+1);
printf("op='%s' (%d)\n", mrb_sym2name(mrb, opasgn->op_sym), opasgn->op_sym);
parser_dump(mrb, opasgn->rhs(), offset+1);
break;
}
case NODE_SUPER:
{
printf("NODE_SUPER:\n");
SuperNode *x=(SuperNode *)orig;
if (x->hasParams()) {
dump_prefix(offset+1);
printf("args:\n");
dump_recur(mrb, x->args(), offset+2);
if (x->block()) {
dump_prefix(offset+1);
printf("block:\n");
parser_dump(mrb, x->block(), offset+2);
}
}
}
break;
case NODE_ZSUPER:
printf("NODE_ZSUPER\n");
break;
case NODE_RETURN:
printf("NODE_RETURN:\n");
parser_dump(mrb, ((ReturnNode *)orig)->child(), offset+1);
break;
case NODE_YIELD:
printf("NODE_YIELD:\n");
dump_recur(mrb, ((YieldNode *)orig)->child(), offset+1);
break;
case NODE_BREAK:
printf("NODE_BREAK:\n");
parser_dump(mrb, ((BreakNode *)orig)->child(), offset+1);
//parser_dump(mrb, tree, offset+1);
break;
case NODE_NEXT:
printf("NODE_NEXT:\n");
parser_dump(mrb, ((NextNode *)orig)->child(), offset+1);
break;
case NODE_REDO:
printf("NODE_REDO\n");
break;
case NODE_RETRY:
printf("NODE_RETRY\n");
break;
case NODE_LVAR:
{
LVarNode * lvar = (LVarNode *)orig;
printf("NODE_LVAR %s\n", mrb_sym2name(mrb, lvar->sym()));
}
break;
case NODE_GVAR:
{
GVarNode * gvar = (GVarNode *)orig;
printf("NODE_GVAR %s\n", mrb_sym2name(mrb, gvar->sym()));
}
break;
case NODE_IVAR:
{
IVarNode * ivar = (IVarNode *)orig;
printf("NODE_IVAR %s\n", mrb_sym2name(mrb, ivar->sym()));
}
break;
case NODE_CVAR:
{
CVarNode * cvar = (CVarNode *)orig;
printf("NODE_CVAR %s\n", mrb_sym2name(mrb, cvar->sym()));
}
break;
case NODE_CONST:
{
ConstNode * cvar = (ConstNode *)orig;
printf("NODE_CONST %s\n", mrb_sym2name(mrb, cvar->sym()));
}
break;
case NODE_MATCH:
printf("NODE_MATCH:\n");
dump_prefix(offset + 1);
printf("lhs:\n");
parser_dump(mrb, tree->left(), offset + 2);
dump_prefix(offset + 1);
printf("rhs:\n");
parser_dump(mrb, tree->right(), offset + 2);
break;
case NODE_BACK_REF:
printf("NODE_BACK_REF: $%c\n", ((BackRefNode *)orig)->m_ref);
break;
case NODE_NTH_REF:
printf("NODE_NTH_REF: $%d\n", ((NthRefNode *)orig)->m_ref);
break;
case NODE_ARG:
{
ArgNode * var = (ArgNode *)orig;
printf("NODE_ARG %s\n", mrb_sym2name(mrb, var->sym()));
}
break;
case NODE_BLOCK_ARG:
{
printf("NODE_BLOCK_ARG:\n");
parser_dump(mrb, ((BlockArgNode *)orig)->child(), offset+1);
}
break;
case NODE_INT:
{
IntLiteralNode *int_lit = (IntLiteralNode *)orig;
printf("NODE_INT %s base %d\n", int_lit->m_val, int_lit->m_base);
}
break;
case NODE_FLOAT:
printf("NODE_FLOAT %s\n", ((FloatLiteralNode *)orig)->m_val);
break;
case NODE_NEGATE:
printf("NODE_NEGATE\n");
parser_dump(mrb, ((NegateNode *)tree)->child(), offset+1);
break;
case NODE_STR:
{
StrNode *sn=(StrNode *)orig;
printf("NODE_STR \"%s\" len %zu\n", sn->m_str, sn->m_length);
}
break;
case NODE_DSTR:
{
DstrNode *dn = (DstrNode *)orig;
printf("NODE_DSTR\n");
dump_recur(mrb, dn->child(), offset+1);
}
break;
case NODE_XSTR:
printf("NODE_XSTR \"%s\" len %d\n", (char*)tree->left(), (int)(intptr_t)tree->right());
break;
case NODE_DXSTR: {
DxstrNode *dn = (DxstrNode *)orig;
printf("NODE_DXSTR\n");
dump_recur(mrb, dn->child(), offset+1);
}
break;
case NODE_REGX:
printf("NODE_REGX /%s/%s\n", (char*)tree->left(), (char*)tree->right());
break;
case NODE_DREGX:
printf("NODE_DREGX\n");
dump_recur(mrb, tree->left(), offset+1);
dump_prefix(offset);
printf("tail: %s\n", (char*)tree->right()->right()->left());
dump_prefix(offset);
printf("opt: %s\n", (char*)tree->right()->right()->right());
break;
case NODE_SYM:
{
SymNode * cvar = (SymNode *)orig;
printf("NODE_SYM :%s\n", mrb_sym2name(mrb, cvar->sym()));
}
break;
case NODE_SELF:
printf("NODE_SELF\n");
break;
case NODE_NIL:
printf("NODE_NIL\n");
break;
case NODE_TRUE:
printf("NODE_TRUE\n");
break;
case NODE_FALSE:
printf("NODE_FALSE\n");
break;
case NODE_ALIAS:
{
AliasNode *an = (AliasNode *)orig;
printf("NODE_ALIAS %s %s:\n",
mrb_sym2name(mrb, an->m_from),
mrb_sym2name(mrb, an->m_to));
}
break;
case NODE_UNDEF:
printf("NODE_UNDEF");
{
UndefNode *und((UndefNode *)tree);
for(mrb_sym v : und->m_syms) {
printf(" %s", mrb_sym2name(mrb, v));
}
}
printf(":\n");
break;
case NODE_CLASS: {
ClassNode *cn = static_cast<ClassNode *>(tree);
printf("NODE_CLASS:\n");
if (cn->receiver()->left() == (mrb_ast_node*)0) {
dump_prefix(offset+1);
printf(":%s\n", mrb_sym2name(mrb, sym(cn->receiver()->right())));
}
else if (cn->receiver()->left() == (mrb_ast_node*)1) {
dump_prefix(offset+1);
printf("::%s\n", mrb_sym2name(mrb, sym(cn->receiver()->right())));
}
else {
parser_dump(mrb, cn->receiver()->left(), offset+1);
dump_prefix(offset+1);
printf("::%s\n", mrb_sym2name(mrb, sym(cn->receiver()->right())));
}
if (cn->super()) {
dump_prefix(offset+1);
printf("super:\n");
parser_dump(mrb, cn->super(), offset+2);
}
dump_prefix(offset+1);
printf("body:\n");
parser_dump(mrb, cn->scope()->body(), offset+2);
break;
}
case NODE_MODULE: {
ModuleNode *cn = static_cast<ModuleNode *>(tree);
printf("NODE_MODULE:\n");
if (cn->receiver()->left() == (mrb_ast_node*)0) {
dump_prefix(offset+1);
printf(":%s\n", mrb_sym2name(mrb, sym(cn->receiver()->right())));
}
else if (cn->receiver()->left() == (mrb_ast_node*)1) {
dump_prefix(offset+1);
printf("::%s\n", mrb_sym2name(mrb, sym(cn->receiver()->right())));
}
else {
parser_dump(mrb, cn->receiver(), offset+1);
dump_prefix(offset+1);
printf("::%s\n", mrb_sym2name(mrb, sym(cn->receiver()->right())));
}
dump_prefix(offset+1);
printf("body:\n");
parser_dump(mrb, cn->scope()->body(), offset+2);
break;
}
case NODE_SCLASS: {
printf("NODE_SCLASS:\n");
SclassNode *scn((SclassNode *)tree);
parser_dump(mrb, scn->scope(), offset+1);
// dump_prefix(offset+1);
// printf("body:\n");
// parser_dump(mrb, scntree->right()->left()->right(), offset+2);
}
break;
case NODE_DEF:
{
DefNode *dn = (DefNode *)orig;
printf("NODE_DEF:\n");
dump_prefix(offset+1);
parser_dump(mrb,dn,offset);
}
break;
case NODE_SDEF:
{
SdefNode *sn = (SdefNode *)orig;
printf("NODE_SDEF:\n");
parser_dump(mrb, sn->receiver(), offset+1);
dump_prefix(offset+1);
printf(":"); // prepend name with ':'
parser_dump(mrb,sn,offset);
}
break;
case NODE_POSTEXE:
printf("NODE_POSTEXE:\n");
parser_dump(mrb, ((PostExeNode *)orig)->child(), offset+1);
break;
case NODE_HEREDOC:{
printf("NODE_HEREDOC:\n");
HeredocNode *hdn((HeredocNode *)tree);
parser_dump(mrb, hdn->contents()->doc->left(), offset+1);
}
break;
default:
printf("node type: %d (0x%x)\n", (int)n, (int)n);
break;
}
#endif
}
