main.c

F:反汇编源码代码学习disasm.ZIP

	{
	    if (p->c_ref>q->c_ref) return 1;
	    else if ((p->c_ref==q->c_ref)&&(p->c_pos > q->c_pos)) return 1; 
	    return 0;
    }
	if (p->c_ref > q->c_ref) return 1;
	return 0;
}

int LE(PKEY p, PKEY q)
{
    if (p->class>0)
	{
        if (p->c_ref < q->c_ref) return 1;
	    else if ((p->c_ref==q->c_ref)&&(p->c_pos <= q->c_pos)) return 1; 
	    return 0;
    }
	if (p->c_ref <= q->c_ref) return 1;
	return 0;
}

int LT(PKEY p, PKEY q)
{
    if (p->class>0)
	{
	    if (p->c_ref < q->c_ref) return 1;
	    else if ((p->c_ref==q->c_ref)&&(p->c_pos < q->c_pos)) return 1; 
	    return 0;
    }
	if (p->c_ref < q->c_ref) return 1;
	return 0;
}

// modified november 2,1997 sangcho i really hope this will work.
// modified november 5,1997 sangcho............same..............

PKEY searchBtree1(PKEY k)
{
Bnode *t;
int i; 
	if (k->class>0)
	     t=Btree_search(k, head, &btn);
	else t=Btree_search(k, headx, &btnx);
	if (t==NULL) return NULL;
	for (i=0;i<t->n;i++)
	if (EQ(k, &(t->key[i]))) return &(t->key[i]);
	return NULL;
}

PKEY searchBtree21(Bnode *t, PKEY k)
{
int i, c, r;
PKEY   p;
	p = NULL;
    if (t != NULL)
	{
	    for (i = 0; i < t->n; i++)
	    {
		    if (p = searchBtree21(t->ptr[i], k)) return p;
			c=t->key[i].class; r=t->key[i].c_ref;
			if (((c==3)||(c==4)||(c==11)||(c==165)||(c==166))
			    &&(r==k->c_ref))
		    return &(t->key[i]);
	    }
		if (p = searchBtree21(t->ptr[i], k)) return p;
	}
	return p;
}

PKEY searchBtree2(PKEY k)
{
    if (k->class>0)
	     return searchBtree21(head, k);
    else return searchBtree21(headx,k);
}


PKEY searchBtree31(Bnode *t, PKEY k)
{
int i, c, r;
PKEY   p;
	p = NULL;
    if (t != NULL)
	{
	    for (i = 0; i < t->n; i++)
	    {
		    if (p = searchBtree31(t->ptr[i], k)) return p;
			c=t->key[i].class; r=t->key[i].c_ref;
			if (((c < 5)||(c==11)||(c==165)||(c==166))
			    &&(r==k->c_ref))
		    return &(t->key[i]);
	    }
		if (p = searchBtree31(t->ptr[i], k)) return p;
	}
	return p;
}

PKEY searchBtree3(PKEY k)
{
    return searchBtree31(head, k);
}

int  referCount(int ref)
{
_key_  k;
Bnode *t;
int i;
    k.class=0; k.c_ref=ref; k.c_pos=0;
	k.c_ref |= 0x80000000;
	t=Btree_search(&k, headx, &btnx);
	if (t==NULL)return 0;
	for (i=0;i<t->n;i++)
	if (EQ(&k, &(t->key[i]))) break;
	if (t==NULL)return 0;
	return t->key[i].class + t->key[i].c_pos;
}


int  addCount(int ref, int class)
{
_key_  k;
Bnode *t;
int i;
    k.class=0; k.c_ref=ref; k.c_pos=0;
	k.c_ref |= 0x80000000;
	t=Btree_search(&k, headx, &btnx);
	if (t==NULL) t=Btree_insert(&k, headx, &btnx);
	if (t==NULL)return 0;
	for (i=0;i<t->n;i++)
	if (EQ(&k, &(t->key[i]))) break;
	if (t==NULL)return 0;
	switch(class)
	{
	    case 1: case 2:
			t->key[i].c_pos += 1;
			break;
		case 3: case 4: case 7: case 165: case 166:
		    t->key[i].c_pos += 256;
			break;
		case 11: case 15:
		    t->key[i].class += 1;
			break;
		default:
	}
	return t->key[i].class + t->key[i].c_pos;
}

int  subtractCount(int ref, int class)
{
int    c;
_key_  k;
Bnode *t;
int i; 
    k.class=0; k.c_ref=ref; k.c_pos=0;
	k.c_ref |= 0x80000000;
	t=Btree_search(&k, headx, &btnx);
	if (t==NULL)return 0;
	for (i=0;i<t->n;i++)
	if (EQ(&k, &(t->key[i]))) break;
	if (t==NULL)return 0;
	switch(class)
	{
	    case 1: case 2:
			t->key[i].c_pos -= 1;
			break;
		case 3: case 4: case 5: case 165: case 166:
		    t->key[i].c_pos -= 256;
			break;
		case 11: case 13:
		    t->key[i].class -= 1;
			break;
		default:
	}
	if (t->key[i].c_pos < 0) t->key[i].c_pos = 0;
	if (t->key[i].class < 0) t->key[i].class = 0;
	c=t->key[i].class + t->key[i].c_pos;
	if (c==0)
	{
	    Btree_delete(&k, headx, &btnx);
	    return 0;
	}
	return c;
}

