NodeOfTree *add_tree(NodeOfTree *root, TypeOfKey key)
{
if (root == nullptr)
{
root = createNode(key);
}
if (key < root->key)
{
if (root->left == nullptr)
{
root->left = createNode(key);
}
else
{
add_tree(root->left, key);
}
}
if (key > root->key)
{
if (root->right == nullptr)
{
root->right = createNode(key);
}
else
{
add_tree(root->right, key);
}
}
return root;
}
void add_tree(binarytree *t, int x) {
if ((*t) == NULL) {
(*t) = (binarytree)malloc(sizeof(struct treenode));
(*t) -> data = x;
(*t) -> left = NULL;
(*t) -> right = NULL;
} else if (x <= (*t) -> data) {
add_tree(&(*t) -> left, x);
} else {
add_tree(&(*t) -> right, x);
}
}
void add_tree(TREE ** T, int num)
{
if (*T == NULL) {
*T = (TREE *) malloc(sizeof(TREE));
(*T)->num = num;
(*T)->lchild = NULL;
(*T)->rchild = NULL;
} else if ((*T)->num > num)
add_tree(&((*T)->lchild), num);
else
add_tree(&((*T)->rchild), num);
}
t_op *ft_create_tree(t_op **lst)
{
t_op *tree;
t_op *save;
t_op *tmp;
tree = NULL;
tmp = *lst;
save = *lst;
while (save)
{
save = NULL;
while (tmp)
{
if (!save && tmp->stat == 0)
save = tmp;
else if (save && tmp->prior <= save->prior && tmp->stat == 0)
save = tmp;
tmp = tmp->next;
}
if (save)
save->stat = 1;
add_tree(&tree, save);
tmp = *lst;
}
return (tree);
}
struct tnode *add_tree(struct tnode *p, char *w)
{
int cond;
if (p == NULL) {
p = talloc();
p->word = str_dump(w);
p->count = 1;
p->left = p->right = NULL;
} else if ((cond = strcmp(w, p->word)) == 0)
p->count++;
else if (cond < 0)
p->left = add_tree(p->left, w);
else
p->right = add_tree(p->right, w);
return p;
}
void treesort(int A[], int N)
{
int i;
TREE *T = NULL;
for (i = 0; i < N; i++)
add_tree(&T, A[i]);
midwalk(T, A);
}
void add_tree(deque<string> tag, const stu & u, const vector<int> & no, Tree & t){
for (int i = 0; i != no.size(); ++i)
if (!count(t.pid[no[i]].begin(), t.pid[no[i]].end(), u.ID))
t.pid[no[i]].push_back(u.ID);
if (!tag.empty()){
string v = tag.front(); tag.pop_front();
add_tree(tag, u, no, t.next[find_tree(v, t)]);
}
}
int main() {
struct tnode *root;
char word[MAXWORD];
root = NULL;
//'\t' is just for indicate the end
while (get_word(word, MAXWORD) != -1)
if (isalpha(word[0]))
root = add_tree(root, word);
tree_print(root);
return 0;
}
Word *
add_tree(Word * p, char * word_buffer){
// printf("insdfsdf\n");
int cond;
if(p == NULL){
p = (Word * )malloc(sizeof(Word));
p->count = 1;
p->word = (char *)malloc(sizeof(word_buffer) + 1);
strcpy(p->word, word_buffer);
p->left = p->right = NULL;
}
else if ( (cond = strcmp(word_buffer, p->word)) == 0 )
p->count++;
else if ( cond < 0 )
p->left = add_tree(p->left, word_buffer);
else
p->right = add_tree(p->right, word_buffer);
return p;
}
int
main(int argc, char *argv[]){
FILE *f = NULL;
f = fopen(argv[1], "r");
if(!f){
printf("Open file failed!\n");
return 1;
}
char word_buffer[20];
Word *root = NULL;
while(get_word(f, word_buffer)){
// printf("%s\n", word_buffer);
if(strlen(word_buffer))
root = add_tree(root, word_buffer);
}
tree_print(root);
fclose(f);
return 0;
}
void read_uhunt()
{
init_tree();
for (size_t i = 0; i != user.size(); ++i){
ifstream in("uhunt\\ana_" + user[i].ID + ".txt");
if (!in) { cerr << user[i].name << "：打开文件失败!" << endl; continue; }
string line; vector<int> road; road.resize(4);
while (getline(in, line)){
if (line.find("AOAPC") != string::npos)
++road[1], road[2] = -1, road[3] = 0;
else if (line.find("Chapter") != string::npos)
road[2] = get_cpt(line), road[3] = 0;
else if (count(line.begin(), line.end(), '-') == 6 && line.find("Examples") == string::npos && line.find("Exercises") == string::npos && line.find("Extra") == string::npos)
++road[3];
else if (line.find("accept") != string::npos) {
vector<int> pid = get_pid(line);
add_tree(get_tag(road), user[i], pid, root);
}
}
in.close();
printf(" %s：uhunt数据读取完毕\n", user[i].name.c_str());
}
cout << "所有同学数据读取完毕！" << endl;
}
int main()
{
TreeNode *tree = NULL;
TreeNode *node;
guint i;
g_assert (!add_tree (&tree, 1));
g_assert (!add_tree (&tree, 2));
g_assert (!add_tree (&tree, 3));
g_assert ( add_tree (&tree, 1));
g_assert ( add_tree (&tree, 2));
g_assert ( add_tree (&tree, 3));
g_assert (!test_tree (&tree, 0));
g_assert ( test_tree (&tree, 1));
g_assert ( test_tree (&tree, 2));
g_assert ( test_tree (&tree, 3));
g_assert (!test_tree (&tree, 4));
g_assert (!del_tree (&tree, 0));
g_assert ( del_tree (&tree, 2));
g_assert (!del_tree (&tree, 4));
g_assert (!test_tree (&tree, 0));
g_assert ( test_tree (&tree, 1));
g_assert (!test_tree (&tree, 2));
g_assert ( test_tree (&tree, 3));
g_assert (!test_tree (&tree, 4));
g_assert ( add_tree (&tree, 1));
g_assert (!add_tree (&tree, 2));
g_assert ( add_tree (&tree, 3));
g_assert ( del_tree (&tree, 1));
g_assert ( del_tree (&tree, 2));
g_assert ( del_tree (&tree, 3));
g_assert (tree == NULL);
GSK_RBTREE_FIRST (TREE(&tree), node);
g_assert (node == NULL);
GSK_RBTREE_LAST (TREE(&tree), node);
g_assert (node == NULL);
/* Construct tree with odd numbers 1..999 inclusive */
for (i = 1; i <= 999; i += 2)
g_assert (!add_tree (&tree, i));
GSK_RBTREE_FIRST (TREE(&tree), node);
g_assert (node != NULL);
g_assert (node->value == 1);
GSK_RBTREE_LAST (TREE(&tree), node);
g_assert (node != NULL);
g_assert (node->value == 999);
for (i = 1; i <= 999; i += 2)
{
g_assert (test_tree (&tree, i));
g_assert (!test_tree (&tree, i+1));
}
for (i = 0; i <= 999; i++)
{
GSK_RBTREE_SUPREMUM_COMPARATOR (TREE(&tree), i, COMPARE_INT_WITH_TREE_NODE, node);
g_assert (node);
g_assert (node->value == (i%2)?i:(i+1));
}
GSK_RBTREE_SUPREMUM_COMPARATOR (TREE(&tree), 1000, COMPARE_INT_WITH_TREE_NODE, node);
g_assert (node==NULL);
for (i = 1; i <= 1000; i++)
{
TreeNode *node;
GSK_RBTREE_INFIMUM_COMPARATOR (TREE(&tree), i, COMPARE_INT_WITH_TREE_NODE, node);
g_assert (node);
g_assert (node->value == (i%2)?i:(i-1));
}
GSK_RBTREE_INFIMUM_COMPARATOR (TREE(&tree), 0, COMPARE_INT_WITH_TREE_NODE, node);
g_assert (node==NULL);
for (i = 1; i <= 999; i += 2)
g_assert (del_tree (&tree, i));
/* random rbctree test */
g_printerr ("Testing RBC-tree macros... ");
for (i = 0; i < 1000; i++)
test_random_rbcint_tree (10, TRUE);
g_printerr (".");
for (i = 0; i < 100; i++)
test_random_rbcint_tree (100, TRUE);
g_printerr (".");
for (i = 0; i < 50; i++)
{
test_random_rbcint_tree (1000, FALSE);
g_printerr (".");
}
for (i = 0; i < 5; i++)
{
test_random_rbcint_tree (10000, FALSE);
g_printerr (".");
}
g_printerr (" done.\n");
return 0;
}
/* ---------------------------------------------------------------------------
.CSD: dset
.NAM:
.SHD:
.DSC: Realisierungsvorblock schreiben und Vorbereiten zum Daten-
schreiben
.RES:
.REM:
.SAL:
.EXF:
.END.
---------------------------------------------------------------------------
*/
short dset( DNORM_DCB * stream, short knr, short rnr, DPARA * parms )
{
RVB rvb;
long rvb_bytes; /* Anz. geschriebener RVB-Bytes */
int i;
KR_NODE * tree_pt;
long write_bytes;
char * pt;
/* ---------- Pruefung des Argumentstreams ----------
*/
if ( stream == NULL || stream->fp == NULL ) /* garnicht offen! */
{
derrno = DNERR_CLSTREAM;
return( EOF );
}
if ( stream->fopen_mode == 'r' ) /* nicht fuer mich! */
{
derrno = stream->err = DNERR_NOWRITESTREAM;
return( EOF );
}
/* ---------- Nachsehen, ob Realisierung mit knr/rnr im
Realisierungsbaum bereits vorhanden, wenn ja: Fehler
Achtung knr/rnr muessen! eindeutige shorts > 0 sein.
die Angabe von
FIRST, NEXT usw. (wie bei dget erlaubt) sind fuer
dset verboten ----------
*/
if ( knr <= 0 || rnr <= 0 ) /* knr oder rnr == 0 usw.ist*/
{
derrno = stream->err = DNERR_BADKRN;
return( EOF ); /* nicht zu laessig! */
}
if ( search_tree( stream->tree, knr, rnr, /* wenn knr/rnr-Kombination */
SEARCH_KRN ) != NULL ) /* bereits vorhanden: Fehler*/
{
derrno = stream->err = DNERR_DUPLKRN;
return( EOF );
}
/* ---------- einige Limitkontrollen ----------
*/
if ( (ULONG)parms->lrb > SHRT_MAX ) /* rb zu lang,schwerer Fehl.*/
{
derrno = stream->err = DNERR_RBLEN;
return( EOF );
}
if ( (ULONG)parms->lxt > SHRT_MAX ) /* rt zu lang! abschneiden! */
parms->lxt = SHRT_MAX;
if ( (ULONG)parms->lht > SHRT_MAX ) /* ht zu lang! abschneiden! */
parms->lht = SHRT_MAX;
if ( (ULONG)parms->lvrt > SHRT_MAX ) /* vrt zu lang! abschneiden!*/
parms->lvrt = SHRT_MAX;
/* ---------- Pruefung des Datumstring auf dnorm-Systemformat, bei
Nichtkonsistenz Fehler!
gueltiges Format mit 26 Zeichen:
'TAG - XX.MON.XX - HH:MM:SS'
Falls kein Datumstring spezifiziert ist wird er an dieser
Stelle mit dem aktuellen Datum generiert ----------
*/
if ( parms->dt && parms->ldt ) /* Datum spezifiziert... */
{ /* Konsistenz testen */
if ( parms->ldt != 26 ) /* schon falsche Laenge */
{
derrno = stream->err = DNERR_BADDATEFORM;
return( EOF );
}
pt = parms->dt;
if ( pt[4] != '-' || pt[16] != '-' || /* Stichprobenartiger Test */
pt[8] != '.' || pt[12] != '.' ||
pt[20] != ':' || pt[23] != ':' )
{
derrno = stream->err = DNERR_BADDATEFORM;
return( EOF );
}
}
else /* kein Datum spezifiziert */
{
pt = dn_getfmtdate();
parms->ldt = strlen( pt );
parms->dt = dn_malloc( parms->ldt +1 );
memmove( parms->dt, pt, (size_t)parms->ldt );
((char *)parms->dt)[parms->ldt] = '\0';
}
/* ---------- Berechnung/Ermittlung automatisch zu generierender
Realisierungsparameter ----------
*/
parms->vsize = 0;
for ( i = 0; i < parms->vdim; i++ )
parms->vsize += parms->rb[i].size; /* Vektorgroesse in byte */
parms->lrb = parms->vdim * sizeof( RB ); /* Laenge Recordbeschreibg. */
/* ---------- Parameter aus parms bzw. knr/rnr uebernehmen ----------
*/
rvb.vblocks = 0;
rvb.rdblocks = 0;
rvb.knr_sign[0] = 'K'; rvb.knr_sign[1] = 'N';
rvb.knr = knr;
rvb.rnr_sign[0] = 'R'; rvb.rnr_sign[1] = 'N';
rvb.rnr = rnr;
rvb.vanz_sign[0] = 'V'; rvb.vanz_sign[1] = 'A';
rvb.vanz = 0;
rvb.vdim_sign[0] = 'V'; rvb.vdim_sign[1] = 'D';
rvb.vdim = parms->vdim; /* Vektordimension */
rvb.vsize_sign[0] = 'V'; rvb.vsize_sign[1] = 'S';
rvb.vsize = parms->vsize; /* Vektorgroesse in byte */
rvb.zf_sign[0] = 'Z'; rvb.zf_sign[1] = 'F';
rvb.zf = parms->zf; /* Zeitfensterfaktor */
rvb.fsr_sign[0] = 'F'; rvb.fsr_sign[1] = 'S';
rvb.fsr = parms->fsr; /* Fortsetzrate */
rvb.ofs_sign[0] = 'O'; rvb.ofs_sign[1] = 'F';
rvb.ofs = parms->ofs; /* Offset */
rvb.rres1_sign[0] = 'R'; rvb.rres1_sign[1] = '1';
rvb.rres1 = parms->rres1;
rvb.rres2_sign[0] = 'R'; rvb.rres2_sign[1] = '2';
rvb.rres2 = parms->rres2;
rvb.rres3_sign[0] = 'R'; rvb.rres3_sign[1] = '3';
rvb.rres3 = parms->rres3;
rvb.rres4_sign[0] = 'R'; rvb.rres4_sign[1] = '4';
rvb.rres4 = parms->rres4;
rvb.rres5_sign[0] = 'R'; rvb.rres5_sign[1] = '5';
rvb.rres5 = parms->rres5;
/* ---------- Pos. des Vorblockanfangs der Realiserung
fuer stream merken ----------
*/
fseek( stream->fp, 0L, SEEK_END ); /* Pos. ans Dateiende */
stream->rvb_rba = ftell( stream->fp ); /* Start-rba d. Realis.merk.*/
/* ---------- Schreiben der Vorblockinformationen konstanter
Teil ----------
*/
rvb_bytes = 0; /* Zelle:Bytelaenge Vorblock*/
#if defined _RISCC_ || defined _OSFC_ || defined _GNUC_ || defined _SUNGC_ || defined _MSCWIN_
write_bytes = write_rvb( &rvb, stream->fp );
#else
if(fwrite( &rvb, (size_t)sizeof( RVB ), /* Vorblock schreiben */
(size_t)1, stream->fp ) !=1 ) {
derrno = stream->err = DNERR_NOWRITESTREAM;
return( EOF );
} /* RVB-blocks & Daten-block */
write_bytes = sizeof( RVB );
#endif
rvb_bytes += write_bytes; /* -anz. noch nicht bekannt!*/
/* ---------- Schreiben der Recordbeschreibung ----------
*/
fputc( 'R', stream->fp ); fputc( 'B', stream->fp );
rvb_bytes += 2;
if(fwrite_myswab( &parms->lrb, (size_t)sizeof( parms->lrb ),
(size_t)1, stream->fp ) !=1 ) {
derrno = stream->err = DNERR_NOWRITESTREAM;
return( EOF );
}
rvb_bytes += sizeof( parms->lrb );
if(parms->rb && (fwrite( parms->rb, (size_t)parms->lrb,
(size_t)1, stream->fp ) !=1 )) {
derrno = stream->err = DNERR_NOWRITESTREAM;
return( EOF );
}
rvb_bytes += parms->lrb;
/* ---------- Schreiben des Realis.kenntextes ----------
*/
fputc( 'R', stream->fp ); fputc( 'T', stream->fp );
rvb_bytes += 2;
if(fwrite_myswab( &parms->lrt, (size_t)sizeof( parms->lrt ),
(size_t)1, stream->fp ) !=1 ) {
derrno = stream->err = DNERR_NOWRITESTREAM;
return( EOF );
}
rvb_bytes += sizeof( parms->lrt );
if(parms->rt && (fwrite( parms->rt, (size_t)parms->lrt,
(size_t)1, stream->fp ) !=1 )) {
derrno = stream->err = DNERR_NOWRITESTREAM;
return( EOF );
}
rvb_bytes += parms->lrt;
/* ---------- Schreiben des Datumstrings ----------
*/
fputc( 'D', stream->fp ); fputc( 'T', stream->fp );
rvb_bytes += 2;
if(fwrite_myswab( &parms->ldt, (size_t)sizeof( parms->ldt ),
(size_t)1, stream->fp ) !=1 ) {
derrno = stream->err = DNERR_NOWRITESTREAM;
return( EOF );
}
rvb_bytes += sizeof( parms->ldt );
if(parms->dt && (fwrite( parms->dt, (size_t)parms->ldt,
(size_t)1, stream->fp ) !=1 )) {
derrno = stream->err = DNERR_NOWRITESTREAM;
return( EOF );
}
rvb_bytes += parms->ldt;
/* ---------- Schreiben der Modification history ----------
*/
fputc( 'H', stream->fp ); fputc( 'T', stream->fp );
rvb_bytes += 2;
if(fwrite_myswab( &parms->lht, (size_t)sizeof( parms->lht ),
(size_t)1, stream->fp ) !=1 ) {
derrno = stream->err = DNERR_NOWRITESTREAM;
return( EOF );
}
rvb_bytes += sizeof( parms->lht );
if(parms->ht && (fwrite( parms->ht, (size_t)parms->lht,
(size_t)1, stream->fp ) !=1 )) {
derrno = stream->err = DNERR_NOWRITESTREAM;
return( EOF );
}
rvb_bytes += parms->lht;
/* ---------- Schreiben des Realisierungsattributrecords ----------
*/
fputc( 'V', stream->fp ); fputc( 'R', stream->fp );
rvb_bytes += 2;
if(fwrite_myswab( &parms->lvrt, (size_t)sizeof( parms->lvrt ),
(size_t)1, stream->fp ) !=1 ) {
derrno = stream->err = DNERR_NOWRITESTREAM;
return( EOF );
}
rvb_bytes += sizeof( parms->lvrt );
if(parms->vrt && (fwrite( parms->vrt, (size_t)parms->lvrt,
(size_t)1, stream->fp ) !=1 )) {
derrno = stream->err = DNERR_NOWRITESTREAM;
return( EOF );
}
rvb_bytes += parms->lvrt;
/* ---------- Auffuellen des Vorblocks mit 0en und Vorblock -
groesse ermitteln (Anzahl der blocks) ----------
*/
rvb.vblocks = (short)(rvb_bytes / BL_SIZE); /* ganze blocks */
rvb_bytes %= BL_SIZE; /* Rest-bytes vorhanden ? */
if ( rvb_bytes ) /* nicht 0 */
{
for ( i = BL_SIZE; i > rvb_bytes; i-- ) /* angerissenen Block */
fputc( '\0', stream->fp ); /* mit 0-en auffuellen */
rvb.vblocks++; /* ein block mehr */
}
/* ---------- Vorblock mit korrekter blocks-Zahl neuschreiben
und Pos. des Beginns der Realis.daten merken ----------
*/
stream->dat_rba = ftell( stream->fp ); /* Beginn der Daten-blocks */
fseek( stream->fp, stream->rvb_rba,
SEEK_SET ); /* Anfang des Vorblocks */
#if defined _RISCC_ || defined _OSFC_ || defined _GNUC_ || defined _SUNGC_ || defined _MSCWIN_
write_bytes = write_rvb( &rvb, stream->fp );
#else
if(fwrite( &rvb, (size_t)sizeof( RVB ), /* Vorblock neu schreiben...*/
(size_t)1, stream->fp ) !=1 ) {
derrno = stream->err = DNERR_NOWRITESTREAM;
return( EOF );
}
write_bytes = sizeof( RVB );
#endif
fseek( stream->fp, stream->dat_rba, /* und zurueck auf den... */
SEEK_SET ); /* Anfang des 1.Datenblock */
stream->w_rest = 0L; /* keine freien bytes mehr */
/* wichtige Info fuer dwrite*/
/* ---------- Einfuegen der Realisierung in Realisierungsbaum ----------
*/
tree_pt = add_tree( stream->tree, knr, /* neue Realisierung mit Nr.*/
rnr,stream->rvb_rba ); /* und Start-rba in R.-Baum */
stream->objects++;
stream->tree = tree_pt;
/* ---------- in knr/rnr spez. Nummer wird die aktuelle
in parms und stream ----------
*/
parms->knr = knr; /* tatsaechliche Klassennnr.*/
parms->rnr = rnr; /* tatsaechliche Realis.nr. */
stream->knr = knr; /* aktuelle Klassen- und */
stream->rnr = rnr; /* Realis.nr. uebernehmen */
/* ----- Systemfehler bei File-E/A pruefen -----
*/
if ( ferror( stream->fp ) )
{
perror( "dnorm sys error" );
exit( 1 );
}
derrno = stream->err = DNERR_OK;
return( 0 );
} /* end of dset() */
pAssemblerTree Analysis::disasm(pCodeBufferInfo pinfo)
{
std::vector<CodePiece> piece_test;
disasm(pinfo,piece_test) ;
for (std::vector<CodePiece>::iterator iter = piece_test.begin();
iter != piece_test.end();iter++)
{
printf("\033[31m标签:%08x,\033[34m跳转到:%08x\033[0m,条件跳转:%d\n",iter->get_label(),iter->get_jmplabel(),iter->get_is_jcc());
for (std::list<ud_t>::iterator xiter = iter->get_piece().begin();
xiter != iter->get_piece().end();xiter++)
{
printf("%s\n",xiter->insn_buffer);
}
}
//__asm("int3");
ud_t ud_obj;
ud_init(&ud_obj);
#ifndef PROTECT_X64
ud_set_mode(&ud_obj,32);
#else
ud_set_mode(&ud_obj,64);
#endif
ud_set_pc(&ud_obj,pinfo->addr);
ud_set_input_buffer(&ud_obj, (uint8_t*)pinfo->buf, pinfo->size);
ud_set_syntax(&ud_obj,UD_SYN_INTEL);
base = pinfo->addr;
size = pinfo->size;
std::vector <long> address_array;
//pAssemblerTree root = new AssemblerTree;
// pAssemblerTree nowtree = root;
std::vector <ud_t> ud_obj_array;
address_array.push_back(pinfo->addr);
address_array.push_back(pinfo->addr + pinfo->size);
while (ud_disassemble(&ud_obj) != 0)
{
ud_obj_array.push_back(ud_obj);
// nowtree.asmpiect.push_back(ud_obj);
if (ud_obj.operand[0].type == UD_OP_JIMM || ud_obj.mnemonic == UD_Icall )//&& ud_obj.mnemonic != UD_Icall)
{
long addr = ud_obj.operand[0].size == 8
? ((signed char)ud_obj.operand[0].lval.sbyte + ud_obj.pc) :
(ud_obj.operand[0].lval.sdword + ud_obj.pc);
if (addr >= pinfo->addr && addr <= pinfo->addr + pinfo->size)
{
address_array.push_back(addr);
address_array.push_back(ud_obj.pc);
}
}
}
long count = 0;
long *a_array;
size_t address_size = address_array.size();
a_array = new long[address_size];
for (std::vector <long>::iterator iter = address_array.begin() ;
iter != address_array.end() ; ++iter)
{
bool fk = true;
for (int i = 0; i < count; ++i)
{
if (*iter == a_array[i])
{
fk = false;
}
}
if (fk)
a_array[count++] = *iter;
}
for (int i = 0; i < count; ++i)
{
for (int j = i; j < count ; ++j)
{
if (a_array[i] > a_array[j])
{
long t = a_array[i];
a_array[i] = a_array[j];
a_array[j] = t;
}
}
}
for (int i = 0; i < count; ++i)
{
printf("%08x\r\n",a_array[i]);
}
int point = 0;
pAssemblerTree nowtree = NULL;
pAssemblerTree parent = NULL;
const bool begin = true;
const bool end = false;
bool status = end;
for (std::vector <ud_t>::iterator iter = ud_obj_array.begin();
iter != ud_obj_array.end(); ++iter)
{
//typedef true begin;
//typedef false end;
// ud_t *p = iter;
ud_t ud = *iter;
if (ud.insn_offset == a_array[point] && status == end)
{
point++;
status = begin;
nowtree = new AssemblerTree;
root ? NULL : root = nowtree;
nowtree->LeftChild = NULL;
nowtree->RightChild = NULL;
nowtree->id = point - 1;
// nowtree.asmpiect.push_back(ud);
}
if (nowtree)
{
nowtree->asmpiece.push_back(ud);
}
if (ud.pc == a_array[point] && status == begin)
{
nowtree->base = a_array[point-1];
//point++;
nowtree->size = ud.pc - a_array[point-1]; //代码块大小
status = end;
parent = add_tree(parent,nowtree,L);
//nowtree = new AssemblerTree;
//nowtree->LeftChild = NULL;
//nowtree->RightChild = NULL;
}
nowtree->reloc_address = -1;
nowtree->next_instruction = ud.pc;
}
block_count = point;
link_tree();
#ifdef DEBUG
show_tree(root,"false:");
#endif
delete [] a_array;
// show_tree(root);
/*for (std::vector <long>::iterator iter = address_array.begin() ;
iter != address_array.end() ; ++iter)
{
int addr = *iter;
printf("%08x\r\n",addr);
}*/
return NULL;
}
