🚀 go-pugleaf

Witam!

> ROTFL. Nie pisałeś nigdy w C++, prawda?

Przypominam, że jesteśmy na grupie
asemblerowej, gdzie panuje pewna kultura
i nie ma zwyczaju podśmiewania się z
kogokolwiek. Nieważne czy piszę w C, czy
w asm. Uważam oba języki za mające swoje
miejsce i twierdzę, że dyskusja o wyższości
jednego nad drugim nie ma sensu. Ludzie
straszący początkujących asemblerem, albo
go nie znają, albo zakończyli edukację
na etepie 16 bitowych aplikacji, które
faktycznie wymagają mrówczej pracy.
Masm32 dla Win32 jest zupełnie innym narzędziem
podobnym w swoich możliwościach do C++.
Jest na ten temat sporo poważnych opracowań
w sieci. Odsyłam do nich. Ja nie aspiruję
do miana eksperta i tylko wyrażam swoje zdanie.

To przykład programiku w C++:

 #include <windows.h>
 #include <stdlib.h>

LRESULT CALLBACK WindowProc (HWND hwnd, UINT uMsg, WPARAM wParam,
LPARAM lParam);

WNDCLASS wndclass = {
  0,
  WindowProc,
  0,
  0,
  NULL,
  NULL,
  NULL,
  (HBRUSH)(COLOR_MENU + 1),
  NULL,
  "Simple"
};

HWND hwnd;
HWND button1;
HWND button2;
HWND edit;

WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrevInst, LPSTR lpCmdLine,
int nCmdShow) {
  MSG msg;

  wndclass.hInstance = hInst;
  wndclass.hIcon     = LoadIcon (NULL, IDI_APPLICATION);
  wndclass.hCursor   = LoadCursor (NULL, IDC_ARROW);
  RegisterClass (&wndclass);

  hwnd = CreateWindow (wndclass.lpszClassName, "Proste kontrolki",
                       WS_OVERLAPPEDWINDOW,
                       500, 300, 200, 120,
                       NULL, NULL, hInst, NULL);

  button1 = CreateWindow (
            "button",
            "Wypisz",
            BS_PUSHBUTTON|WS_CHILD|WS_VISIBLE,
            25, 5, 60, 20,
            hwnd,     //<-- uchwyt rodzica, na ktorym umieszczamy
przycisk
            (HMENU)1, //<-- tu przekazujemy identyfikator okienka
            hInst,    //    bedzie uzywany do rozpoznawania przyciskow
            NULL);

  button2 = CreateWindow (
            "button",
            "Zapiszcz",
            BS_PUSHBUTTON|WS_CHILD|WS_VISIBLE,
            110, 5, 70, 20,
            hwnd,
            (HMENU)2, //<-- wazne zeby nie uzyc tych samych
identyfikatorow
            hInst,
            NULL);

  edit = CreateWindowEx (
            WS_EX_CLIENTEDGE, //<-- bez tego wyglada jak w win 3.11
            "edit",
             0,                   // "wpisz cos",
            WS_CHILD|WS_VISIBLE,
            25, 30, 140, 20,
            hwnd,
            (HMENU)3,
            hInst,
            NULL);

  edit = CreateWindowEx (
            WS_EX_CLIENTEDGE, //<-- bez tego wyglada jak w win 3.11
            "edit",
             0,                   // "wpisz cos",
            WS_CHILD|WS_VISIBLE,
            25, 60, 140, 20,
            hwnd,
            (HMENU)4,
            hInst,
            NULL);



  ShowWindow (hwnd, nCmdShow);

  while (GetMessage (&msg, NULL, 0, 0)) {
    TranslateMessage(&msg);    //<-- istotne dla dzialania kontrolek
do
    DispatchMessage(&msg);     //    wpisywania tekstu
  }

  return 0;
}

LRESULT CALLBACK WindowProc (HWND hwnd, UINT uMsg, WPARAM wParam,
LPARAM lParam) {
  switch (uMsg) {
  case WM_COMMAND: {
    int id = LOWORD(wParam); //<-- identyfikator kontrolki

    // przycisk 'wypisz', wypisuje tekst kontrolki edycji
    if (id == 1)
     {
      int textLength = GetWindowTextLength(edit);
      char* text = (char*)malloc(textLength+1);  // nie zapomniec o
miejscu na '\0' !!
      GetWindowText(edit, text, textLength+1);
      MessageBox(hwnd, text, "Z KONTROLKI EDYCJI", MB_OK);
      free(text);
    }

    // przycisk 'zapiszcz'
    else if (id == 2) {
      MessageBeep(MB_ICONEXCLAMATION);
    }
    break;
    }

  case WM_DESTROY:
    PostQuitMessage (0);
    return 0;
  }

  return DefWindowProc (hwnd, uMsg, wParam, lParam);
}


I bardzo podobny w Masm32:


.386
.model flat,stdcall
option casemap:none

  include  C:\MASM32\include\Windows.inc
  include  C:\MASM32\include\user32.inc
  include  C:\MASM32\include\kernel32.inc
  includelib  C:\MASM32\lib\user32.lib
  includelib  C:\MASM32\lib\kernel32.lib
  includelib  C:\MASM32\lib\\remeka.lib

   _dec_hex  PROTO
   _wyswietl PROTO


