ccx.h

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

              *p_outfile;       /* stdout name (eventually "-" if not a file) */

/* logical to physical and vice versa */
PBYTE toMap(int);
PBYTE toFile(int);
int fromMap(PBYTE);
int fromFile(PBYTE);

/* Btree related funcions */
Bnode *init_Btree(int *);
int    in_Bnode  (PKEY, Bnode *);
PKEY   searchBtree1(PKEY);
PKEY   searchBtree2(PKEY);
PKEY   searchBtree3(PKEY);
int    MyBtreeInsert(PKEY);
int    MyBtreeInsertEx(PKEY);
int    MyBtreeDelete(PKEY);
Bnode *Btree_search(PKEY, Bnode *, int *);
void   insert_key(Bnode *, PKEY, Bnode *, Bnode * );
Bnode *split(PKEY, Bnode *, Bnode *);
Bnode *Btree_insert(PKEY, Bnode *, int *);
void   delete_key(Bnode *, int);
int    borrow_key(Bnode *, int);
Bnode *bind_node(Bnode *, int, Bnode *);
void   make_swap(Bnode *, Bnode *, PKEY, int);
Bnode *Btree_delete(PKEY, Bnode *, int *);
void   _deleteall(Bnode *);
Bnode *Btree_deleteall(Bnode *, int *);
void   _list(Bnode *);
void   Btree_list(Bnode *);
void   _sort(Bnode *);
void   Btree_sort(Bnode *);



/* opcodes */
# define INCR   5            /* increment value stack */
# define PARM   4            /* parameter to a function call */
# define FUNC   3            /* That's got an ACTION operand */
# define EXIT   2
# define CNST   1            /* That's got a VALUE operand. */
# define NOP    0            /* Saves time. */

/* program stack manipulation */
#define push(x) {if(pc>=precc_data.maxprogramsize-1){\
                 printf("\nprecc: program stack overflow (%d)\n",pc);\
                 p_exit(19);\
                 }\
                 program[pc++]=(x);\
                }
# define pull(n) (pc-=(n))
# define pop(x)  (x=program[--pc])
# define ppeek(x) (pc>0?x=program[pc-1]:((x).opcode=EXIT,(x)))
# define ppoke(x) {if(pc>0)program[pc-1]=(x);}

/* load and unlaod the current instruction */
#define getinstruction(n,x)   {Opcode(instr)=(n);Action(instr)=(x);}
#define pushinstruction(n,x)  {getinstruction(n,x);push(instr);}
#define getTOKEN(x)           {Opcode(instr)=(CNST);Token(instr)=(TOKEN)(x);}
#define getPARAM(x)           {Opcode(instr)=(PARM);Param(instr)=(PARAM)(x);}
#define getMANIP(x)           {Opcode(instr)=(INCR);Param(instr)=(PARAM)(x);}
#define getVALUE(x)           {Opcode(instr)=(CNST);Value(instr)=(VALUE)(x);}
#define pushTOKEN(x)          {getTOKEN(x);push(instr);}
#define pushPARAM(x)          {getPARAM(x);push(instr);}
#define pushVALUE(x)          {getVALUE(x);push(instr);}
#define pushACTION(x)         pushinstruction(FUNC,(x))
#define pushEXIT              pushinstruction(EXIT,0)
/* don't allow extra stack manips if call_mode=1 */
/* and let's try some on-the-fly optimisation    */
/* now let's try disabling stack manipulations altogether ! */
# define pushMANIP(x)
# define pushINCR               pushMANIP(1)
# define pushDECR               pushMANIP(-1)
# define pushNOP               pushinstruction(NOP,0)

/* evaluation stack manipulation */
# define pushvalue(x) ((*value++).val)=(x)
# define pushparam(x) ((*value++).par)=(x)
# define pushtoken(x) ((*value++).val)=(VALUE)(x)
# define popvalue(x)  (x=(*--value).val)
# define poptoken(x)  (x=(TOKEN)(*--value).val)
# define popparam(x)  (x=(*--value).par)
# define pullvalue(n) &((value-=(n))->val)
# define pullparam(n) &((value-=(n))->par)
# define pulltoken(n) &(TOKEN)((value-=(n))->val))
/*
# define pullvalue(n) &stack[(int)(value-=(n))-(int)stack].val
# define pullparam(n) &stack[(int)(value-=(n))-(int)stack].par
# define pulltoken(n) &stack[(int)(value-=(n))-(int)stack].tok
*/

/* frame stack manipulation */
# define fpush(x) (*fptr++=(x))
# define fpop(x)  (x=*--fptr)
# define fpull(n) (fptr-=(n))
# define fsave(x) \
x.pstr=pstr;\
/*x.value=value;*/\
x.pc=pc;\
x.lineno=passcount

//# define frestore(x) \
//pstr=(x.lineno==passcount)?x.pstr:(btk_error(),buffer);\
//pc=x.pc\

# define frestore(x) \
if (x.lineno==passcount)pstr=x.pstr;\
else {pstr=x.pstr;p_exit(-1);}pc=x.pc


/* multi-argument function call */

/* I have to use int's in the param list because of possible promotion */

