a.c

小型游戏引擎

        : "cc", "memory");
    return(retval);
} /* tsethlineshift */

/* #pragma aux setupslopevlin parm [eax][ebx][ecx] modify [edx] */
long setupslopevlin(long i1, long i2, long i3)
{
    long retval;
    __asm__ __volatile__ (
        "call _asm_setupslopevlin   \n\t"
       : "=a" (retval)
        : "a" (i1), "b" (i2), "c" (i3)
        : "cc", "edx", "memory");
    return(retval);
} /* setupslopevlin */

/* #pragma aux slopevlin parm [eax][ebx][ecx][edx][esi][edi] */
long slopevlin(long i1, long i2, long i3, long i4, long i5, long i6)
{
    long retval;
    __asm__ __volatile__ (
        "call _asm_slopevlin   \n\t"
       : "=a" (retval)
        : "a" (i1), "b" (i2), "c" (i3), "d" (i4), "S" (i5), "D" (i6)
        : "cc", "memory");
    return(retval);
} /* slopevlin */

/* #pragma aux settransnormal parm */
long settransnormal(void)
{
    long retval;
    __asm__ __volatile__ (
        "call _asm_settransnormal   \n\t"
       : "=a" (retval)
        :
        : "cc", "memory");
    return(retval);
} /* settransnormal */

/* #pragma aux settransreverse parm */
long settransreverse(void)
{
    long retval;
    __asm__ __volatile__ (
        "call _asm_settransreverse   \n\t"
       : "=a" (retval)
        :
        : "cc", "memory");
    return(retval);
} /* settransreverse */

/* #pragma aux setupdrawslab parm [eax][ebx] */
long setupdrawslab(long i1, long i2)
{
    long retval;
    __asm__ __volatile__ (
        "call _asm_setupdrawslab   \n\t"
       : "=a" (retval)
        : "a" (i1), "b" (i2)
        : "cc", "memory");
    return(retval);
} /* setupdrawslab */

/* #pragma aux drawslab parm [eax][ebx][ecx][edx][esi][edi] */
long drawslab(long i1, long i2, long i3, long i4, long i5, long i6)
{
    long retval;
    __asm__ __volatile__ (
        "call _asm_drawslab   \n\t"
       : "=a" (retval)
        : "a" (i1), "b" (i2), "c" (i3), "d" (i4), "S" (i5), "D" (i6)
        : "cc", "memory");
    return(retval);
} /* drawslab */

/* #pragma aux stretchhline parm [eax][ebx][ecx][edx][esi][edi] */
long stretchhline(long i1, long i2, long i3, long i4, long i5, long i6)
{
    long retval;
    __asm__ __volatile__ (
        "call _asm_stretchhline   \n\t"
       : "=a" (retval)
        : "a" (i1), "b" (i2), "c" (i3), "d" (i4), "S" (i5), "D" (i6)
        : "cc", "memory");
    return(retval);
} /* drawslab */

#else  /* below is the C version of all that nasty self-modifying ASM... */


long is_vmware_running(void)
{
    return(0);
} /* is_vmware_running */


static unsigned char machxbits_val = 6;
static unsigned char hxsiz_val = 26;
static unsigned char hysiz_val = 6;
static unsigned char hmach3_val = 6;
static char *hoffs_val = 0x88888888;
static unsigned long fixchain1_val = 320;
static unsigned long fixchain2_val = 0x88888888;
static char *pal_val = (char *) 0x88888888;
static unsigned long hmach4_val = 0x88888888;
static unsigned long hmach1_val = 0x88888888;

/*
_sethlinesizes (long (eax), long (ebx), long (ecx))
	mov byte ptr [machxbits1+2], al
	mov byte ptr [machxbits2+2], al
	mov byte ptr [machxbits3+2], al
	neg al
	mov byte ptr [hxsiz1+2], al
	mov byte ptr [hxsiz2+2], al
	mov byte ptr [hxsiz3+2], al
	mov byte ptr [hxsiz4+2], al
	mov byte ptr [machnegxbits1+2], al

	mov byte ptr [hysiz1+3], bl
	mov byte ptr [hysiz2+3], bl
	mov byte ptr [hysiz3+3], bl
	mov byte ptr [hysiz4+3], bl
	mov byte ptr [hmach3a+2], bl
	mov byte ptr [hmach3b+2], bl
	mov byte ptr [hmach3c+2], bl
	mov byte ptr [hmach3d+2], bl

	mov dword ptr [hoffs1+2], ecx
	mov dword ptr [hoffs2+2], ecx
	mov dword ptr [hoffs3+2], ecx
	mov dword ptr [hoffs4+2], ecx
	mov dword ptr [hoffs5+2], ecx
	mov dword ptr [hoffs6+2], ecx
	mov dword ptr [hoffs7+2], ecx
	mov dword ptr [hoffs8+2], ecx

	mov edx, -1
	mov cl, al
	sub cl, bl
	shr edx, cl
	mov dword ptr [hmach2a+1], edx
	mov dword ptr [hmach2b+1], edx
	mov dword ptr [hmach2c+1], edx
	mov dword ptr [hmach2d+1], edx

	ret
*/

