which is more readable , using invoke macro or calling a function like a high level language do ?

which is more readable , declaring variables with (DB , DW , and DD) or with a high level language do ?

which is more readable , using arguments inside the procedure with EBP indexed or with the normal name

which is more readable , this expretion mov EAX,5 or EAX = 5; ?

the point here is not the fast code to be generated by Sphinx C--,

Sphinx C-- allows you to mix asm low level code with C high level code , so you can make a code that
is more faster easlly by using directlly SSE instructions.

#define class struct

#ifdef __TLS__
#include <windows.h-->

:dword fastcall __new(EAX)
{
     return GlobalAlloc(GMEM_FIXED,EAX);
}

:dword fastcall __delete(EAX)
{
    IF(EAX)GlobalFree(EAX);
}

#endif

#ifdef __MSDOS__
#include "alloc.h--"

:word fastcall __new(AX)
{
     return MALLOC(AX);
}

:word fastcall __delete(AX)
{
       IF(AX)FREE(AX);
}

#endif
    

#pragma option w32c
#include "winbase.h--"
#include "class.h--"
#include "msvcrt.h--"
struct info {
   info(dword str);
    ~info();
    char buf[80];
};

info::info(dword str)
{
     IF(this){
              strcpy(#buf,str);
           printf("%s%s\n","Create class in ",#buf);
      }
      return this;
}

info::~info()
{
       printf("%s%s\n","Destroy class in ",#buf);
}

info ss;

int CheckClass()
{
info s1;
dword w1;
        w1 = new info("allocate memory");
 s1.info("stack memory");
  ss.info("programm memory");
       delete ss;
  delete w1 info;
}

void main()
{
      CheckClass();
}
    

Sphinx C-- can be ported. You just have to have different header files... much like c++.

when coding with asm , it is your responsibility to generate a fast or slowe code. the full control is in your hand.
consider the first Examole , which is faster in your opinion strlen1 procedure or strlen4 one ?

me239 wrote:

Sphinx C-- can be ported. You just have to have different header files... much like c++.

How would that help your 32bit x86 code running on x86-64, or ARM?

f0dder wrote:

me239 wrote:

Sphinx C-- can be ported. You just have to have different header files... much like c++.

How would that help your 32bit x86 code running on x86-64, or ARM?

Maybe you didn't understand what I meant by porting. What I meant is that you can code applications to run on DIFFERENT systems, not the compiler. So actually in that manner it is exact to C++.

And that doesn't help with regards to portability of your applications - at best you get a cross-compiler.

Um... I have no idea what you mean. An application is written for the platform it was designed to run on. C++ should work the same way. A compiled Windows application will not work on Mac OSX w/o emulation will it?

You'll never get 100% portability, and you aren't going to get major-platform portability without writing some OS-specific code (or targeting a REALLY low lowest-common-denominator).

But there's ways you can make large parts of your applications portable - writing OS- and CPU-specific code in your core parts is not the way to achieve that. If you're going to use a HLL, why use one that doesn't give you much advantage over assembly?

]Once again man, C++ when compiled works the EXACT SAME WAY AS ASSEMBLY. All code is eventually turned into assembly and with compiled C++ and assembly it's immediate. So unless you have a C++ interpreter running C++ code you will have 0% portability, so in the end the two really come out to the same product.

Then there's source portability, which is what C and C++ offers. Yes. you'll have to build your application for each platform, but if you can reuse, say 90% of your code... that's better than the 100% rewrite you'd need with assembly

// extracting Dx9 methods
GetComProc(EBX,ECX,EDI) 
{
  EBX = DSDWORD[EBX];
  FOR(EAX=0; EAX<EDI; EAX+=4)
   {  
      EDX = DSDWORD[EBX + EAX]; 
      DSDWORD[ECX + EAX] = EDX;
   }  
}

GetDX9Proc(EBX,ECX) 
{
  GetComProc(EBX,ECX,sizeof(IDirect3DDevice9));  
}


// Directx9 class stuff
struct DirectX9 : IDirect3DDevice9
{
   DWORD  InitD3D(dword hWnd);
   void   ReleaseD3D();
   void   _BiginScene(DWORD color);
   void   _EndScene();
     
   static DWORD  D3D; 
   static DWORD  D3DDevice;
   static D3DPRESENT_PARAMETERS d3dpp;
   static DWORD  HWnd;
   static long nScreenWidth = 512;
   static long nScreenHeight = 512;
   
   static char szLogFile[1024]={0};  
};

DWORD DirectX9::InitD3D(dword hWnd) 
{
    
    D3DDISPLAYMODE d3ddm;
    
    DWORD qualityLevels = 0;
    
    IF(hWnd==NULL)
     {
       HWnd = GetActiveWindow();
     }
    ELSE
     {
       HWnd = hWnd;
     } 
    
     D3D = Direct3DCreate9(D3D_SDK_VERSION);
     IF (D3D==0)
         return;
      
   EBX = D3D; EBX = DSDWORD[EBX];
      EBX.IDirect3D9.GetAdapterDisplayMode(D3D, D3DADAPTER_DEFAULT, #d3ddm );

 EAX=#d3dpp;
 RtlZeroMemory(EAX, sizeof(D3DPRESENT_PARAMETERS));
  d3dpp.Windowed=TRUE;
        d3dpp.BackBufferWidth        = nScreenWidth;
        d3dpp.BackBufferHeight       = nScreenHeight;
        d3dpp.BackBufferFormat       = d3ddm.Format;
        d3dpp.EnableAutoDepthStencil = TRUE;
        d3dpp.AutoDepthStencilFormat = D3DFMT_D16;
        d3dpp.BackBufferCount        = 1;
    d3dpp.MultiSampleType        = D3DMULTISAMPLE_NONE;
 d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
 
    EBX = D3D; EBX = DSDWORD[EBX];
      EBX.IDirect3D9.CheckDeviceMultiSampleType(D3D,D3DADAPTER_DEFAULT,D3DDEVTYPE_HAL,d3dpp.BackBufferFormat,FALSE,D3DMULTISAMPLE_2_SAMPLES,#qualityLevels);
        d3dpp.MultiSampleType    = D3DMULTISAMPLE_2_SAMPLES;
      d3dpp.MultiSampleQuality = qualityLevels-1; 
        d3dpp.SwapEffect         = D3DSWAPEFFECT_DISCARD; 
   
   EAX=#d3dpp;

     EBX = D3D; EBX = DSDWORD[EBX];
      EBX.IDirect3D9.CreateDevice(D3D, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd, D3DCREATE_SOFTWARE_VERTEXPROCESSING, EAX, #D3DDevice);

       IF  (EAX!=D3D_OK){
             XOR EAX, EAX
                RETURN;
            }

    GetDX9Proc(D3DDevice,this);  
}

void DirectX9::ReleaseD3D()
{
       
            IF(D3DDevice != 0) 
          {
                     EBX = D3DDevice; EBX = DSDWORD[EBX];
                        EBX.IDirect3DDevice9.Release(D3DDevice);
                    D3DDevice = 0;
               }
        
         IF(D3D != 0)
                 {
                     EBX = D3D; EBX = DSDWORD[EBX];
                      EBX.IDirect3D9.Release(D3D);
                        D3D = 0;
             }
}

void  DirectX9::_BiginScene(DWORD color)
{
             EBX = D3DDevice; EBX = DSDWORD[EBX];
         EBX.IDirect3DDevice9.Clear(D3DDevice, 0, 0, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, color, 1.0f, 0);
            EBX = D3DDevice; EBX = DSDWORD[EBX];
        EBX.IDirect3DDevice9.BeginScene(D3DDevice);
}

void  DirectX9::_EndScene()
{
             EBX = D3DDevice; EBX = DSDWORD[EBX];
             EBX.IDirect3DDevice9.EndScene(D3DDevice);
           EBX = D3DDevice; EBX = DSDWORD[EBX];
        EBX.IDirect3DDevice9.Present(D3DDevice,NULL, NULL, NULL, NULL);
}


    

Render()
{
    Dx9._BiginScene(RGBA_MAKE(0,0,255,255));
    
    Dx9.SetStreamSource(Dx9.D3DDevice, 0, D3DVB, 0, sizeof(CUSTOMVERTEX));

    Dx9.SetFVF(Dx9.D3DDevice, D3DFVF_XYZRHW | D3DFVF_DIFFUSE );

    Dx9.DrawPrimitive(Dx9.D3DDevice, D3DPT_TRIANGLELIST, 0, 1 );

    
    Dx9._EndScene();
    
}