# define CALL(p,m,a,e)  {\
    m=va_arg(ap,int);\
    a=(PARAM*)ap; /* very NON-PORTABLE, but it's fast */\
    ap=(va_list)&a[m];\
    m++;\
    switch(m-1) {\
    case 0: p();break;\
    case 1: p(a[0]);break;\
    case 2: p(a[0],a[1]);break;\
    case 3: p(a[0],a[1],a[2]);break;\
    case 4: p(a[0],a[1],a[2],a[3]);break;\
    case 5: p(a[0],a[1],a[2],a[3],a[4]);break;\
    case 6: p(a[0],a[1],a[2],a[3],a[4],a[5]);break;\
    case 7: p(a[0],a[1],a[2],a[3],a[4],a[5],a[6]);break;\
    case 8: p(a[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7]);break;\
    case 9: p(a[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7],a[8]);break;\
    case 10: p(a[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7],a[8],a[9]);break;\
    case 11: p(a[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7],a[8],a[9],a[10]);break;\
    case 12: p(a[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7],a[8],a[9],a[10],a[11]);\
             break;\
    case 13: p(a[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7],a[8],a[9],a[10],a[11],\
             a[12]);break;\
    case 14: p(a[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7],a[8],a[9],a[10],a[11],\
             a[12],a[13]);break;\
    case 15: p(a[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7],a[8],a[9],a[10],a[11],\
             a[12],a[13],a[14]);break;\
    case 16: p(a[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7],a[8],a[9],a[10],a[11],\
             a[12],a[13],a[14],a[15]);break;\
    default: p_exit(e);\
    }\
}


# define setvalue(n)  pullvalue(call_mode?(n)-1:0);refvalue(1)
# define settoken(n)  pullvalue(call_mode?(n)-1:0);reftoken(1)
# define refvalue(n)  (value[(n)-2].val)
# define reftoken(n)  (TOKEN)(long)(value[(n)-2].val)
# define refpar(n)    (value[(n)-2].par)


/* program-interpreter */
    /* in engine.c */
extern int p_evaluate();

/* read and run parser, interpret resulting program */
    /* in engine.c */
extern ACTION p_run;

/* parsers without actions */

# define p_andparse0(x,y) p_andparse0n(x,(char)0,y,(char)0)
# define  p_orparse0(x,y) p_orparse0n(x,(char)0,y,(char)0)
# define     p_many0(x) p_many0n(x,(char)0)
# define   p_iter0(n,x) p_iter0n(n,x,(char)0)
# define     p_some0(x) p_some0n(x,(char)0)
# define   p_option0(x) p_option0n(x,(char)0)
# define    p_range0(x) p_range0n(x,(char)0)
# define   p_hidden0(x) p_hidden0n(x,(char)0)
# define    p_until0(x) p_until0n(x,(char)0)

/* defined in common.c */

extern PARSER p_nothing0;
extern PARSER p_anything0;
extern PARSER p_first0;
extern PARSER p_last0;
extern PARSER p_exactly0;
extern PARSER p_notexactly0;
extern PARSER p_attach0;
extern PARSER p_uniq0;

/* parsers with actions attached */

# define ATTACH(p,f) if(GOODSTATUS(p))pushACTION(f)
# define p_attach(x,y) p_attach0n(x,(char)0,y,(char)0)
# define p_prepend(x,y) p_prepend0n(x,(char)0,y,(char)0)

# define p_andparse(p,q,f) ATTACH(p_andparse0(p,q),f)
# define p_orparse(p,q,f) ATTACH(p_orparse0(p,q),f)
# define p_many(p,f) ATTACH(p_many0(p),f)
# define p_iter(n,p,f) ATTACH(p_iter0(n,p),f)
# define p_some(p,f) ATTACH(p_some0(p),f)
# define p_option(p,f) ATTACH(p_option0(p),f)
# define p_nothing(f) ATTACH(p_nothing0(),f)
# define p_anything(f) ATTACH(p_anything0(),f)
# define p_first(f) ATTACH(p_first0(),f)
# define p_last(f) ATTACH(p_last0(),f)
# define p_exactly(f) ATTACH(p_exactly0(),f)
# define p_notexactly(f) ATTACH(p_notexactly0(),f)
# define p_range(p,f) ATTACH(p_range0(p),f)

/*
*/

/* parsers taking a variable number of arguments */
extern STATUS p_andparse0n(PARSER *, ...);
extern STATUS p_starparse0n(VALUE *,PARSER *, ...);
extern STATUS p_orparse0n(PARSER *, ...);
extern STATUS p_option0n(PARSER *, ...);
extern STATUS p_hidden0n(PARSER *, ...);
extern STATUS p_many0n(PARSER *, ...);
extern STATUS p_iter0n(int, PARSER *, ...);
extern STATUS p_some0n(PARSER *, ...);
extern STATUS p_uniq0n(PARSER *, ...);
extern STATUS p_attach0n(PARSER *, ...);
extern STATUS p_prepend0n(ACTION *, ...);
extern STATUS p_range0n(PREDICATE *, ...);
extern STATUS p_until0n(PARSER *, ...);
extern STATUS p_uerror0n(PARSER *, ...);
extern PARSER p_test0;

/* actions*/
    /* in common.c */
extern ACTION p_nop;

/* aux */
extern char *p_scpy();
extern void p_exit(int);
    /* (in on_error.c) */
extern ACTION zer_error;
extern ACTION bad_error;
extern ACTION btk_error;
extern ACTION precc_begin;
extern ACTION precc_end;
    /* lexer (in yystuff.c)*/
extern int yylex();
    /* in engine.c */
extern TOKEN      get1token();
extern ACTION     realignbuffer;
extern VOID       callerror(int);

#define P_PSTAR(X,CALL1,CALL2) \
  MARK;  p_tok = CALL1;\
  if (BADSTATUS(p_tok)) {RELEASE;return p_tok;}\
  X = (PARAM)INSTATUS(p_tok); p_tok = CALL2;\
  if (BADSTATUS(p_tok)) {REWIND;} else {RELEASE;}

#define P_PAND(CALL1,CALL2) \
  MARK; p_tok = CALL1;\
  if (BADSTATUS(p_tok)) {RELEASE;return p_tok;}\
  p_tok = CALL2;\
  if (BADSTATUS(p_tok)) {REWIND;} else {RELEASE;}


#define MAIN(x)