int  MyBtreeInsert(PKEY k)
{
Bnode *b;
    if (k->class>0)
	{
		if (searchBtree1(k)) return 0;	// already exist
		else Btree_insert(k, head, &btn);
		return addCount(k->c_ref, k->class);
    }
	else if (Btree_insert(k, headx, &btnx)) return 1;
	else return 0;
}

int  MyBtreeInsertEx(PKEY k)
{
_key_     key;
	Btree_insert(k, head, &btn);
	key.class=256; key.c_ref=k->c_ref; key.c_pos=256*256;
	key.c_ref |= 0x80000000;
	Btree_insert(&key, headx, &btnx);
	return 1;
}

// i can refuse to be deleted provied that reference count is big enough.
int  MyBtreeDelete(PKEY k)
{
Bnode *b;
	if (k->class>0)
	{
	     if (searchBtree1(k))  
		 {
		     Btree_delete(k, head, &btn);
			 return subtractCount(k->c_ref,k->class);
		     //return 0;
		 }
		 else return 0;
	}
    else Btree_delete(k, headx, &btnx);
	return 0;
}

Bnode *init_Btree(int *num)
{
Bnode *head;
    head = (Bnode*)calloc(sizeof(Bnode),1);
    head->ptr[0] = NULL;
    head->n = 0;
    *num = 0;
	return head;
}

int in_Bnode(PKEY pkey, Bnode *t)
{
int i;
    for (i = 0; i < t->n; i++)
	if (EQ(pkey, &(t->key[i]))) return i;
    return -1;
}

Bnode *Btree_search(PKEY pkey, Bnode *base, int *num)
{
Bnode *t;
int i;
    t = base->ptr[0];
    while (t != NULL && in_Bnode(pkey, t) == -1)
	{
	for (i = 0; i < t->n && GE(pkey, &(t->key[i])); i++);
	t = t->ptr[i];
	}
    return t;
}

void insert_key(Bnode *t, PKEY pkey, Bnode *left, Bnode *right)
{
int i;
    i = t->n;
    while (LT(pkey, &(t->key[i-1])) && i > 0)
	{
	t->key[i] = t->key[i-1];
	t->ptr[i+1] = t->ptr[i];
	i--;
	}
    t->n++;
    t->key[i] = *pkey;
    t->ptr[i] = left;
    t->ptr[i+1] = right;
}

Bnode *split(PKEY pkey, Bnode *pivot, Bnode *base)
{
Bnode *left, *right;
Bnode *child;
int i;
    if ((right = (Bnode*)calloc(sizeof(Bnode),1)) == NULL) return NULL;
    if (pivot == base)
	{
	child = pivot->ptr[0];
	if ((left = (Bnode*)calloc(sizeof(Bnode),1)) == NULL) return NULL;
	for (i = 0; i < M; i++)   /* left node create */
	    {
	    left->key[i] = child->key[i];
	    left->ptr[i] = child->ptr[i];
	    }
	left->ptr[i] = child->ptr[i];
	left->n = M;
	for (i = M+1; i < MM; i++)  /* right node create */
	    {
	    right->key[i-M-1] = child->key[i];
	    right->ptr[i-M-1] = child->ptr[i];
	    }
	right->ptr[i-M-1] = child->ptr[i];
	right->n = M;

	child->n = 0;   /* root node create */
	insert_key(child, &(child->key[M]), left, right);
	}
    else
	{
	for (i = 0; i < pivot->n && GE(pkey, &(pivot->key[i])); i++);
	left = pivot->ptr[i];
	left->n = M;  /* left already created */
	for (i = M+1; i < MM; i++)  /* right node create */
	    {
	    right->key[i-M-1] = left->key[i];
	    right->ptr[i-M-1] = left->ptr[i];
	    }
	right->ptr[i-M-1] = left->ptr[i];
	right->n = M;

	insert_key(pivot, &(left->key[M]), left, right);  /* pivot update */
	child = pivot;
	}
    return child;
}

Bnode *Btree_insert(PKEY pkey, Bnode *base, int *num)
{
Bnode *t, *parent;
int i;
    parent = base;
    t = base->ptr[0];
    if (t == NULL)
	{
	if ((t = (Bnode*)calloc(sizeof(Bnode),1)) == NULL) return NULL;
	t->n = 0;
	t->ptr[0] = NULL;
	base->ptr[0] = t;
	}
    while (t != NULL)
	{
	if (in_Bnode(pkey, t) >= 0) return NULL;  /* equal key */
	if (t->n == MM)
	    {
	    t = split(pkey, parent, base);
	    if (t == NULL) return NULL;
	    }
	parent = t;
	for (i = 0; i < t->n && GE(pkey, &(t->key[i])); i++);
	t = t->ptr[i];
	}
    insert_key(parent, pkey, NULL, NULL);
    (*num)++;
    return parent;
}

