📄 oxccb.c
字号:
iv->symaddr[GL(((Pop)pdef)->data)], key.k1, key.k2, p, *p);
}
jp = jp->next;
}
}
static void
addto_jmplist(Piv iv, unsigned char *p, void *q)
{
void *next = iv->jbuf;
if(iv->jbufcnt >= sizeof(struct _jl))
{
iv->jbuf++;
}
else
{
iv->jbufcnt = 4080;
iv->jbuf = Ccalloc(FUNCDATA, 1, iv->jbufcnt);
}
*((void**)next) = iv->jbuf;
iv->jbuf->p = p;
iv->jbuf->q = q;
iv->jbuf->offset = iv->out_offset+iv->func_offset-5;
iv->jbufcnt -= sizeof(struct _jl);
}
static void
save_maxdepth(Piv iv, long symnum)
{
long key[2];
long val[3];
if(iv->functbl == 0)
{
iv->functbl = NewSymTable(iv->category, 277);
}
key[0] = symnum;
key[1] = 0;
val[0] = iv->maxdepth + (4*iv->numnested);
val[1] = iv->mindepth;
val[2] = 0;
SymInsert(iv->functbl, key, val, 12);
}
static long
get_maxdepth(Piv iv, short symnum)
{
long key[2];
long *result;
key[0] = symnum;
key[1] = 0;
if(SymFind(iv->functbl, key, &result))
{
return result[0];
}
return 0;
}
static void
printline(Piv iv, void *ptr)
{
fprintf(iv->outfile, "Line:%ld:\n", *((long*)ptr));
}
static int
print8(Piv iv, unsigned char *ptr, int size, long offset, int lf)
{
char buf[40];
int i, j=0;
i = sprintf(buf, "%8.8lx: ", offset);
while(j < size && j < 8)
{
i += sprintf(&buf[i], "%2.2x ", *ptr++);
++j;
}
if(lf)
buf[i++] = '\n';
else
{
while(i < 35)
buf[i++] = ' ';
}
buf[i] = 0;
fprintf(iv->outfile, buf);
return j;
}
static void
printinst(Piv iv, unsigned char *pc, long size)
{
int i, bufcnt;
unsigned char *epc;
char *pbuf[20];
bufcnt = 0;
epc = pc + size;
for( ;pc < epc; ++pc)
{
switch(*pc)
{
case LOCATE|J1:
case LOCATE|J2:
case LOCATE|J3:
case LOCATE|J4:
pbuf[bufcnt++] = "locate|";
pbuf[bufcnt++] = Jbuf[*pc & 0x03];
pc += Jcnt[*pc & 0x03];
break;
case LS|A1|B1:
case LS|A1|B2:
case LS|A1|B4:
case LS|A1|B8:
case LS|A2|B1:
case LS|A2|B2:
case LS|A2|B4:
case LS|A2|B8:
case LS|A3|B1:
case LS|A3|B2:
case LS|A3|B4:
case LS|A3|B8:
pbuf[bufcnt++] = "ls|";
pbuf[bufcnt++] = ABbuf[*pc & 0x0f];
pc += Acnt[(*pc>>2) & 0x03];
break;
case NEG|BYTE:
case NEG|SHORT:
case NEG|LONG:
case NEG|UBYTE:
case NEG|USHORT:
case NEG|ULONG:
case NEG|FLOAT:
case NEG|DOUBLE:
pbuf[bufcnt++] = "neg|";
pbuf[bufcnt++] = Tbuf[*pc & 0x07];
break;
case LM|A1|B1:
case LM|A1|B2:
case LM|A1|B4:
case LM|A1|B8:
case LM|A2|B1:
case LM|A2|B2:
case LM|A2|B4:
case LM|A2|B8:
case LM|A3|B1:
case LM|A3|B2:
case LM|A3|B4:
case LM|A3|B8:
case LM|A4|B1:
case LM|A4|B2:
case LM|A4|B4:
case LM|A4|B8:
pbuf[bufcnt++] = "lm|";
pbuf[bufcnt++] = ABbuf[*pc & 0x0f];
pc += Acnt[(*pc>>2) & 0x03];
break;
case COMP|B1:
case COMP|B2:
case COMP|B4:
case COMP|B8:
pbuf[bufcnt++] = "comp|";
pbuf[bufcnt++] = Bbuf[*pc & 0x03];
break;
case JMP|J1:
case JMP|J2:
case JMP|J3:
case JMP|J4:
pbuf[bufcnt++] = "jmp|";
pbuf[bufcnt++] = Jbuf[*pc & 0x03];
pc += Jcnt[*pc & 0x03];
break;
case JMPT|J1:
case JMPT|J2:
case JMPT|J3:
case JMPT|J4:
pbuf[bufcnt++] = "jmpt|";
pbuf[bufcnt++] = Jbuf[*pc & 0x03];
pc += Jcnt[*pc & 0x03];
break;
case LJMPT|J1:
case LJMPT|J2:
case LJMPT|J3:
case LJMPT|J4:
pbuf[bufcnt++] = "ljmpt|";
pbuf[bufcnt++] = Jbuf[*pc & 0x03];
pc += Jcnt[*pc & 0x03];
break;
case JMPF|J1:
case JMPF|J2:
case JMPF|J3:
case JMPF|J4:
pbuf[bufcnt++] = "jmpf|";
pbuf[bufcnt++] = Jbuf[*pc & 0x03];
pc += Jcnt[*pc & 0x03];
break;
case LJMPF|J1:
case LJMPF|J2:
case LJMPF|J3:
case LJMPF|J4:
pbuf[bufcnt++] = "ljmpf|";
pbuf[bufcnt++] = Jbuf[*pc & 0x03];
pc += Jcnt[*pc & 0x03];
break;
case NOT|B1:
case NOT|B2:
case NOT|B4: /* also FLOAT */
case NOT|B8: /* also DOUBLE */
pbuf[bufcnt++] = "not|";
pbuf[bufcnt++] = Bbuf[*pc & 0x03];
break;
case SS|A1|B1:
case SS|A1|B2:
case SS|A1|B4:
case SS|A1|B8:
case SS|A2|B1:
case SS|A2|B2:
case SS|A2|B4:
case SS|A2|B8:
case SS|A3|B1:
case SS|A3|B2:
case SS|A3|B4:
case SS|A3|B8:
pbuf[bufcnt++] = "ss|";
pbuf[bufcnt++] = ABbuf[*pc & 0x0f];
pc += Acnt[(*pc>>2) & 0x03];
break;
case TRUTHOF|B2:
case TRUTHOF|B4:
case TRUTHOF|B8:
pbuf[bufcnt++] = "truthof|";
pbuf[bufcnt++] = Bbuf[*pc & 0x03];
break;
case CVT:
{
unsigned char cvs,cvd;
pbuf[bufcnt++] = "cvt ";
++pc;
cvs = (*pc & 0x70)>>4;
cvd = (*pc & 0x07);
pbuf[bufcnt++] = Tbuf[cvd];
pbuf[bufcnt++] = "<-";
pbuf[bufcnt++] = Tbuf[cvs];
break;
}
case LI|B1:
case LI|B2:
case LI|B4:
case LI|B8:
pbuf[bufcnt++] = "li|";
pbuf[bufcnt++] = Bbuf[*pc & 0x03];
pc += Bcnt[*pc & 0x03];
break;
case LAI|D1:
case LAI|D2:
case LAI|D3:
case LAI|D4:
pbuf[bufcnt++] = "lai|";
pbuf[bufcnt++] = Dbuf[*pc & 0x03];
pc += Dcnt[*pc & 0x03];
break;
case LUI|B1:
case LUI|B2:
case LUI|B4:
case LUI|B8:
pbuf[bufcnt++] = "lui|";
pbuf[bufcnt++] = Bbuf[*pc & 0x03];
pc += Bcnt[*pc & 0x03];
break;
case IMMED:
{
++pc;
switch(*pc)
{
case SMI|A1|B1:
case SMI|A1|B2:
case SMI|A1|B4:
case SMI|A1|B8:
case SMI|A2|B1:
case SMI|A2|B2:
case SMI|A2|B4:
case SMI|A2|B8:
case SMI|A3|B1:
case SMI|A3|B2:
case SMI|A3|B4:
case SMI|A3|B8:
case SMI|A4|B1:
case SMI|A4|B2:
case SMI|A4|B4:
case SMI|A4|B8:
pbuf[bufcnt++] = "smi|";
pbuf[bufcnt++] = ABbuf[*pc & 0x0f];
pc += ABcnt[*pc & 0x0f];
break;
case SSI|A1|B1:
case SSI|A1|B2:
case SSI|A1|B4:
case SSI|A1|B8:
case SSI|A2|B1:
case SSI|A2|B2:
case SSI|A2|B4:
case SSI|A2|B8:
case SSI|A3|B1:
case SSI|A3|B2:
case SSI|A3|B4:
case SSI|A3|B8:
pbuf[bufcnt++] = "ssi|";
pbuf[bufcnt++] = ABbuf[*pc & 0x0f];
pc += ABcnt[*pc & 0x0f];
break;
case MODI|BYTE:
case MODI|SHORT:
case MODI|LONG:
case MODI|UBYTE:
case MODI|USHORT:
case MODI|ULONG:
pbuf[bufcnt++] = "modi|";
pbuf[bufcnt++] = Tbuf[*pc & 0x07];
pc += 2;
break;
case DEREF|BYTE:
case DEREF|SHORT:
case DEREF|LONG:
case DEREF|UBYTE:
case DEREF|USHORT:
case DEREF|ULONG:
case DEREF|FLOAT:
case DEREF|DOUBLE:
pbuf[bufcnt++] = "deref|";
pbuf[bufcnt++] = Tbuf[*pc & 0x07];
break;
case DEREF1|BYTE:
case DEREF1|SHORT:
case DEREF1|LONG:
case DEREF1|UBYTE:
case DEREF1|USHORT:
case DEREF1|ULONG:
case DEREF1|FLOAT:
case DEREF1|DOUBLE:
pbuf[bufcnt++] = "deref1|";
pbuf[bufcnt++] = Tbuf[*pc & 0x07];
break;
}
break;
}
case SM|A1|B1:
case SM|A1|B2:
case SM|A1|B4:
case SM|A1|B8:
case SM|A2|B1:
case SM|A2|B2:
case SM|A2|B4:
case SM|A2|B8:
case SM|A3|B1:
case SM|A3|B2:
case SM|A3|B4:
case SM|A3|B8:
case SM|A4|B1:
case SM|A4|B2:
case SM|A4|B4:
case SM|A4|B8:
pbuf[bufcnt++] = "sm|";
pbuf[bufcnt++] = ABbuf[*pc & 0x0f];
pc += Acnt[(*pc>>2) & 3];
break;
case ADD|BYTE:
case ADD|SHORT:
case ADD|LONG:
case ADD|UBYTE:
case ADD|USHORT:
case ADD|ULONG:
case ADD|FLOAT:
case ADD|DOUBLE:
pbuf[bufcnt++] = "add|";
pbuf[bufcnt++] = Tbuf[*pc & 0x07];
break;
case SUB|BYTE:
case SUB|SHORT:
case SUB|LONG:
case SUB|UBYTE:
case SUB|USHORT:
case SUB|ULONG:
case SUB|FLOAT:
case SUB|DOUBLE:
pbuf[bufcnt++] = "sub|";
pbuf[bufcnt++] = Tbuf[*pc & 0x07];
break;
case MUL|BYTE:
case MUL|SHORT:
case MUL|LONG:
case MUL|UBYTE:
case MUL|USHORT:
case MUL|ULONG:
case MUL|FLOAT:
case MUL|DOUBLE:
pbuf[bufcnt++] = "mul|";
pbuf[bufcnt++] = Tbuf[*pc & 0x07];
break;
case DIV|BYTE:
case DIV|SHORT:
case DIV|LONG:
case DIV|UBYTE:
case DIV|USHORT:
case DIV|ULONG:
case DIV|FLOAT:
case DIV|DOUBLE:
pbuf[bufcnt++] = "div|";
pbuf[bufcnt++] = Tbuf[*pc & 0x07];
break;
case OR|B1:
case OR|B2:
case OR|B4:
case OR|B8:
pbuf[bufcnt++] = "or|";
pbuf[bufcnt++] = Bbuf[*pc & 0x03];
break;
case AND|B1:
case AND|B2:
case AND|B4:
case AND|B8:
pbuf[bufcnt++] = "and|";
pbuf[bufcnt++] = Bbuf[*pc & 0x03];
break;
case MOD|BYTE:
case MOD|SHORT:
case MOD|LONG:
case MOD|UBYTE:
case MOD|USHORT:
case MOD|ULONG:
pbuf[bufcnt++] = "mod|";
pbuf[bufcnt++] = Tbuf[*pc & 0x07];
break;
case XTD:
{
++pc;
switch(*pc)
{
case LI:
pbuf[bufcnt++] = "li";
pc += XSZ;
break;
case LSH|B1:
case LSH|B2:
case LSH|B4:
case LSH|B8:
pbuf[bufcnt++] = "lsh|";
pbuf[bufcnt++] = Bbuf[*pc & 0x03];
break;
case LSHI|B1:
case LSHI|B2:
case LSHI|B4:
case LSHI|B8:
pbuf[bufcnt++] = "lshi|";
pbuf[bufcnt++] = Bbuf[*pc & 0x03];
++pc;
break;
case RSH|BYTE:
case RSH|SHORT:
case RSH|LONG:
case RSH|UBYTE:
case RSH|USHORT:
case RSH|ULONG:
pbuf[bufcnt++] = "rsh|";
pbuf[bufcnt++] = Tbuf[*pc & 0x07];
break;
case RSHI|BYTE:
case RSHI|SHORT:
case RSHI|LONG:
case RSHI|UBYTE:
case RSHI|USHORT:
case RSHI|ULONG:
pbuf[bufcnt++] = "rshi|";
pbuf[bufcnt++] = Tbuf[*pc & 0x07];
++pc;
break;
case BUILTIN:
{
pbuf[bufcnt++] = "builtin ";
++pc;
pbuf[bufcnt++] = BUbuf[*pc];
break;
} /* END: XTD BUILTIN */
case CLRDAT:
pbuf[bufcnt++] = "clrdat";
break;
case SWITCH:
pbuf[bufcnt++] = "switch";
pc += 2;
break;
case CALLSETUP:
pbuf[bufcnt++] = "callsetup";
pc += 4;
break;
case RETSTRUCT:
pbuf[bufcnt++] = "retstruct";
pc += 4;
break;
case PRUNESTRUCT:
pbuf[bufcnt++] = "prunestruct";
break;
case GETBITFIELD:
pbuf[bufcnt++] = "getbitfield";
pc += 3;
break;
case PUTBITFIELD:
pbuf[bufcnt++] = "putbitfield";
pc += 3;
break;
case IMMED:
{
++pc;
switch(*pc)
{
case SMI|A1:
case SMI|A2:
case SMI|A3:
case SMI|A4:
pbuf[bufcnt++] = "smi|";
pbuf[bufcnt++] = Abuf[(*pc>>2) & 0x03];
pc += Acnt[(*pc>>2) & 0x03] + XSZ;
break;
case SSI|A1:
case SSI|A2:
case SSI|A3:
pbuf[bufcnt++] = "ssi|";
pbuf[bufcnt++] = Abuf[(*pc>>2) & 0x03];
pc += Acnt[(*pc>>2) & 0x03] + XSZ;
break;
case MODI|LONGLONG:
case MODI|ULONGLONG:
pbuf[bufcnt++] = "modi|";
pbuf[bufcnt++] = XTbuf[*pc & 0x03];
pc += 2;
break;
case DEREF|LONGLONG:
case DEREF|ULONGLONG:
case DEREF|LONGDOUBLE:
pbuf[bufcnt++] = "deref|";
pbuf[bufcnt++] = XTbuf[*pc & 0x03];
break;
case DEREF1|LONGLONG:
case DEREF1|ULONGLONG:
case DEREF1|LONGDOUBLE:
pbuf[bufcnt++] = "deref1|";
pbuf[bufcnt++] = XTbuf[*pc & 0x03];
break;
}
break;
}/* END: XTD IMMED */
case ADD|LONGLONG:
case ADD|ULONGLONG:
case ADD|LONGDOUBLE:
pbuf[bufcnt++] = "add|";
pbuf[bufcnt++] = XTbuf[*pc & 0x03];
break;
case SUB|LONGLONG:
case SUB|ULONGLONG:
case SUB|LONGDOUBLE:
pbuf[bufcnt++] = "sub|";
pbuf[bufcnt++] = XTbuf[*pc & 0x03];
case MUL|LONGLONG:
case MUL|ULONGLONG:
case MUL|LONGDOUBLE:
pbuf[bufcnt++] = "mul|";
pbuf[bufcnt++] = XTbuf[*pc & 0x03];
break;
case DIV|LONGLONG:
case DIV|ULONGLONG:
case DIV|LONGDOUBLE:
pbuf[bufcnt++] = "div|";
pbuf[bufcnt++] = XTbuf[*pc & 0x03];
break;
case LT|LONGLONG:
case LT|ULONGLONG:
case LT|LONGDOUBLE:
pbuf[bufcnt++] = "lt|";
pbuf[bufcnt++] = XTbuf[*pc & 0x03];
break;
case GT|LONGLONG:
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -