开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 模拟服务器 > 查看源码
rad.h
资源名称：SwordOnline.rar　[点击查看]
上传用户：dzyhzl
上传日期：2019-04-29
资源大小：56270k
文件大小：24k
源码类别：

模拟服务器

开发平台：

C/C++

rad.h：源码内容
  1. #ifndef __RAD__
  2. #define __RAD__
  4. #define RADCOPYRIGHT "Copyright (C) 1994-99 RAD Game Tools, Inc."
  6. #ifndef __RADRES__
  8. //  __RADDOS__ means DOS code (16 or 32 bit)
  9. //  __RAD16__ means 16 bit code (Win16)
  10. //  __RAD32__ means 32 bit code (DOS, Win386, Win32s, Mac)
  11. //  __RADWIN__ means Windows code (Win16, Win386, Win32s)
  12. //  __RADWINEXT__ means Windows 386 extender (Win386)
  13. //  __RADNT__ means Win32s code
  14. //  __RADMAC__ means Macintosh
  15. //  __RAD68K__ means 68K Macintosh
  16. //  __RADPPC__ means PowerMac
  19. #if (defined(__MWERKS__) && !defined(__INTEL__)) || defined(THINK_C) || defined(powerc) || defined(macintosh) || defined(__powerc)
  21.   #define __RADMAC__
  22.   #if defined(powerc) || defined(__powerc)
  23.     #define __RADPPC__
  24.   #else
  25.     #define __RAD68K__
  26.   #endif
  28.   #define __RAD32__
  30. #else
  32.   #ifdef __MWERKS__
  33.     #define _WIN32
  34.   #endif
  36.   #ifdef __DOS__
  37.     #define __RADDOS__
  38.   #endif
  40.   #ifdef __386__
  41.     #define __RAD32__
  42.   #endif
  44.   #ifdef _Windows    //For Borland
  45.     #ifdef __WIN32__
  46.       #define WIN32
  47.     #else
  48.       #define __WINDOWS__
  49.     #endif
  50.   #endif
  52.   #ifdef _WINDOWS    //For MS
  53.     #ifndef _WIN32
  54.       #define __WINDOWS__
  55.     #endif
  56.   #endif
  58.   #ifdef _WIN32
  59.     #define __RADWIN__
  60.     #define __RADNT__
  61.     #define __RAD32__
  62.   #else
  63.     #ifdef __NT__
  64.       #define __RADWIN__
  65.       #define __RADNT__
  66.       #define __RAD32__
  67.     #else
  68.       #ifdef __WINDOWS_386__
  69.         #define __RADWIN__
  70.         #define __RADWINEXT__
  71.         #define __RAD32__
  72.       #else
  73.         #ifdef __WINDOWS__
  74.           #define __RADWIN__
  75.           #define __RAD16__
  76.         #else
  77.           #ifdef WIN32
  78.             #define __RADWIN__
  79.             #define __RADNT__
  80.             #define __RAD32__
  81.           #endif
  82.         #endif
  83.       #endif
  84.     #endif
  85.   #endif
  87. #endif
  89. #if (!defined(__RADDOS__) && !defined(__RADWIN__) && !defined(__RADMAC__))
  90.   #error RAD.H did not detect your platform.  Define __DOS__, __WINDOWS__, WIN32, macintosh, or powerc.
  91. #endif
  93. #ifdef __RADMAC__
  95.   // this define is for CodeWarrior 11's stupid new libs (even though
  96.   //   we don't use longlong's).
  98.   #define __MSL_LONGLONG_SUPPORT__
  100.   #define RADLINK
  101.   #define RADEXPLINK
  103.   #ifdef __CFM68K__
  104.     #ifdef __RADINDLL__
  105.       #define RADEXPFUNC RADDEFFUNC __declspec(export)
  106.     #else
  107.       #define RADEXPFUNC RADDEFFUNC __declspec(import)
  108.     #endif
  109.   #else
  110.     #define RADEXPFUNC RADDEFFUNC
  111.   #endif
  112.   #define RADASMLINK
  114. #else
  116.   #ifdef __RADNT__
  117.     #ifndef _WIN32
  118.       #define _WIN32
  119.     #endif
  120.     #ifndef WIN32
  121.       #define WIN32
  122.     #endif
  123.   #endif
  125.   #ifdef __RADWIN__
  126.     #ifdef __RAD32__
  127.       #ifdef __RADNT__
  129.         #define RADLINK __stdcall
  130.         #define RADEXPLINK __stdcall
  132.         #ifdef __RADINEXE__
  133.           #define RADEXPFUNC RADDEFFUNC
  134.         #else
  135.           #ifndef __RADINDLL__
  136.             #define RADEXPFUNC RADDEFFUNC __declspec(dllimport)
  137.             #ifdef __BORLANDC__
  138.               #if __BORLANDC__<=0x460
  139.                 #undef RADEXPFUNC
  140.                 #define RADEXPFUNC RADDEFFUNC
  141.               #endif
  142.             #endif
  143.           #else
  144.             #define RADEXPFUNC RADDEFFUNC __declspec(dllexport)
  145.           #endif
  146.         #endif
  147.       #else
  148.         #define RADLINK __pascal
  149.         #define RADEXPLINK __far __pascal
  150.         #define RADEXPFUNC RADDEFFUNC
  151.       #endif
  152.     #else
  153.       #define RADLINK __pascal
  154.       #define RADEXPLINK __far __pascal __export
  155.       #define RADEXPFUNC RADDEFFUNC
  156.     #endif
  157.   #else
  158.     #define RADLINK __pascal
  159.     #define RADEXPLINK __pascal
  160.     #define RADEXPFUNC RADDEFFUNC
  161.   #endif
  163.   #define RADASMLINK __cdecl
  165. #endif
  167. #ifdef __RADWIN__
  168.   #ifndef _WINDOWS
  169.     #define _WINDOWS
  170.   #endif
  171. #endif
  173. #ifdef __cplusplus
  174.   #define RADDEFFUNC extern "C"
  175.   #define RADDEFSTART extern "C" {
  176.   #define RADDEFEND }
  177. #else
  178.   #define RADDEFFUNC
  179.   #define RADDEFSTART
  180.   #define RADDEFEND
  181. #endif
  184. RADDEFSTART
  186. #define s8 signed char
  187. #define u8 unsigned char
  188. #define u32 unsigned long
  189. #define s32 signed long
  190. #define u64 unsigned __int64
  191. #define s64 signed __int64
  192. #define f32 float
  193. #define f64 double
  196. #ifdef __RAD32__
  197.   #define PTR4
  199.   #define u16 unsigned short
  200.   #define s16 signed short
  202.   #ifdef __RADMAC__
  204.     #include <string.h>
  205.     #include <memory.h>
  206.     #include <OSUtils.h>
  208.     #define radstrlen strlen
  210.     #define radmemset memset
  212.     #define radmemcmp memcmp
  214.     #define radmemcpy(dest,source,size) BlockMoveData((Ptr)(source),(Ptr)(dest),size)
  216.     #define radmemcpydb(dest,source,size) BlockMoveData((Ptr)(source),(Ptr)(dest),size)
  218.     #define radstrcat strcat
  220.     #define radstrcpy strcpy
  222.     static u32 inline radsqr(s32 a) {  return(a*a);  }
  223.    
  224.     #ifdef __RAD68K__
  226.       #pragma parameter __D0 mult64anddiv(__D0,__D1,__D2)
  227.       u32 mult64anddiv(u32 m1,u32 m2,u32 d) ={0x4C01,0x0C01,0x4C42,0x0C01};
  228.       //  muls.l d1,d1:d0  divs.l d2,d1:d0
  229.                
  230.       #pragma parameter radconv32a(__A0,__D0)
  231.       void radconv32a(void* p,u32 n) ={0x4A80,0x600C,0x2210,0xE059,0x4841,0xE059,0x20C1,0x5380,0x6EF2};
  232.       // tst.l d0  bra.s @loope  @loop:  move.l (a0),d1  ror.w #8,d1  swap d1 ror.w #8,d1  move.l d1,(a0)+  sub.l #1,d0  bgt.s @loop  @loope:
  233.       
  234.     #else
  236.       u32 mult64anddiv(u32 m1,u32 m2,u32 d);
  238.       void radconv32a(void* p,u32 n);
  240.     #endif
  242.   #else
  244.     #ifdef __WATCOMC__
  246.       u32 radsqr(s32 a);
  247.       #pragma aux radsqr = "mul eax" parm [eax] modify [EDX eax];
  249.       u32 mult64anddiv(u32 m1,u32 m2,u32 d);
  250.       #pragma aux mult64anddiv = "mul ecx" "div ebx" parm [eax] [ecx] [ebx] modify [EDX eax];
  252.       s32 radabs(s32 ab);
  253.       #pragma aux radabs = "test eax,eax" "jge skip" "neg eax" "skip:" parm [eax];
  255.       #define radabs32 radabs
  257.       u32 DOSOut(const char* str);
  258.       #pragma aux DOSOut = "cld" "mov ecx,0xffffffff" "xor eax,eax" "mov edx,edi" "repne scasb" "not ecx" "dec ecx" "mov ebx,1" "mov ah,0x40" "int 0x21" parm [EDI] modify [EAX EBX ECX EDX EDI] value [ecx];
  259.     
  260.       void DOSOutNum(const char* str,u32 len);
  261.       #pragma aux DOSOutNum = "mov ah,0x40" "mov ebx,1" "int 0x21" parm [edx] [ecx] modify [eax ebx];
  263.       u32 ErrOut(const char* str);
  264.       #pragma aux ErrOut = "cld" "mov ecx,0xffffffff" "xor eax,eax" "mov edx,edi" "repne scasb" "not ecx" "dec ecx" "xor ebx,ebx" "mov ah,0x40" "int 0x21" parm [EDI] modify [EAX EBX ECX EDX EDI] value [ecx];
  265.     
  266.       void ErrOutNum(const char* str,u32 len);
  267.       #pragma aux ErrOutNum = "mov ah,0x40" "xor ebx,ebx" "int 0x21" parm [edx] [ecx] modify [eax ebx];
  269.       void radmemset16(void* dest,u16 value,u32 size);
  270.       #pragma aux radmemset16 = "cld" "mov bx,ax" "shl eax,16" "mov ax,bx" "mov bl,cl" "shr ecx,1" "rep stosd" "mov cl,bl" "and cl,1" "rep stosw" parm [EDI] [EAX] [ECX] modify [EAX EDX EBX ECX EDI];
  271.     
  272.       void radmemset(void* dest,u8 value,u32 size);
  273.       #pragma aux radmemset = "cld" "mov ah,al" "mov bx,ax" "shl eax,16" "mov ax,bx" "mov bl,cl" "shr ecx,2" "and bl,3" "rep stosd" "mov cl,bl" "rep stosb" parm [EDI] [AL] [ECX] modify [EAX EDX EBX ECX EDI];
  275.       void radmemset32(void* dest,u32 value,u32 size);
  276.       #pragma aux radmemset32 = "cld" "rep stosd" parm [EDI] [EAX] [ECX] modify [EAX EDX EBX ECX EDI];
  278.       void radmemcpy(void* dest,const void* source,u32 size);
  279.       #pragma aux radmemcpy = "cld" "mov bl,cl" "shr ecx,2" "rep movsd" "mov cl,bl" "and cl,3" "rep movsb" parm [EDI] [ESI] [ECX] modify [EBX ECX EDI ESI];
  281.       void __far *radfmemcpy(void __far* dest,const void __far* source,u32 size);
  282.       #pragma aux radfmemcpy = "cld" "push es" "push ds" "mov es,cx" "mov ds,dx" "mov ecx,eax" "shr ecx,2" "rep movsd" "mov cl,al" "and cl,3" "rep movsb" "pop ds" "pop es" parm [CX EDI] [DX ESI] [EAX] modify [ECX EDI ESI] value [CX EDI];
  284.       void radmemcpydb(void* dest,const void* source,u32 size);  //Destination bigger
  285.       #pragma aux radmemcpydb = "std" "mov bl,cl" "lea esi,[esi+ecx-4]" "lea edi,[edi+ecx-4]" "shr ecx,2" "rep movsd" "and bl,3" "jz dne" "add esi,3" "add edi,3" "mov cl,bl" "rep movsb" "dne:" "cld" parm [EDI] [ESI] [ECX] modify [EBX ECX EDI ESI];
  287.       char* radstrcpy(void* dest,const void* source);
  288.       #pragma aux radstrcpy = "cld" "mov edx,edi" "lp:" "mov al,[esi]" "inc esi" "mov [edi],al" "inc edi" "cmp al,0" "jne lp" parm [EDI] [ESI] modify [EAX EDX EDI ESI] value [EDX];
  290.       char __far* radfstrcpy(void __far* dest,const void __far* source);
  291.       #pragma aux radfstrcpy = "cld" "push es" "push ds" "mov es,cx" "mov ds,dx" "mov edx,edi" "lp:" "lodsb" "stosb" "test al,0xff" "jnz lp" "pop ds" "pop es" parm [CX EDI] [DX ESI] modify [EAX EDX EDI ESI] value [CX EDX];
  293.       char* radstpcpy(void* dest,const void* source);
  294.       #pragma aux radstpcpy = "cld" "lp:" "mov al,[esi]" "inc esi" "mov [edi],al" "inc edi" "cmp al,0" "jne lp" "dec edi" parm [EDI] [ESI] modify [EAX EDI ESI] value [EDI];
  296.       char* radstpcpyrs(void* dest,const void* source);
  297.       #pragma aux radstpcpyrs = "cld" "lp:" "mov al,[esi]" "inc esi" "mov [edi],al" "inc edi" "cmp al,0" "jne lp" "dec esi" parm [EDI] [ESI] modify [EAX EDI ESI] value [ESI];
  299.       u32 radstrlen(const void* dest);
  300.       #pragma aux radstrlen = "cld" "mov ecx,0xffffffff" "xor eax,eax" "repne scasb" "not ecx" "dec ecx" parm [EDI] modify [EAX ECX EDI] value [ECX];
  301.     
  302.       char* radstrcat(void* dest,const void* source);
  303.       #pragma aux radstrcat = "cld" "mov ecx,0xffffffff" "mov edx,edi" "xor eax,eax" "repne scasb" "dec edi" "lp:" "lodsb" "stosb" "test al,0xff" "jnz lp" 
  304.       parm [EDI] [ESI] modify [EAX ECX EDI ESI] value [EDX];
  306.       char* radstrchr(const void* dest,char chr);
  307.       #pragma aux radstrchr = "cld" "lp:" "lodsb" "cmp al,dl" "je fnd" "cmp al,0" "jnz lp" "mov esi,1" "fnd:" "dec esi" parm [ESI] [DL] modify [EAX ESI] value [esi];
  309.       s8 radmemcmp(const void* s1,const void* s2,u32 len);
  310.       #pragma aux radmemcmp = "cld" "rep cmpsb" "setne al" "jbe end" "neg al" "end:"  parm [EDI] [ESI] [ECX] modify [ECX EDI ESI];
  312.       s8 radstrcmp(const void* s1,const void* s2);
  313.       #pragma aux radstrcmp = "lp:" "mov al,[esi]" "mov ah,[edi]" "cmp al,ah" "jne set" "cmp al,0" "je set" "inc esi" "inc edi" "jmp lp" "set:" "setne al" "jbe end" "neg al" "end:" 
  314.       parm [EDI] [ESI] modify [EAX EDI ESI];
  316.       s8 radstricmp(const void* s1,const void* s2);                                                                       
  317.       #pragma aux radstricmp = "lp:" "mov al,[esi]" "mov ah,[edi]" "cmp al,'a'" "jb c1" "cmp al,'z'" "ja c1" "sub al,32" "c1:" "cmp ah,'a'" "jb c2" "cmp ah,'z'" "ja c2" "sub ah,32" "c2:" "cmp al,ah" "jne set" "cmp al,0" "je set" 
  318.      "inc esi" "inc edi" "jmp lp" "set:" "setne al" "jbe end" "neg al" "end:" 
  319.       parm [EDI] [ESI] modify [EAX EDI ESI];
  321.       s8 radstrnicmp(const void* s1,const void* s2,u32 len);
  322.       #pragma aux radstrnicmp = "lp:" "mov al,[esi]" "mov ah,[edi]" "cmp al,'a'" "jb c1" "cmp al,'z'" "ja c1" "sub al,32" "c1:" "cmp ah,'a'" "jb c2" "cmp ah,'z'" "ja c2" "sub ah,32" "c2:" "cmp al,ah" "jne set" "cmp al,0" "je set" 
  323.       "dec ecx" "jz set" "inc esi" "inc edi" "jmp lp" "set:" "setne al" "jbe end" "neg al" "end:" 
  324.       parm [EDI] [ESI] [ECX] modify [EAX ECX EDI ESI];
  326.       char* radstrupr(void* s1);
  327.       #pragma aux radstrupr = "mov ecx,edi" "lp:" "mov al,[edi]" "cmp al,'a'" "jb c1" "cmp al,'z'" "ja c1" "sub [edi],32" "c1:" "inc edi" "cmp al,0" "jne lp" parm [EDI] modify [EAX EDI] value [ecx];
  329.       char* radstrlwr(void* s1);
  330.       #pragma aux radstrlwr = "mov ecx,edi" "lp:" "mov al,[edi]" "cmp al,'A'" "jb c1" "cmp al,'Z'" "ja c1" "add [edi],32" "c1:" "inc edi" "cmp al,0" "jne lp" parm [EDI] modify [EAX EDI] value [ecx];
  332.       u32 radstru32(const void* dest);
  333.         #pragma aux radstru32 = "cld" "xor ecx,ecx" "xor ebx,ebx" "xor edi,edi" "lodsb" "cmp al,45" "jne skip2" "mov edi,1" "jmp skip" "lp:" "mov eax,10" "mul ecx" "lea ecx,[eax+ebx]" 
  334.         "skip:" "lodsb" "skip2:" "cmp al,0x39" "ja dne" "cmp al,0x30" "jb dne" "mov bl,al" "sub bl,0x30" "jmp lp" "dne:" "test edi,1" "jz pos" "neg ecx" "pos:" 
  335.         parm [ESI] modify [EAX EBX EDX EDI ESI] value [ecx];
  336.                                                              
  337.       u16 GetDS();
  338.       #pragma aux GetDS = "mov ax,ds" value [ax];
  340.       #ifdef __RADWINEXT__
  341.     
  342.         #define _16To32(ptr16) ((void*)(((GetSelectorBase((u16)(((u32)(ptr16))>>16))+((u16)(u32)(ptr16)))-GetSelectorBase(GetDS()))))
  344.       #endif
  346.       #ifndef __RADWIN__
  347.         #define int86 int386
  348.         #define int86x int386x
  349.       #endif
  350.     
  351.       #define u32regs x
  352.       #define u16regs w
  353.     
  354.     #else
  356.       #define radstrcpy strcpy
  357.       #define radstrcat strcat
  358.       #define radmemcpy memcpy
  359.       #define radmemcpydb memmove
  360.       #define radmemcmp memcmp
  361.       #define radmemset memset
  362.       #define radstrlen strlen
  363.       #define radstrchr strchr
  364.       #define radtoupper toupper
  365.       #define radstru32(s) ((u32)atol(s))
  366.       #define radstricmp _stricmp
  367.       #define radstrcmp strcmp
  368.       #define radstrupr _strupr
  369.       #define radstrlwr _strlwr
  370.       #define BreakPoint() __asm {int 3}
  372.       #ifdef _MSC_VER
  374.         #pragma warning( disable : 4035)
  376.         typedef char* RADPCHAR;
  378.         u32 __inline radsqr(u32 m) {
  379.           __asm {
  380.             mov eax,[m]
  381.             mul eax
  382.           }
  383.         }
  385.         u32 __inline mult64anddiv(u32 m1,u32 m2, u32 d) {
  386.           __asm {
  387.             mov eax,[m1]
  388.             mov ecx,[m2]
  389.             mul ecx
  390.             mov ecx,[d]
  391.             div ecx
  392.           }
  393.         }
  395.         s32 __inline radabs(s32 ab) {
  396.           __asm {
  397.             mov eax,[ab]
  398.             test eax,eax
  399.             jge skip
  400.             neg eax
  401.            skip:
  402.           }
  403.         }
  405.         u8 __inline radinp(u16 p) {
  406.           __asm {
  407.             mov dx,[p] 
  408.             in al,dx 
  409.           } 
  410.         }
  412.         void __inline radoutp(u16 p,u8 v) {
  413.           __asm {
  414.             mov dx,[p] 
  415.             mov al,[v]
  416.             out dx,al 
  417.           }
  418.         }
  420.         RADPCHAR __inline radstpcpy(char* p1, char* p2) { 
  421.           __asm {
  422.              mov edx,[p1] 
  423.              mov ecx,[p2]
  424.              cld
  425.             lp:
  426.              mov al,[ecx] 
  427.              inc ecx 
  428.              mov [edx],al 
  429.              inc edx
  430.              cmp al,0 
  431.              jne lp 
  432.              dec edx 
  433.              mov eax,edx 
  434.           } 
  435.         }
  436.         
  437.         RADPCHAR __inline radstpcpyrs(char* p1, char* p2) { 
  438.           __asm {
  439.             mov edx,[p1]
  440.             mov ecx,[p2]
  441.             cld
  442.            lp:
  443.             mov al,[ecx]
  444.             inc ecx
  445.             mov [edx],al
  446.             inc edx
  447.             cmp al,0 
  448.             jne lp
  449.             dec ecx
  450.             mov eax,ecx 
  451.           } 
  452.         }
  454.         void __inline radmemset16(void* dest,u16 value,u32 sizeb) {
  455.           __asm {
  456.             mov edi,[dest] 
  457.             mov ax,[value] 
  458.             mov ecx,[sizeb]
  459.             shl eax,16 
  460.             cld 
  461.             mov ax,[value] 
  462.             mov bl,cl 
  463.             shr ecx,1 
  464.             rep stosd
  465.             mov cl,bl 
  466.             and cl,1 
  467.             rep stosw
  468.           }
  469.         }
  471.         void __inline radmemset32(void* dest,u32 value,u32 sizeb) {
  472.           __asm {
  473.             mov edi,[dest]
  474.             mov eax,[value]
  475.             mov ecx,[sizeb]
  476.             cld
  477.             rep stosd
  478.           }
  479.         }
  481.         u32 __inline __stdcall RADsqrt(u32 sq) {
  482.           __asm {
  483.             fild dword ptr [sq]
  484.             fsqrt
  485.             fistp word ptr [sq]
  486.             movzx eax,word ptr [sq]
  487.           }
  488.         }
  490.         void __inline RADCycleTimerStartAddr(u32* addr)
  491.         {
  492.           __asm {
  493.             mov ecx,[addr]
  494. #ifdef __MWERKS__
  495.             rdtsc
  496. #else
  497. #if _MSC_VER<=1100
  498.             __emit 0xf
  499.             __emit 0x31
  500. #else
  501.             rdtsc
  502. #endif
  503. #endif
  504.             mov [ecx],eax
  505.           }
  506.         }
  508.         u32 __inline RADCycleTimerDeltaAddr(u32* addr)
  509.         {
  510.           __asm {
  511. #ifdef __MWERKS__
  512.             rdtsc
  513. #else
  514. #if _MSC_VER<=1100
  515.             __emit 0xf
  516.             __emit 0x31
  517. #else
  518.             rdtsc
  519. #endif
  520. #endif
  521.             mov ecx,[addr]
  522.             sub eax,[ecx]
  523.             mov [ecx],eax
  524.           }
  525.         }
  527.         #define RADCycleTimerStart(var) RADCycleTimerStartAddr(&var)
  528.         #define RADCycleTimerDelta(var) RADCycleTimerDeltaAddr(&var)
  530.         #pragma warning( default : 4035)
  532.       #endif
  534.     #endif
  536.   #endif
  538. #else
  540.   #define PTR4 __far
  542.   #define u16 unsigned int
  543.   #define s16 signed int
  545.   #ifdef __WATCOMC__
  547.     u32 radsqr(s32 a);
  548.     #pragma aux radsqr = "shl edx,16" "mov dx,ax" "mov eax,edx" "xor edx,edx" "mul eax" "shld edx,eax,16" parm [dx ax] modify [DX ax] value [dx ax];
  550.     s16 radabs(s16 ab);
  551.     #pragma aux radabs = "test ax,ax" "jge skip" "neg ax" "skip:" parm [ax] value [ax];
  553.     s32 radabs32(s32 ab);
  554.     #pragma aux radabs32 = "test dx,dx" "jge skip" "neg dx" "neg ax" "sbb dx,0" "skip:" parm [dx ax] value [dx ax];
  555.     
  556.     u32 DOSOut(const char far* dest);
  557.     #pragma aux DOSOut = "cld" "and edi,0xffff" "mov dx,di" "mov ecx,0xffffffff" "xor eax,eax" 0x67 "repne scasb" "not ecx" "dec ecx" "mov bx,1" "push ds" "push es" "pop ds" "mov ah,0x40" "int 0x21" "pop ds" "movzx eax,cx" "shr ecx,16" 
  558.        parm [ES DI] modify [AX BX CX DX DI ES] value [CX AX];
  559.     
  560.     void DOSOutNum(const char far* str,u16 len);
  561.     #pragma aux DOSOutNum = "push ds" "mov ds,cx" "mov cx,bx" "mov ah,0x40" "mov bx,1" "int 0x21" "pop ds" parm [cx dx] [bx] modify [ax bx cx];
  563.     u32 ErrOut(const char far* dest);
  564.     #pragma aux ErrOut = "cld" "and edi,0xffff" "mov dx,di" "mov ecx,0xffffffff" "xor eax,eax" 0x67 "repne scasb" "not ecx" "dec ecx" "xor bx,bx" "push ds" "push es" "pop ds" "mov ah,0x40" "int 0x21" "pop ds" "movzx eax,cx" "shr ecx,16" 
  565.        parm [ES DI] modify [AX BX CX DX DI ES] value [CX AX];
  567.     void ErrOutNum(const char far* str,u16 len);
  568.     #pragma aux ErrOutNum = "push ds" "mov ds,cx" "mov cx,bx" "mov ah,0x40" "xor bx,bx" "int 0x21" "pop ds" parm [cx dx] [bx] modify [ax bx cx];
  570.     void radmemset(void far *dest,u8 value,u32 size);
  571.     #pragma aux radmemset = "cld" "and edi,0ffffh" "shl ecx,16" "mov cx,bx" "mov ah,al" "mov bx,ax" "shl eax,16" "mov ax,bx" "mov bl,cl" "shr ecx,2" 0x67 "rep stosd" "mov cl,bl" "and cl,3" "rep stosb" parm [ES DI] [AL] [CX BX];
  573.     void radmemset16(void far* dest,u16 value,u32 size);
  574.     #pragma aux radmemset16 = "cld" "and edi,0ffffh" "shl ecx,16" "mov cx,bx" "mov bx,ax" "shl eax,16" "mov ax,bx" "mov bl,cl" "shr ecx,1" "rep stosd" "mov cl,bl" "and cl,1" "rep stosw" parm [ES DI] [AX] [CX BX];
  576.     void radmemcpy(void far* dest,const void far* source,u32 size);
  577.     #pragma aux radmemcpy = "cld" "push ds" "mov ds,dx" "and esi,0ffffh" "and edi,0ffffh" "shl ecx,16" "mov cx,bx" "shr ecx,2" 0x67 "rep movsd" "mov cl,bl" "and cl,3" "rep movsb" "pop ds" parm [ES DI] [DX SI] [CX BX] modify [CX SI DI ES];
  579.     s8 radmemcmp(const void far* s1,const void far* s2,u32 len);
  580.     #pragma aux radmemcmp = "cld" "push ds" "mov ds,dx" "shl ecx,16" "mov cx,bx" "rep cmpsb" "setne al" "jbe end" "neg al" "end:" "pop ds"  parm [ES DI] [DX SI] [CX BX] modify [CX SI DI ES];
  582.     char far* radstrcpy(void far* dest,const void far* source);
  583.     #pragma aux radstrcpy = "cld" "push ds" "mov ds,dx" "and esi,0xffff" "and edi,0xffff" "mov dx,di" "lp:" "lodsb" "stosb" "test al,0xff" "jnz lp" "pop ds" parm [ES DI] [DX SI] modify [AX DX DI SI ES] value [es dx];
  585.     char far* radstpcpy(void far* dest,const void far* source);
  586.     #pragma aux radstpcpy = "cld" "push ds" "mov ds,dx" "and esi,0xffff" "and edi,0xffff" "lp:" "lodsb" "stosb" "test al,0xff" "jnz lp" "dec di" "pop ds" parm [ES DI] [DX SI] modify [DI SI ES] value [es di];
  588.     u32 radstrlen(const void far* dest);
  589.     #pragma aux radstrlen = "cld" "and edi,0xffff" "mov ecx,0xffffffff" "xor eax,eax" 0x67 "repne scasb" "not ecx" "dec ecx" "movzx eax,cx" "shr ecx,16" parm [ES DI] modify [AX CX DI ES] value [CX AX];
  590.     
  591.     char far* radstrcat(void far* dest,const void far* source);
  592.     #pragma aux radstrcat = "cld" "and edi,0xffff" "mov ecx,0xffffffff" "and esi,0xffff" "push ds" "mov ds,dx" "mov dx,di" "xor eax,eax" 0x67 "repne scasb" "dec edi" "lp:" "lodsb" "stosb" "test al,0xff" "jnz lp" "pop ds" 
  593.       parm [ES DI] [DX SI] modify [AX CX DI SI ES] value [es dx];
  594.     
  595.     char far* radstrchr(const void far* dest,char chr);
  596.     #pragma aux radstrchr = "cld" "lp:" 0x26 "lodsb" "cmp al,dl" "je fnd" "cmp al,0" "jnz lp" "xor ax,ax" "mov es,ax" "mov si,1" "fnd:" "dec si" parm [ES SI] [DL] modify [AX SI ES] value [es si];
  598.     s8 radstricmp(const void far* s1,const void far* s2);                                                                       
  599.     #pragma aux radstricmp = "and edi,0xffff" "push ds" "mov ds,dx" "and esi,0xffff" "lp:" "mov al,[esi]" "mov ah,[edi]" "cmp al,'a'" "jb c1" "cmp al,'z'" "ja c1" "sub al,32" "c1:" 
  600.       "cmp ah,'a'" "jb c2" "cmp ah,'z'" "ja c2" "sub ah,32" "c2:" "cmp al,ah" "jne set" "cmp al,0" "je set" 
  601.       "inc esi" "inc edi" "jmp lp" "set:" "setne al" "jbe end" "neg al" "end:" "pop ds" 
  602.       parm [ES DI] [DX SI] modify [AX DI SI];
  604.     u32 radstru32(const void far* dest);
  605.     #pragma aux radstru32 = "cld" "xor ecx,ecx" "xor ebx,ebx" "xor edi,edi" 0x26 "lodsb" "cmp al,45" "jne skip2" "mov edi,1" "jmp skip" "lp:" "mov eax,10" "mul ecx" "lea ecx,[eax+ebx]" 
  606.       "skip:" 0x26 "lodsb" "skip2:" "cmp al,0x39" "ja dne" "cmp al,0x30" "jb dne" "mov bl,al" "sub bl,0x30" "jmp lp" "dne:" "test edi,1" "jz pos" "neg ecx" "pos:" 
  607.       "movzx eax,cx" "shr ecx,16" parm [ES SI] modify [AX BX DX DI SI] value [cx ax];
  609.     u32 mult64anddiv(u32 m1,u32 m2,u32 d);
  610.     #pragma aux mult64anddiv = "shl ecx,16" "mov cx,ax" "shrd eax,edx,16" "mov ax,si" "mul ecx" "shl edi,16" "mov di,bx" "div edi" "shld edx,eax,16" "and edx,0xffff" "and eax,0xffff" parm [cx ax] [dx si] [di bx] 
  611.       modify [ax bx cx dx si di] value [dx ax];
  613.   #endif
  615. #endif
  617. RADDEFEND
  619. #define u32neg1 ((u32)(s32)-1)
  620. #define RAD_align(var) var; u8 junk##var[4-(sizeof(var)&3)];
  621. #define RAD_align_after(var) u8 junk##var[4-(sizeof(var)&3)]={0};
  622. #define RAD_align_init(var,val) var=val; u8 junk##var[4-(sizeof(var)&3)]={0};
  623. #define RAD_align_array(var,num) var[num]; u8 junk##var[4-(sizeof(var)&3)];
  624. #define RAD_align_string(var,str) char var[]=str; u8 junk##var[4-(sizeof(var)&3)]={0};
  627. RADEXPFUNC void PTR4* RADEXPLINK radmalloc(u32 numbytes);
  628. RADEXPFUNC void RADEXPLINK radfree(void PTR4* ptr);
  631. #ifdef __WATCOMC__
  633.   char bkbhit();
  634.   #pragma aux bkbhit = "mov ah,1" "int 0x16" "lahf" "shr eax,14" "and eax,1" "xor al,1" ;
  636.   char bgetch();
  637.   #pragma aux bgetch = "xor ah,ah" "int 0x16" "test al,0xff" "jnz done" "mov al,ah" "or al,0x80" "done:" modify [AX];
  639.   void BreakPoint();
  640.   #pragma aux BreakPoint = "int 3";
  642.   u8 radinp(u16 p);
  643.   #pragma aux radinp = "in al,dx" parm [DX];
  645.   u8 radtoupper(u8 p);
  646.   #pragma aux radtoupper = "cmp al,'a'" "jb c1" "cmp al,'z'" "ja c1" "sub al,32" "c1:" parm [al] value [al];
  648.   void radoutp(u16 p,u8 v);
  649.   #pragma aux radoutp = "out dx,al" parm [DX] [AL];
  651. #else
  653. // for multi-processor machines
  655. #ifdef __RADNT__
  656.   #define LockedIncrement(var) __asm { lock inc [var] }
  657.   #define LockedDecrement(var) __asm { lock dec [var] }
  658.   void __inline LockedIncrementFunc(void PTR4* var) { 
  659.     __asm {
  660.       mov eax,[var]
  661.       lock inc [eax]
  662.     }
  663.   }
  665.   void __inline LockedDecrementFunc(void PTR4* var) {
  666.     __asm {
  667.        mov eax,[var]
  668.        lock dec [eax]
  669.     }
  670.   }
  672. #else
  673.   
  674.   #ifdef __RADMAC__
  676.     #define LockedIncrement(var) {++(var);}
  677.     #define LockedDecrement(var) {--(var);}
  679.     #define LockedIncrementFunc(ptr) {++(*((u32*)(var)));}
  680.     #define LockedDecrementFunc(ptr) {--(*((u32*)(var)));}
  682.   #else
  684.     #define LockedIncrement(var) __asm { inc [var] }
  685.     #define LockedDecrement(var) __asm { dec [var] }
  686.     void __inline LockedIncrementFunc(void PTR4* var) { __asm { mov eax,[var]
  687.                                                                 inc [eax] } }
  688.     void __inline LockedDecrementFunc(void PTR4* var) { __asm { mov eax,[var]
  689.                                                                 dec [eax] } }
  690.   #endif
  692. #endif
  694. #endif
  696. #endif
  698. #endif