.data

klasa        db "WinClass",0
tytul        db "       Konwerter dec/hex",0
classbutton  db "button",0
Button1Text  db "OK",0
Button2Text  db "Exit",0
classedit    db "edit",0
msgTekst3  db "Wpisz coś", 0
msgTytul db "Error!", 0
Bufor1          db 32 dup(0)
Bufor2          db 32 dup(0)
Bufor3          db 32 dup(0)

.data?

uchwyt       dd ?
hEdit1       dd ?
hEdit2       dd ?

.const

Button1ID   equ 3
Button2ID   equ 4

.code

start:

 invoke GetModuleHandleA, 0
     mov uchwyt, eax

     call WinMain
zamknij:
     invoke ExitProcess, 0

WinMain proc

    LOCAL wc:WNDCLASSEX
    LOCAL msg:MSG
    LOCAL hwnd:HWND
    mov wc.cbSize,SIZEOF WNDCLASSEX
    mov wc.style,CS_HREDRAW or CS_VREDRAW   ;poczytać o tym
    mov wc.lpfnWndProc,offset WndProc
    mov wc.cbClsExtra,0
    mov wc.cbWndExtra,0
    push uchwyt
    pop wc.hInstance
    mov wc.hbrBackground,COLOR_WINDOW
    mov wc.lpszMenuName,0
    mov wc.lpszClassName,offset klasa
    invoke LoadIcon, 0, IDI_APPLICATION
    mov wc.hIcon,eax
    mov wc.hIconSm,eax
    invoke LoadCursor, 0, IDC_ARROW
    mov wc.hCursor,eax

    invoke RegisterClassEx, addr wc

    invoke CreateWindowEx, WS_OVERLAPPEDWINDOW, offset klasa, offset
tytul, WS_TILEDWINDOW,\
           520, 430, 270, 90, 0, 0, uchwyt, 0
     mov hwnd,eax
    invoke ShowWindow, hwnd, SW_SHOWNORMAL
    invoke UpdateWindow, hwnd

 .WHILE TRUE
  invoke GetMessage,ADDR msg,0,0,0
  .BREAK .IF (!eax)
  invoke TranslateMessage,ADDR msg
  invoke DispatchMessage,ADDR msg
 .ENDW
      mov  eax, msg.wParam
      ret

WinMain endp

WndProc proc hWnd:HWND,uMsg:UINT,wParam:WPARAM,lParam:LPARAM

        .IF uMsg==WM_DESTROY
    invoke PostQuitMessage,0
            .ELSEIF uMsg==WM_CREATE

    invoke CreateWindowEx, WS_EX_CLIENTEDGE, ADDR classedit, 0,
WS_CHILD or WS_VISIBLE or WS_BORDER or ES_RIGHT,\
           10, 10, 165, 22, hWnd, 0, uchwyt, 0
     mov hEdit1, eax
        invoke SetFocus, hEdit1

    invoke CreateWindowEx, WS_EX_CLIENTEDGE, offset classedit, 0,
WS_CHILD or WS_VISIBLE or WS_BORDER or ES_RIGHT,\
           10, 33, 165, 22, hWnd, 0, uchwyt, 0
     mov hEdit2, eax

    invoke CreateWindowEx, 0, addr classbutton, addr Button1Text,
WS_CHILD or WS_VISIBLE,\
    189, 10, 60, 22, hWnd, Button1ID, uchwyt, 0

    invoke CreateWindowEx, 0, addr classbutton, addr Button2Text,
WS_CHILD or WS_VISIBLE,\
    189, 33, 60, 22, hWnd, Button2ID, uchwyt, 0

 .ELSEIF uMsg==WM_COMMAND
            mov eax,wParam
      .IF ax==Button1ID

     invoke GetWindowText, hEdit1, addr Bufor1, 16

 push edi
 push esi
 push ebp
 push ebx

 lea esi, Bufor1
 mov ecx, eax
 invoke _dec_hex
 cmp eax, 'b'
 jz jeszcz
 mov dword ptr [Bufor2], edi
 lea esi, Bufor2
 lea edi, Bufor3
 invoke _wyswietl

 pop ebx
 pop ebp
 pop esi
 pop edi

 invoke SetWindowTextA, hEdit2, addr Bufor3
     ret

wpisz:
       invoke MessageBox, 0, addr msgTekst3, addr msgTytul, MB_OK
     ret

jeszcz:
 pop ebx
 pop ebp
 pop esi
 pop edi

    invoke SetWindowTextA, hEdit1, 0

 .ELSEIF ax==Button2ID
     jmp zamknij

     .ENDIF

  .ELSE
    invoke DefWindowProc,hWnd,uMsg,wParam,lParam
  ret
     .ENDIF
 ret

WndProc endp

end start


Oba programiki wykonują podobne operacje. Czy tak bardzo się
różnią sposobem pisania? Ten w C++ po kompilacji ma 8,5 kB,
a ten w Masm 3,5 kB.

Nie ma co straszyć dzieci asemblerem.


Pozdrawiam!

--
Remek