[Duvida] Como criar uma janel em assembly com texto?
Tem um contexto por trás de uma liguagem dessa, mas já tenho um codigo que peguei pela internet que me ajudou:
; Basic Window Extended, 64 bit. V1.05
ANSI_CHARSET EQU 0 ; Constants
BLACKNESS EQU 42h
CLIP_DEFAULT_PRECIS EQU 0
CS_BYTEALIGNWINDOW EQU 2000h
CS_HREDRAW EQU 2
CS_VREDRAW EQU 1
DEFAULT_PITCH EQU 0
ES_AUTOHSCROLL EQU 80h
ES_CENTER EQU 1
FALSE EQU 0
GRAY_BRUSH EQU 2
IDC_ARROW EQU 7F00h
IDI_APPLICATION EQU 7F00h
IDNO EQU 7
IMAGE_CURSOR EQU 2
IMAGE_ICON EQU 1
LR_SHARED EQU 8000h
MB_DEFBUTTON2 EQU 100h
MB_YESNO EQU 4
NULL EQU 0
NULL_BRUSH EQU 5
OPAQUE EQU 2
PROOF_QUALITY EQU 2
SM_CXFULLSCREEN EQU 10h
SM_CYFULLSCREEN EQU 11h
SS_CENTER EQU 1
SS_NOTIFY EQU 100h
SW_SHOWNORMAL EQU 1
TRUE EQU 1
WM_CLOSE EQU 10h
WM_COMMAND EQU 111h
WM_CREATE EQU 1
WM_CTLCOLOREDIT EQU 133h
WM_CTLCOLORSTATIC EQU 138h
WM_DESTROY EQU 2
WM_PAINT EQU 0Fh
WM_SETFONT EQU 30h
OUT_DEFAULT_PRECIS EQU 0
WS_CHILD EQU 40000000h
WS_EX_COMPOSITED EQU 2000000h
WS_OVERLAPPEDWINDOW EQU 0CF0000h
WS_TABSTOP EQU 10000h
WS_VISIBLE EQU 10000000h
WindowWidth EQU 600
WindowHeight EQU 500
Static1ID EQU 100
Static2ID EQU 101
Edit1ID EQU 102
Edit2ID EQU 103
extern AdjustWindowRectEx ; Import external symbols
extern BeginPaint ; Windows API functions, not decorated
extern BitBlt
extern CreateFontA
extern CreateSolidBrush
extern CreateWindowExA
extern DefWindowProcA
extern DeleteObject
extern DestroyWindow
extern DispatchMessageA
extern EndPaint
extern ExitProcess
extern GetDlgCtrlID
extern GetStockObject
extern GetMessageA
extern GetModuleHandleA
extern GetSystemMetrics
extern InvalidateRect
extern IsDialogMessageA
extern LoadImageA
extern MessageBoxA
extern PostQuitMessage
extern RegisterClassExA
extern SendMessageA
extern SetBkColor
extern SetBkMode
extern SetTextColor
extern ShowWindow
extern TranslateMessage
extern UpdateWindow
global Start ; Export symbols. The entry point
section .data ; Initialized data segment
Static1Colour dd 0F0F0F0h ; Colour (0BBGGRRh)
Static1ColourA dd 020A0F0h
Static2Colour dd 000FFFFh
Static2ColourA dd 08000FFh
Edit1TextColour dd 0F590F5h
Edit1BackColour dd 0x808080
Edit2TextColour dd 0A56E3Bh
Edit2BackColour dd 0FEFE8Eh
BackgroundColour dd 0x808080
WindowName db "Window", 0
ClassName db "Window", 0
SegoeUI db "Segoe UI", 0
StaticClass db "STATIC", 0
EditClass db "EDIT", 0
ExitText db "Você quer sair?", 0
section .bss ; Uninitialized data segment
alignb 8
hInstance resq 1
BackgroundBrush resq 1
Font resq 1
Static1 resq 1
Static2 resq 1
Edit1 resq 1
Edit2 resq 1
section .text
; Code segment
Start:
sub RSP, 8 ; Align stack pointer to 16 bytes
sub RSP, 32 ; 32 bytes of shadow space
xor ECX, ECX
call GetModuleHandleA
mov qword [REL hInstance], RAX
add RSP, 32 ; Remove the 32 bytes
call WinMain
.Exit:
xor ECX, ECX
call ExitProcess
WinMain:
push RBP ; Set up a stack frame
mov RBP, RSP
sub RSP, 160 + 64 + 32 ; 160 bytes for local variables
; + 64 (8 * 8 byte) parameters
; + 32 shadow space
; Kept to a multiple of 16 for API functions
%define Screen.Width RBP - 160 ; 4 bytes
%define Screen.Height RBP - 156 ; 4 bytes
%define ClientArea RBP - 152 ; RECT structure. 16 bytes
%define ClientArea.left RBP - 152 ; 4 bytes. Start on a 4 byte boundary
%define ClientArea.top RBP - 148 ; 4 bytes
%define ClientArea.right RBP - 144 ; 4 bytes
%define ClientArea.bottom RBP - 140 ; 4 bytes. End on a 4 byte boundary
%define wc RBP - 136 ; WNDCLASSEX structure, 80 bytes
%define wc.cbSize RBP - 136 ; 4 bytes. Start on an 8 byte boundary
%define wc.style RBP - 132 ; 4 bytes
%define wc.lpfnWndProc RBP - 128 ; 8 bytes
%define wc.cbClsExtra RBP - 120 ; 4 bytes
%define wc.cbWndExtra RBP - 116 ; 4 bytes
%define wc.hInstance RBP - 112 ; 8 bytes
%define wc.hIcon RBP - 104 ; 8 bytes
%define wc.hCursor RBP - 96 ; 8 bytes
%define wc.hbrBackground RBP - 88 ; 8 bytes
%define wc.lpszMenuName RBP - 80 ; 8 bytes
%define wc.lpszClassName RBP - 72 ; 8 bytes
%define wc.hIconSm RBP - 64 ; 8 bytes. End on an 8 byte boundary
%define msg RBP - 56 ; MSG structure, 48 bytes
%define msg.hwnd RBP - 56 ; 8 bytes. Start on an 8 byte boundary
%define msg.message RBP - 48 ; 4 bytes
%define msg.Padding1 RBP - 44 ; 4 bytes. Natural alignment padding
%define msg.wParam RBP - 40 ; 8 bytes
%define msg.lParam RBP - 32 ; 8 bytes
%define msg.time RBP - 24 ; 4 bytes
%define msg.py.x RBP - 20 ; 4 bytes
%define msg.pt.y RBP - 16 ; 4 bytes
%define msg.Padding2 RBP - 12 ; 4 bytes. Structure length padding
%define hWnd RBP - 8 ; 8 bytes
mov ECX, dword [REL BackgroundColour]
call CreateSolidBrush ; Create a brush for the window backgound
mov qword [REL BackgroundBrush], RAX
mov dword [wc.cbSize], 80 ; [RBP - 136]
mov dword [wc.style], CS_HREDRAW | CS_VREDRAW | CS_BYTEALIGNWINDOW ; [RBP - 132]
lea RAX, [REL WndProc]
mov qword [wc.lpfnWndProc], RAX ; [RBP - 128]
mov dword [wc.cbClsExtra], NULL ; [RBP - 120]
mov dword [wc.cbWndExtra], NULL ; [RBP - 116]
mov RAX, qword [REL hInstance]
mov qword [wc.hInstance], RAX ; [RBP - 112]
xor ECX, ECX
mov EDX, IDI_APPLICATION
mov R8D, IMAGE_ICON
xor R9D, R9D
mov qword [RSP + 4 * 8], NULL
mov qword [RSP + 5 * 8], LR_SHARED
call LoadImageA ; Large program icon
mov qword [wc.hIcon], RAX ; [RBP - 104]
xor ECX, ECX
mov EDX, IDC_ARROW
mov R8D, IMAGE_CURSOR
xor R9D, R9D
mov qword [RSP + 4 * 8], NULL
mov qword [RSP + 5 * 8], LR_SHARED
call LoadImageA ; Cursor
mov qword [wc.hCursor], RAX ; [RBP - 96]
mov RAX, qword [REL BackgroundBrush]
mov qword [wc.hbrBackground], RAX ; [RBP - 88]
mov qword [wc.lpszMenuName], NULL ; [RBP - 80]
lea RAX, [REL ClassName]
mov qword [wc.lpszClassName], RAX ; [RBP - 72]
xor ECX, ECX
mov EDX, IDI_APPLICATION
mov R8D, IMAGE_ICON
xor R9D, R9D
mov qword [RSP + 4 * 8], NULL
mov qword [RSP + 5 * 8], LR_SHARED
call LoadImageA ; Small program icon
mov qword [wc.hIconSm], RAX ; [RBP - 64]
lea RCX, [wc] ; [RBP - 136]
call RegisterClassExA
mov ECX, SM_CXFULLSCREEN
call GetSystemMetrics ; Get the current screen width
mov dword [Screen.Width], EAX ; [RBP - 160]
mov ECX, SM_CYFULLSCREEN
call GetSystemMetrics ; Get the current screen height
mov dword [Screen.Height], EAX ; [RBP - 156]
mov dword [ClientArea.left], 0 ; [RBP - 152]
mov dword [ClientArea.top], 0 ; [RBP - 148]
mov dword [ClientArea.right], WindowWidth ; [RBP - 144]
mov dword [ClientArea.bottom], WindowHeight ; [RBP - 140]
lea RCX, [ClientArea] ; [RBP - 152]
mov EDX, WS_OVERLAPPEDWINDOW ; Style
xor R8D, R8D
mov R9D, WS_EX_COMPOSITED ; Extended style
call AdjustWindowRectEx ; Get window size for the desired client size
; Size is returned in ClientArea
mov EAX, dword [ClientArea.top] ; [RBP - 148]
sub dword [ClientArea.bottom], EAX ; New Height = ClientArea.bottom - ClientArea.top
mov EAX, dword [ClientArea.left] ; [RBP - 152]
sub dword [ClientArea.right], EAX ; New Width = ClientArea.right - ClientArea.left
mov ECX, WS_EX_COMPOSITED
lea RDX, [REL ClassName]
lea R8, [REL WindowName]
mov R9D, WS_OVERLAPPEDWINDOW
xor R10D, R10D
mov EAX, dword [Screen.Width] ; [RBP - 160]
sub EAX, dword [ClientArea.right] ; Corrected window width. [RBP - 144]
cmovs EAX, R10D ; Clamp to 0 (left) if negative
shr EAX, 1 ; EAX = (Screen.Width - window height) / 2
mov dword [RSP + 4 * 8], EAX ; X position, now centred
mov EAX, dword [Screen.Height] ; [RBP - 156]
sub EAX, dword [ClientArea.bottom] ; Corrected window height. [RBP - 140]
cmovs EAX, R10D ; Clamp to 0 (top) if negative
shr EAX, 1 ; EAX = (Screen.Height - window height) / 2
mov dword [RSP + 5 * 8], EAX ; Y position, now centred
mov EAX, dword [ClientArea.right] ; [RBP - 144]
mov dword [RSP + 6 * 8], EAX ; Width
mov EAX, dword [ClientArea.bottom] ; [RBP - 140]
mov dword [RSP + 7 * 8], EAX ; Height
mov qword [RSP + 8 * 8], NULL
mov qword [RSP + 9 * 8], NULL
mov RAX, qword [REL hInstance]
mov qword [RSP + 10 * 8], RAX
mov qword [RSP + 11 * 8], NULL
call CreateWindowExA
mov qword [hWnd], RAX ; [RBP - 8]
mov RCX, qword [hWnd] ; [RBP - 8]
mov EDX, SW_SHOWNORMAL
call ShowWindow
mov RCX, qword [hWnd] ; [RBP - 8]
call UpdateWindow
.MessageLoop:
lea RCX, [msg] ; [RBP - 56]
xor EDX, EDX
xor R8D, R8D
xor R9D, R9D
call GetMessageA
cmp RAX, 0
je .Done
mov RCX, qword [hWnd] ; [RBP - 8]
lea RDX, [msg] ; [RBP - 56]
call IsDialogMessageA ; For keyboard strokes
cmp RAX, 0
jne .MessageLoop ; Skip TranslateMessage and DispatchMessageA
lea RCX, [msg] ; [RBP - 56]
call TranslateMessage
lea RCX, [msg] ; [RBP - 56]
call DispatchMessageA
jmp .MessageLoop
.Done:
xor EAX, EAX
mov RSP, RBP ; Remove the stack frame
pop RBP
ret
WndProc:
push RBP ; Set up a stack frame
mov RBP, RSP
sub RSP, 80 + 80 + 32 ; 80 bytes for local variables
; + 80 (10 * 8 byte) parameters
; + 32 shadow space
; Kept to a multiple of 16 for API functions
%define hWnd RBP + 16 ; Location of the shadow space setup by
%define uMsg RBP + 24 ; the calling function
%define wParam RBP + 32
%define lParam RBP + 40
%define ps RBP - 80 ; PAINTSTRUCT structure. 72 bytes
%define ps.hdc RBP - 80 ; 8 bytes. Start on an 8 byte boundary
%define ps.fErase RBP - 72 ; 4 bytes
%define ps.rcPaint.left RBP - 68 ; 4 bytes
%define ps.rcPaint.top RBP - 64 ; 4 bytes
%define ps.rcPaint.right RBP - 60 ; 4 bytes
%define ps.rcPaint.bottom RBP - 56 ; 4 bytes
%define ps.Restore RBP - 52 ; 4 bytes
%define ps.fIncUpdate RBP - 48 ; 4 bytes
%define ps.rgbReserved RBP - 44 ; 32 bytes
%define ps.Padding RBP - 12 ; 4 bytes. Structure length padding
%define hdc RBP - 8 ; 8 bytes
mov qword [hWnd], RCX ; Free up RCX RDX R8 R9 by spilling the
mov qword [uMsg], RDX ; 4 passed parameters to the shadow space
mov qword [wParam], R8 ; We can now access these parameters by name
mov qword [lParam], R9
cmp qword [uMsg], WM_CLOSE ; [RBP + 24]
je WMCLOSE
cmp qword [uMsg], WM_COMMAND ; [RBP + 24]
je WMCOMMAND
cmp qword [uMsg], WM_CREATE ; [RBP + 24]
je WMCREATE
cmp qword [uMsg], WM_CTLCOLOREDIT ; [RBP + 24]
je WMCTLCOLOREDIT
cmp qword [uMsg], WM_CTLCOLORSTATIC ; [RBP + 24]
je WMCTLCOLORSTATIC
cmp qword [uMsg], WM_DESTROY ; [RBP + 24]
je WMDESTROY
cmp qword [uMsg], WM_PAINT ; [RBP + 24]
je WMPAINT
DefaultMessage:
mov RCX, qword [hWnd] ; [RBP + 16]
mov RDX, qword [uMsg] ; [RBP + 24]
mov R8, qword [wParam] ; [RBP + 32]
mov R9, qword [lParam] ; [RBP + 40]
call DefWindowProcA
jmp Return
WMCLOSE:
mov RCX, qword [hWnd] ; [RBP + 16]
lea RDX, [REL ExitText]
lea R8, [REL WindowName]
mov R9D, MB_YESNO | MB_DEFBUTTON2
call MessageBoxA
cmp RAX, IDNO
je Return.WM_Processed
mov RCX, qword [hWnd] ; [RBP + 16]
call DestroyWindow ; Send a WM_DESTROY message
jmp Return.WM_Processed
WMCOMMAND:
mov RAX, qword [wParam] ; RAX = ID. [RBP + 32]
cmp AX, Static1ID
je .Static1
cmp AX, Static2ID
je .Static2
jmp Return.WM_Processed
.Static1:
mov EAX, dword [REL Static1Colour]
mov ECX, dword [REL Static1ColourA]
mov dword [REL Static1Colour], ECX
mov dword [REL Static1ColourA], EAX ; Swap colours
mov RCX, qword [lParam] ; Static1 handle. [RBP + 40]
xor EDX, EDX
mov R8D, TRUE
call InvalidateRect ; Redraw control
jmp Return.WM_Processed
.Static2:
mov EAX, dword [REL Static2Colour]
mov ECX, dword [REL Static2ColourA]
mov dword [REL Static2Colour], ECX
mov dword [REL Static2ColourA], EAX ; Swap colours
mov RCX, qword [lParam] ; Static2 handle. [RBP + 40]
xor EDX, EDX
mov R8D, TRUE
call InvalidateRect ; Redraw control
jmp Return.WM_Processed
WMCREATE:
jmp Return.WM_Processed
WMCTLCOLOREDIT: ; For colouring edit controls
mov RCX, qword [lParam] ; [RBP + 40]
call GetDlgCtrlID ; RAX = ID
cmp RAX, Edit1ID
je .Edit1
cmp RAX, Edit2ID
je .Edit2
.Default:
mov ECX, NULL_BRUSH
call GetStockObject ; Return a brush
jmp Return
.Edit1:
mov RCX, qword [wParam] ; [RBP + 32]
mov EDX, dword [REL Edit1TextColour]
call SetTextColor
mov RCX, qword [wParam] ; [RBP + 32]
mov EDX, OPAQUE
call SetBkMode
mov RCX, qword [wParam] ; [RBP + 32]
mov EDX, dword [REL Edit1BackColour]
call SetBkColor
mov ECX, NULL_BRUSH
call GetStockObject ; Return a brush
jmp Return
.Edit2:
mov RCX, qword [wParam] ; [RBP + 32]
mov EDX, dword [REL Edit2TextColour]
call SetTextColor
mov RCX, qword [wParam] ; [RBP + 32]
mov EDX, OPAQUE
call SetBkMode
mov RCX, qword [wParam] ; [RBP + 32]
mov EDX, dword [REL Edit2BackColour]
call SetBkColor
mov ECX, NULL_BRUSH
call GetStockObject ; Return a brush
jmp Return
WMCTLCOLORSTATIC: ; For colouring static controls
mov RCX, qword [lParam] ; [RBP + 40]
call GetDlgCtrlID ; RAX = ID
cmp RAX, Static1ID
je .Static1
cmp RAX, Static2ID
je .Static2
.Default:
mov ECX, NULL_BRUSH
call GetStockObject ; Return a brush
jmp Return
.Static1:
mov RCX, qword [wParam] ; [RBP + 32]
mov EDX, dword [REL Static1Colour]
call SetTextColor
mov RCX, qword [wParam] ; [RBP + 32]
mov EDX, OPAQUE
call SetBkMode
mov RCX, qword [wParam] ; [RBP + 32]
mov EDX, 0604060h
call SetBkColor
mov ECX, NULL_BRUSH
call GetStockObject ; Return a brush
jmp Return
.Static2:
mov RCX, qword [wParam] ; [RBP + 32]
mov EDX, dword [REL Static2Colour]
call SetTextColor
mov RCX, qword [wParam] ; [RBP + 32]
mov EDX, OPAQUE
call SetBkMode
mov RCX, qword [wParam] ; [RBP + 32]
mov EDX, 0005000h
call SetBkColor
mov ECX, GRAY_BRUSH
call GetStockObject ; Return a brush
jmp Return
WMDESTROY:
mov RCX, qword [REL BackgroundBrush]
call DeleteObject
mov RCX, qword [REL Font]
call DeleteObject
xor ECX, ECX
call PostQuitMessage
jmp Return.WM_Processed
WMPAINT:
mov RCX, qword [hWnd] ; [RBP + 16]
lea RDX, [ps] ; [RBP - 80]
call BeginPaint
mov qword [hdc], RAX ; [RBP - 8] ; Blit a black rectangle
mov RCX, qword [hWnd] ; [RBP + 16]
lea RDX, [ps] ; [RBP - 80]
call EndPaint
Return.WM_Processed:
xor EAX, EAX ; WM_ has been processed, return 0
Return:
mov RSP, RBP ; Remove the stack frame
pop RBP
ret
Mas quero adicionar texto dentro dessa janela (não e uma messagebox, e texto mesmo dentro da janela), poderiam me ajudar?
OBS: E necessariio que seja em assembly por algumas peculariedades do meu projeto!
Você pode aprender assembly no canal abaixo, aulas em português. A parte ruim é que seu foco é Windows, mas acredito que dá para aprender bastante, o foco do canal é Linux.
Canal debxp Tutorial de NASM, instruções x86, 64 bits e GNU Linux. https://www.youtube.com/playlist?list=PLXoSGejyuQGohd0arC7jRBqVdQqf5GqKJ
Repositório do canal https://codeberg.org/blau_araujo/assembly-nasm-x86_64
Além do Assembly você está usando a API Win32 https://learn.microsoft.com/pt-br/windows/win32/desktop-programming
O caminho é procurar como adicionar um label na janela. Outra coisa, a API é feita para ser chamada em C, então outro caminho é entender essa "conversão" de chamadas de C para chamadas Assembly.
Gostei, principalmente pois ainda vou preparar para o contexto do Linux, estou usando o Windows preferencialmente porque é a plataforma que eu uso, eu uso win64 no nasm. Muito obrigado.
Bom, fiquei com mais questões do quê solução para o seu problema kkkkk
Tive preguiça de ler todo o codigo, então vou falar o que penso que seja mais facil( eu nem mesmo tenho grande conhecimento de asm 64 kkk é muito registrador!)
Se você tá criando uma janela no windows, então tá fazendo chamada a API do windows, tudo que precisa é vasculhar a API do Windows e encontrar a chamada a janela, então coloca a mensagem que você quer num registrador e depois... bom, depois eu não sei kkkkk você precisa REALMENTE estudar a API do Windows, talvez deva ter uma janela especifica para exibir uma mensagem ou que aceite uma entrada.
Aqui vai um spoiler: Sabe porquê o Ruindows é mais pesado e lento em relação ao Linux e Unix e Unix-likes? Porquê no sistema POSIX temos algo proximo a 100(acho que um pouco mais) chamadas, enquanto o Windows tem literalmente algo proximo ou superior a milhares. O Windows ligou o foda-se e cria chamadas loucamente, e pior, toda nova versão do Windows adiciona mais um monte simplesmente para manter compatibilidade com as anteriores, ou seja, bola de neve! E pior que uma boa parte dessas chamadas são da interface grafica do sistema chamando o kernel, abrindo processos, processos filhos, e etc... um inferno kkkkkkk
Sugiro tentar implementar num Linux primeiro, acho que é mais simples kkkkk bom, tudo que sei foi mexendo no MINIX e lendo o livrinho do Tanenbaum, certeza que equivoquei em algo aí, mas dá uma procurada e boa sorte! :D ps, continua no ASM que essa é a linguagem/sintaxe MAIS LINDA DE TODAS!! (pena que doi os dedos de escrever kkkk)
Obrigado pelo comentario! Qcredito mesmo que tenha muitos registradores, ja tentei ajuda ao chatGPT e ele endoidou e ficou infinitamente push 0 (sendo que isso e em 32 bits e estou escrevendo 64 bits), vou tentar procurar o comando para criar a label pois o mais proximo disso e um controlador que muda de cor (peguei do site da fonte).