long sethlinesizes(long i1, long i2, long i3)
{
    unsigned char al = (i1 & 0xFF);
    unsigned char bl = (i2 & 0xFF);
    unsigned long edx = 0;

    machxbits_val = al;
    al ~= al;
    hxsiz_val = al;
    machinenegxbits_val = al;

    hysiz_val = bl;
    hmach3_val = bl;
    hoffs_val = (char *) i3;
    hmach2_val = (-1 >> (al - bl));

    return(0);
}

/*
    Used in Pentium II/Pentium Pro overlay. --ryan.
ALIGN 16
PUBLIC prosethlinesizes_
prosethlinesizes_:
	mov dword ptr [prohbuf-4], ecx
	neg eax
	mov ecx, eax
	sub eax, ebx
	mov byte ptr [prohshru-1], al   ;bl = 32-al-bl
	mov eax, -1
	shr eax, cl
	mov ecx, ebx
	shl eax, cl
	mov dword ptr [prohand-4], eax  ;((-1>>(-oal))<<obl)
	neg ebx
	mov byte ptr [prohshrv-1], bl   ;bl = 32-bl
	ret
*/


/*
_setvlinebpl_(long (eax))
	mov dword ptr [fixchain1a+2], eax
	mov dword ptr [fixchain1b+2], eax
	mov dword ptr [fixchain1m+2], eax
	mov dword ptr [fixchain1t+2], eax
	mov dword ptr [fixchain1s+2], eax
	mov dword ptr [mfixchain1s+2], eax
	mov dword ptr [tfixchain1s+2], eax
	mov dword ptr [fixchain2a+2], eax
	mov dword ptr [profixchain2a+2], eax
	mov dword ptr [fixchain2ma+2], eax
	mov dword ptr [fixchain2mb+2], eax
	mov dword ptr [fixchaint2a+1], eax
	mov dword ptr [fixchaint2b+2], eax
	mov dword ptr [fixchaint2c+2], eax
	mov dword ptr [fixchaint2d+2], eax
	mov dword ptr [fixchaint2e+2], eax
	ret
*/

long setvlinebpl(long i1)
{
    fixchain1_val = i1;
    fixchain2_val = i1;
    return(0);
} /* setvlinebpl */



/*
_setpalookupaddress_(char * (eax)):
	mov dword ptr [pal1+2], eax
	mov dword ptr [pal2+2], eax
	mov dword ptr [pal3+2], eax
	mov dword ptr [pal4+2], eax
	mov dword ptr [pal5+2], eax
	mov dword ptr [pal6+2], eax
	mov dword ptr [pal7+2], eax
	mov dword ptr [pal8+2], eax
	ret
*/

long setpalookupaddress(char *i1)
{
    pal_val = i1;
    return(0);
} /* setpalookupaddress */


/*
    Used in Pentium II/Pentium Pro overlay. --ryan.
ALIGN 16
PUBLIC prosetpalookupaddress_
prosetpalookupaddress_:
	mov dword ptr [prohpala-4], eax
	ret
*/


/*
_setuphlineasm4_(long (eax), long (ebx))
machxbits3: rol eax, 6                     ;xbits
	mov dword ptr [hmach4a+2], eax
	mov dword ptr [hmach4b+2], eax
	mov bl, al
	mov dword ptr [hmach4c+2], eax
	mov dword ptr [hmach4d+2], eax
	mov dword ptr [hmach1a+2], ebx
	mov dword ptr [hmach1b+2], ebx
	mov dword ptr [hmach1c+2], ebx
	mov dword ptr [hmach1d+2], ebx
	ret
*/

long setuphlineasm4(long i1, long i2)
{
    hmach4_val = i1;
    hmach1_val = ((i2 & 0xFF00) | (i1 & 0xFF));
} /* setuphlineasm4 */


