Assembly-> Gui?

Is there any way to link an application programmed in TASM ASSEMBLY to a windows form application o开发者_Python百科r any kind of GUI?

Thanks

Developing of GUI applications in assembly language worths!

You can create GUI applications in assembly for Windows, for Linux or for any other OS with graphical user interface.

You can create them even with TASM, although I am not sure how exactly this have to be done. Notice, that you will need version of TASM that supports 32bit/64bit protected mode instructions and also a linker that can link the object files produced by TASM into PE executable files (the executable format for Windows).

So, if you are not bound to TASM, there are much easier alternatives. Since the beginning of the 2000-th there are people actively programming in assembly for Windows and other 32bit platforms. The assemblers of choice are FASM, NASM and MASM32.

The first - FASM - is my favorite, because:

1. It can compile directly to executable files. Using linker is optional, only if you really need it.

2. The syntax of FASM is affected by TASM IDEAL mode syntax.

3. Compiles very fast, even huge projects - 500K loc source is compiled for 2..3 seconds.

4. Has very powerful macro preprocessor that makes things easy for the complex projects.

5. Supports programming for several OSes.

6. It is written in FASM and is self-compilable and self-sufficient. Because of that, FASM is very easy portable on new platforms is compiler of choice for OS developers. For example KolibriOS is fully written in assembly language and use FASM as an assembler.

7. FASM has very active and friendly community. It is in active development and every bug found disappears for hours.

GUI applications, written in assembly tend to be very small in size, with very responsive interface, fast and resource friendly.

As an example of such an application I can point you to my project Fresh IDE - it is an advanced Visual RAD IDE for FASM programming. It is very feature-rich, but the size of the executable is only 250kB.

At the end two code examples:

1. Very simple "Hello world" example using advanced FASM macro system:

   include 'win32ax.inc' 
   
   .code
     start:
           invoke  MessageBox,HWND_DESKTOP,"Hellow world!", "Hello!", MB_OK
           invoke  ExitProcess,0
   
   .end start
   

2. More complex template application with main window:

   ; Template for program using standard Win32 headers
   
   format PE GUI 4.0
   entry start
   
   include 'win32w.inc'
   
   section '.text' code readable executable
   
     start:
   
           invoke  GetModuleHandle,0
           mov     [wc.hInstance],eax
           invoke  LoadIcon,0,IDI_APPLICATION
           mov     [wc.hIcon],eax
           invoke  LoadCursor,0,IDC_ARROW
           mov     [wc.hCursor],eax
           invoke  RegisterClass,wc
           test    eax,eax
           jz      error
   
           invoke  CreateWindowEx,0,_class,_title,WS_VISIBLE+WS_DLGFRAME+WS_SYSMENU,128,128,256,192,NULL,NULL,[wc.hInstance],NULL
           test    eax,eax
           jz      error
   
     msg_loop:
           invoke  GetMessage,msg,NULL,0,0
           cmp     eax,1
           jb      end_loop
           jne     msg_loop
           invoke  TranslateMessage,msg
           invoke  DispatchMessage,msg
           jmp     msg_loop
   
     error:
           invoke  MessageBox,NULL,_error,NULL,MB_ICONERROR+MB_OK
   
     end_loop:
           invoke  ExitProcess,[msg.wParam]
   
   proc WindowProc uses ebx esi edi, hwnd,wmsg,wparam,lparam
           cmp     [wmsg],WM_DESTROY
           je      .wmdestroy
     .defwndproc:
           invoke  DefWindowProc,[hwnd],[wmsg],[wparam],[lparam]
           jmp     .finish
     .wmdestroy:
           invoke  PostQuitMessage,0
           xor     eax,eax
     .finish:
           ret
   endp
   
   section '.data' data readable writeable
   
     _class TCHAR 'FASMWIN32',0
     _title TCHAR 'Win32 program template',0
     _error TCHAR 'Startup failed.',0
   
     wc WNDCLASS 0,WindowProc,0,0,NULL,NULL,NULL,COLOR_BTNFACE+1,NULL,_class
   
     msg MSG
   
   section '.idata' import data readable writeable
   
     library kernel32,'KERNEL32.DLL',\
             user32,'USER32.DLL'
   
     include 'api\kernel32.inc'
     include 'api\user32.inc'                                                                                                                                                                                                                              
   

You can mix assembly with C (and probably nearly other language). The most generic way would be to write a DLL in assembly, then call this DLL from the GUI program. In C, you can also directly link the program with an object file produced by an assembler, as long as you follow the C conventions.

This tutorial does a good job of explaining the C conventions, but uses NASM: http://drpaulcarter.com/pcasm/.

You should note that TASM is really dated, and I suspect that few people still use it beside teachers.