void delete_key(Bnode *t, int index)
{
int i;
    for (i = index+1; i < t->n; i++)
	{
	t->key[i-1] = t->key[i];
	t->ptr[i-1] = t->ptr[i];
	}
    t->ptr[i-1] = t->ptr[i];
    t->n--;
}

int borrow_key(Bnode *p, int index)
{
int from, to;
Bnode *p1, *p2;
    if (index == p->n)
	{  /* right most */
	from = index-1;
	to = index;
	}
    else
	{
	from = index+1;
	to = index;
	}
    p1 = p->ptr[from];
    p2 = p->ptr[to];
    if (p1->n <= M) return 0;
    if (from > to)
	{
	insert_key(p2, &(p->key[to]), p2->ptr[p2->n], p1->ptr[0]);
	p->key[to] = p1->key[0];
	delete_key(p1, 0);
	}
    else
	{
	insert_key(p2, &(p->key[from]), p1->ptr[p1->n], p2->ptr[0]);
	p->key[from] = p1->key[p1->n - 1];
	delete_key(p1, p1->n - 1);
	}
    return 1;
}

Bnode *bind_node(Bnode *p, int index, Bnode *base)
{
Bnode *left, *right;
int i;
    if (index == p->n) index--;
    left = p->ptr[index];
    right = p->ptr[index+1];
    left->key[left->n++] = p->key[index];
    for (i = 0; i < right->n; i++)
	{
	left->key[left->n] = right->key[i];
	left->ptr[left->n++] = right->ptr[i];
	}
    left->ptr[left->n] = right->ptr[i];
    delete_key(p, index);
    p->ptr[index] = left;
    free(right);
    if (p->n == 0)
	{
	free(p);
	base->ptr[0] = left;
	}
    return left;
}

void make_swap(Bnode *p, Bnode *t, PKEY pkey, int index)
{
Bnode *center, *pcenter;
    pcenter = t;
    center = pcenter->ptr[index+1];
    while (center->ptr[0] != NULL)
	{
	pcenter = center;
	center = center->ptr[0];
	}
    t->key[index] = center->key[0];
    *pkey = center->key[0];
}

Bnode *Btree_delete(PKEY pkey, Bnode *base, int *num)
{
Bnode *t, *parent;
int pi = 0;
int ti;
    parent = base;
    t = base->ptr[0];
    while (t != NULL)
	{
	if (t->n <= M && parent != base)
	    if (!borrow_key(parent, pi)) t = bind_node(parent, pi, base);
	if ((ti = in_Bnode(pkey, t)) >= 0)
	    {
	    if (t->ptr[0] == NULL) break;  /* if external break */
	    else make_swap(parent, t, pkey, ti);
	    }
	parent = t;
	for (pi = 0; pi < t->n && GE(pkey, &(t->key[pi])); pi++);
	t = t->ptr[pi];
	}
    if (t == NULL) return NULL;  /* can't find */
    if (t->n <= M && parent != base)  /* external but less M */
	if (!borrow_key(parent, pi)) t = bind_node(parent, pi, base);
    delete_key(t, in_Bnode(pkey, t));
    (*num)--;
    return t;
}

void _deleteall(Bnode *t)
{
int i;
    if (t != NULL)
	{
	for (i = 0; i < t->n+1; i++)
	    _deleteall(t->ptr[i]);
	free(t);
	}
}

Bnode *Btree_deleteall(Bnode *base, int *num)
{
    _deleteall(base->ptr[0]);
    base->ptr[0] = NULL;
    *num = 0;
    return base;
}

void _list(Bnode *t)
{
int i, nn;
static int x = 0;
    if (t != NULL)
	{
	x += 2;
	nn = 1;
	for (i = 2; i < x; i++) printf("   ");
	for (i = 0; i < t->n; i++)
	{
	    printf("%3d:%08X<%08X,", t->key[i].class, t->key[i].c_ref, t->key[i].c_pos);
		if(nn++ % 4==0)printf("\n");
	}
	printf("\n");
	for (i = 0; i < t->n+1; i++) _list(t->ptr[i]);
	x -= 2;
	}
}

void Btree_list(Bnode *base)
{
    _list(base->ptr[0]);
}

void _sort(Bnode *t)
{
int i, j;
static int x=0;
    if (t != NULL)
	{
	    for (i = 0; i < t->n; i++)
	    {
	        _sort(t->ptr[i]);
		    //if(t->key[i].class>2||t->key[i].class==0)
		    {
		        printf("%5d:%08X<%08X,", t->key[i].class, t->key[i].c_ref, t->key[i].c_pos);
	            if(x++ % 4==0)printf("\n");
		    }
	    }
	_sort(t->ptr[i]);
	}
}

void Btree_sort(Bnode *base)
{
    _sort(base->ptr[0]);
}

// *********************