/*
	;Non-256-stuffed ceiling&floor method with NO SHLD!:
	;yinc&0xffffff00   lea eax, [edx+88888800h]           1     1/2
	;ybits...xbits     and edx, 88000088h                 1     1/2
	;ybits             rol edx, 6                         2     1/2
	;xinc<<xbits       add esi, 88888888h                 1     1/2
	;xinc>>(32-xbits)  adc al, 88h                        1     1/2
	;bufplc            mov cl, byte ptr [edx+88888888h]   1     1/2
	;paloffs&255       mov bl, byte ptr [ecx+88888888h]   1     1/2

_hlineasm4_ (long (eax), long (ebx), long (ecx), long (edx), long (esi), long (edi))
	push ebp

	lea ebp, [eax+1]

	cmp ebp, 8
	jle shorthline

	test edi, 1
	jnz short skipthe1byte

	mov eax, esi
hxsiz1: shr eax, 26
hysiz1: shld eax, edx, 6
hoffs1: mov cl, byte ptr [eax+88888888h]
pal1: mov bl, byte ptr [ecx+88888888h]
	sub esi, _asm1
	sub edx, _asm2
	mov byte ptr [edi], bl
	dec edi
	dec ebp

skipthe1byte:
	test edi, 2
	jnz short skipthe2byte

	mov eax, esi
hxsiz2: shr eax, 26
hysiz2: shld eax, edx, 6
hoffs2: mov cl, byte ptr [eax+88888888h]
pal2: mov bh, byte ptr [ecx+88888888h]
	sub esi, _asm1
	sub edx, _asm2

	mov eax, esi
hxsiz3: shr eax, 26
hysiz3: shld eax, edx, 6
hoffs3: mov cl, byte ptr [eax+88888888h]
pal3: mov bl, byte ptr [ecx+88888888h]
	sub esi, _asm1
	sub edx, _asm2
	mov word ptr [edi-1], bx
	sub edi, 2
	sub ebp, 2

skipthe2byte:

	mov eax, esi
machxbits1: shl esi, 6                     ;xbits
machnegxbits1: shr eax, 32-6               ;32-xbits
	mov dl, al

	inc edi

	add ebx, ebx
	mov eax, edx
	jc beginhline64

	mov eax, _asm1
machxbits2: rol eax, 6                     ;xbits
	mov dword ptr [hmach4a+2], eax
	mov dword ptr [hmach4b+2], eax
	mov dword ptr [hmach4c+2], eax
	mov dword ptr [hmach4d+2], eax
	mov ebx, eax
	mov eax, _asm2
	mov al, bl
	mov dword ptr [hmach1a+2], eax
	mov dword ptr [hmach1b+2], eax
	mov dword ptr [hmach1c+2], eax
	mov dword ptr [hmach1d+2], eax

	mov eax, edx
	jmp beginhline64
ALIGN 16
prebeginhline64:
	mov dword ptr [edi], ebx
beginhline64:

hmach3a: rol eax, 6
hmach2a: and eax, 00008888h
hmach4a: sub esi, 88888888h
hmach1a: sbb edx, 88888888h
	sub edi, 4
hoffs4: mov cl, byte ptr [eax+88888888h]
	mov eax, edx

hmach3b: rol eax, 6
hmach2b: and eax, 00008888h
hmach4b: sub esi, 88888888h
hmach1b: sbb edx, 88888888h
pal4: mov bh, byte ptr [ecx+88888888h]
hoffs5: mov cl, byte ptr [eax+88888888h]
	mov eax, edx

hmach3c: rol eax, 6
pal5: mov bl, byte ptr [ecx+88888888h]
hmach2c: and eax, 00008888h
	shl ebx, 16
hmach4c: sub esi, 88888888h
hmach1c: sbb edx, 88888888h
hoffs6: mov cl, byte ptr [eax+88888888h]

	mov eax, edx
	;(

hmach3d: rol eax, 6
hmach2d: and eax, 00008888h
hmach4d: sub esi, 88888888h
hmach1d: sbb edx, 88888888h
pal6: mov bh, byte ptr [ecx+88888888h]
hoffs7: mov cl, byte ptr [eax+88888888h]
	mov eax, edx
	sub ebp, 4
	nop
pal7: mov bl, byte ptr [ecx+88888888h]
	jnc prebeginhline64
skipthe4byte:

	test ebp, 2
	jz skipdrawthe2
	rol ebx, 16
	mov word ptr [edi+2], bx
	sub edi, 2
skipdrawthe2:
	test ebp, 1
	jz skipdrawthe1
	shr ebx, 24
	mov byte ptr [edi+3], bl
skipdrawthe1:

	pop ebp
	ret

shorthline:
	test ebp, ebp
	jz endshorthline
begshorthline:
	mov eax, esi
hxsiz4: shr eax, 26
hysiz4: shld eax, edx, 6
hoffs8: mov cl, byte ptr [eax+88888888h]
pal8: mov bl, byte ptr [ecx+88888888h]
	sub esi, _asm1
	sub edx, _asm2
	mov byte ptr [edi], bl
	dec edi
	dec ebp
	jnz begshorthline
endshorthline:
	pop ebp
	ret
*/


long hlineasm4(unsigned long eax, unsigned long ebx, unsigned long ecx,
               unsigned long edx, unsigned long esi, unsigned long edi)
{
    unsigned long ebp = eax + 1;
    unsigned __int64 eaxedx;

    if (ebp <= 8)
    {
        /* shorthline */
        while (ebp != 0)
        {