870 lines
18 KiB
NASM
870 lines
18 KiB
NASM
;constants.asm
|
|
extern EOS
|
|
extern NL
|
|
;core.asm
|
|
extern min
|
|
extern minu
|
|
extern max
|
|
extern maxu
|
|
extern islower
|
|
extern isupper
|
|
extern tolower
|
|
extern toupper
|
|
extern itoa
|
|
extern exit
|
|
;console.asm
|
|
extern print
|
|
extern puts
|
|
extern printf
|
|
extern perror
|
|
;string.asm
|
|
extern strlen
|
|
extern strcpy
|
|
extern strlcpy
|
|
extern strclr
|
|
extern strlclr
|
|
extern strcat
|
|
extern strcmp
|
|
;file.asm
|
|
extern fopen
|
|
extern fclose
|
|
extern fwrite
|
|
|
|
section .rodata
|
|
PRINT_nums equ 1
|
|
PRINT_strs equ 1
|
|
TEST_print equ 1
|
|
TEST_puts equ 1
|
|
TEST_printf equ 1
|
|
TEST_perror equ 1
|
|
TEST_min equ 1 ;includes minu
|
|
TEST_max equ 1 ;includes maxu
|
|
TEST_strlen equ 1
|
|
TEST_islower equ 1
|
|
TEST_isupper equ 1
|
|
TEST_strcpy equ 1
|
|
TEST_strlcpy equ 1
|
|
TEST_strclr equ 1
|
|
TEST_strlclr equ 1
|
|
TEST_strcat equ 1
|
|
TEST_tolower equ 1
|
|
TEST_toupper equ 1
|
|
TEST_strcmp equ 1
|
|
TEST_file1 equ 1
|
|
;TEST_itoa equ 0 ; not included in these tests; printf() calls itoa for %d specifiers
|
|
|
|
num1 dq 69
|
|
num2 dq 0xFFFFFF
|
|
num3 equ 25
|
|
num4 dq -90
|
|
prntNums db "PRINT numbers:",NL,"> num1: %d",NL,"> num2: %d",NL,"> num3: %d",NL,"> num4: %d",NL,EOS
|
|
|
|
str1 db "Hello, world!",EOS
|
|
str2 db "Hello world!",EOS
|
|
str3 db "Howdy environment!",EOS
|
|
str4 db "Hell",EOS"o world!",EOS
|
|
prntStrs db "PRINT strings:",NL,"> str1: %s",NL,"> str2: %s",NL,"> str3: %s",NL,"> str4: %s",NL,EOS
|
|
|
|
; print()
|
|
msgPrint db NL,"# print()",NL,EOS
|
|
msgPrint1 db "print() test",EOS
|
|
; puts()
|
|
msgPuts db NL,NL,"# puts()",NL,EOS
|
|
msgPuts1 db "puts() test",EOS
|
|
; printf()
|
|
testStr db "Testing: %s, %%, %s, %s, %f, %s, %d, %s, %s, %x, %s, %s, %d, %s",NL,EOS
|
|
tS1 db "one",EOS
|
|
tS2 db "two",EOS
|
|
tS3 db "three",EOS
|
|
tS4 db "four",EOS
|
|
tS5 db "five",EOS
|
|
tS6 db "six",EOS
|
|
tS7 db "seven",EOS
|
|
tS8 db "eight",EOS
|
|
tS9 db "noin",EOS
|
|
msgPrintf db NL,"# printf()",EOS
|
|
msgPrintf1 db "TEST printf()",NL,EOS
|
|
msgPrintf2 db "TEST printf(testStr, tS1, tS2, tS3, invalid1, tS4, num4, tS5, tS6, invalid2, tS7, tS8, num1, tS9)",NL,EOS
|
|
msgPrintf2b db "Return value: %d",NL,EOS
|
|
; perror()
|
|
msgPerror db NL,"# perror()",EOS
|
|
msgPerror1 db "TEST perror(",34,"ErrTest",34,") (rax=0):",NL,EOS
|
|
msgPerror2 db "TEST perror(",34,"ErrTest",34,") (rax=-22):",NL,EOS
|
|
msgPerror3 db "TEST perror(",34,"ErrTest",34,") (rax=7):",NL,EOS
|
|
msgPerror4 db "TEST perror(",34,"ErrTest",34,") (rax=-50)",NL,EOS
|
|
perrorStr db "ErrTest",EOS
|
|
; min() / minu()
|
|
msgMin db NL,"# min() / minu()",EOS
|
|
msgMin1 db "TEST min(num1, num2): %d",NL,EOS
|
|
msgMin2 db "TEST minu(num1, num2): %d",NL,EOS
|
|
msgMin3 db "TEST min(num1, num3): %d",NL,EOS
|
|
msgMin4 db "TEST minu(num1, num3): %d",NL,EOS
|
|
msgMin5 db "TEST min(num1, num4): %d",NL,EOS
|
|
msgMin6 db "TEST minu(num1, num4): %d",NL,EOS
|
|
msgMin7 db "TEST min(num2, num4): %d",NL,EOS
|
|
msgMin8 db "TEST minu(num2, num4): %d",NL,EOS
|
|
; max() / maxu()
|
|
msgMax db NL,"# max() / maxu()",EOS
|
|
msgMax1 db "TEST max(num1, num2): %d",NL,EOS
|
|
msgMax2 db "TEST maxu(num1, num2): %d",NL,EOS
|
|
msgMax3 db "TEST max(num1, num3): %d",NL,EOS
|
|
msgMax4 db "TEST maxu(num1, num3): %d",NL,EOS
|
|
msgMax5 db "TEST max(num1, num4): %d",NL,EOS
|
|
msgMax6 db "TEST maxu(num1, num4): %d",NL,EOS
|
|
msgMax7 db "TEST max(num2, num4): %d",NL,EOS
|
|
msgMax8 db "TEST maxu(num2, num4): %d",NL,EOS
|
|
; strlen()
|
|
msgStrlen db NL,"# strlen()",EOS
|
|
msgStrlen1 db "TEST strlen(str1): %d",NL,EOS
|
|
msgStrlen2 db "TEST strlen(str2): %d",NL,EOS
|
|
msgStrlen3 db "TEST strlen(str3): %d",NL,EOS
|
|
msgStrlen4 db "TEST strlen(str4): %d",NL,EOS
|
|
; islower()
|
|
msgIslower db NL,"# islower()",EOS
|
|
msgIslower1 db "TEST islower(str1[0]): %d",NL,EOS ;str1[0] => 'H'
|
|
msgIslower2 db "TEST islower(str1[1]): %d",NL,EOS ;str1[1] => 'e'
|
|
msgIslower3 db "TEST islower(str1[5]): %d",NL,EOS ;str1[5] => ','
|
|
; isupper()
|
|
msgIsupper db NL,"# isupper()",EOS
|
|
msgIsupper1 db "TEST isupper(str1[0]): %d",NL,EOS ;str1[0] => 'H'
|
|
msgIsupper2 db "TEST isupper(str1[1]): %d",NL,EOS ;str1[1] => 'e'
|
|
msgIsupper3 db "TEST isupper(str1[5]): %d",NL,EOS ;str1[5] => ','
|
|
; strcpy()
|
|
msgStrcpy db NL,"# strcpy()",EOS
|
|
msgStrcpy1 db "TEST strcpy(strBuff1, str4): %s",NL,EOS
|
|
msgStrcpy2 db "TEST strcpy(strBuff1, str2): %s",NL,EOS
|
|
msgStrcpy3 db "TEST strcpy(strBuff1, str1): %s",NL,EOS
|
|
; strlcpy()
|
|
msgStrlcpy db NL,"# strlcpy()",EOS
|
|
msgStrlcpy1 db "TEST strlcpy(strBuff2, str1, -1) (%d): %s",NL,EOS
|
|
msgStrlcpy2 db "TEST strlcpy(strBuff2, str1, 0) (%d): %s",NL,EOS
|
|
msgStrlcpy3 db "TEST strlcpy(strBuff2, str1, 5) (%d): %s",NL,EOS
|
|
msgStrlcpy4 db "TEST strlcpy(strBuff2, str4, 8) (%d): %s",NL,EOS
|
|
; strclr()
|
|
msgStrclr db NL,"# strclr()",EOS
|
|
msgStrclr1 db "TEST strclr(strBuff1): (%d) %s",NL,EOS
|
|
msgStrclr2 db "> strcpy(strBuff1, str3). strBuff1 => %s",NL,EOS
|
|
msgStrclr3 db "TEST strclr(strBuff1): (%d) %s",NL,EOS
|
|
; strlclr()
|
|
msgStrlclr db NL,"# strlclr()",EOS
|
|
msgStrlclr1 db "TEST strlclr(strbuff1, 32): %s",NL,EOS
|
|
msgStrlclr2 db "> strcpy(strBuff1, str3). strBuff1 => %s",NL,EOS
|
|
msgStrlclr3 db "TEST strlclr(strBuff1, 32): %s",NL,EOS
|
|
; strcat()
|
|
msgStrcat db NL,"# strcat()",EOS
|
|
msgStrcat1 db "TEST strcat(strBuff1, str3): %s", NL,EOS
|
|
msgStrcat2 db "> strclr(strBuff1)",EOS
|
|
msgStrcat3 db "TEST strcat(strBuff1, str1): %s",NL,EOS
|
|
msgStrcat4 db "TEST strcat(strBuff1, str3): %s",NL,EOS
|
|
; tolower()
|
|
msgTolower db NL,"# tolower()",NL,"> strcpy(strBuff1, str3)",EOS
|
|
msgTolower1 db "TEST tolower(strBuff1[0]): %c",NL,EOS
|
|
msgTolower2 db "TEST tolower for whole strBuff1: %s",NL,EOS
|
|
; toupper()
|
|
msgToupper db NL,"# toupper()",NL,"> strcpy(strBuff1, str3)",EOS
|
|
msgToupper1 db "TEST toupper(strBuff1[0]): %c",NL,EOS
|
|
msgToupper2 db "TEST toupper for whole strBuff1: %s",NL,EOS
|
|
; strcmp()
|
|
msgStrcmp db NL,"# strcmp()",NL,"strlclr(strBuff1, 32)",NL,"strcpy(strBuff1, str1)",NL,"toupper(strBuff1[7])",EOS
|
|
msgStrcmpStrs db "> str1: %s",NL,"> str2: %s",NL,"> str4: %s",NL,"> strBuff1: %s",NL,EOS
|
|
msgStrcmp1 db "TEST strcmp(strBuff1, str1): %d",NL,EOS
|
|
msgStrcmp2 db "TEST strcmp(str1, str2): %d",NL,EOS
|
|
msgStrcmp3 db "TEST strcmp(strBuff1, str2): %d",NL,EOS
|
|
msgStrcmp4 db "TEST strcmp(str4, str1): %d",NL,EOS
|
|
msgStrcmp5 db "TEST strcmp(str1, str4): %d",NL,EOS
|
|
msgStrcmp6 db "TEST strcmp(str1, str1): %d",NL,EOS
|
|
; fopen(), fwrite(), fclose()
|
|
testFile1 db "testFile1.txt",EOS
|
|
fileStr1 db "Hello file world!",EOS
|
|
msgFileB db NL,"# fopen(), fwrite(), fclose()",EOS
|
|
msgFileB1 db "TEST fopen('testFile1.txt', 'w'): %d",NL,EOS
|
|
msgFileB2 db "TEST fwrite(filePointer1, fileStr1): %d",NL,EOS
|
|
msgFileB3 db "TEST fclose(filePointer1): %d",NL,EOS
|
|
perror_fopen db " Error@fopen()",EOS
|
|
perror_fwrite db " Error@fwrite()",EOS
|
|
perror_fclose db " Error@fclose()",EOS
|
|
section .data
|
|
filePointer1 dq 0
|
|
section .bss
|
|
strBuff1 resb 32
|
|
strBuff2 resb 8
|
|
section .text
|
|
global _start
|
|
_start:
|
|
push rbp
|
|
mov rbp, rsp
|
|
|
|
%IF PRINT_nums
|
|
xor rax, rax
|
|
lea rdi, [rel prntNums]
|
|
mov rsi, [rel num1]
|
|
mov rdx, [rel num2]
|
|
mov rcx, num3
|
|
mov r8, [rel num4]
|
|
call printf
|
|
%ENDIF
|
|
%IF PRINT_strs
|
|
xor rax, rax
|
|
lea rdi, [rel prntStrs]
|
|
lea rsi, [rel str1]
|
|
lea rdx, [rel str2]
|
|
lea rcx, [rel str3]
|
|
lea r8, [rel str4]
|
|
call printf
|
|
%ENDIF
|
|
|
|
%IF TEST_print
|
|
xor rax, rax
|
|
lea rdi, [rel msgPrint]
|
|
call printf
|
|
lea rdi, [rel msgPrint1]
|
|
call print
|
|
%ENDIF
|
|
%IF TEST_puts
|
|
xor rax, rax
|
|
lea rdi, [rel msgPuts]
|
|
call printf
|
|
lea rdi, [rel msgPuts1]
|
|
call puts
|
|
%ENDIF
|
|
%IF TEST_printf
|
|
lea rdi, [rel msgPrintf]
|
|
call puts
|
|
|
|
; TEST: printf(msgPrintf1)
|
|
lea rdi, [rel msgPrintf1]
|
|
call printf
|
|
|
|
; TEST printf(testStr, tS1, tS2, tS3, invalid1, tS4, num4, tS5, tS6, invalid2, tS7, tS8, num1, tS9)
|
|
lea rdi, [rel msgPrintf2]
|
|
call printf
|
|
|
|
lea rdi, [rel testStr]
|
|
lea rsi, [rel tS1]
|
|
lea rdx, [rel tS2]
|
|
lea rcx, [rel tS3]
|
|
mov r8, 0
|
|
lea r9, [rel tS4]
|
|
push tS9
|
|
push qword [rel num1]
|
|
push tS8
|
|
push tS7
|
|
push 0
|
|
push tS6
|
|
push tS5
|
|
push qword [num4]
|
|
call printf
|
|
add rsp, 8*8
|
|
mov rsi, rax
|
|
lea rdi, [msgPrintf2b]
|
|
call printf
|
|
%ENDIF
|
|
%IF TEST_perror
|
|
lea rdi, [rel msgPerror]
|
|
call puts
|
|
|
|
; TEST: perror (no error)
|
|
lea rdi, [rel msgPerror1]
|
|
call print
|
|
xor rax, rax
|
|
lea rdi, [rel perrorStr]
|
|
call perror
|
|
|
|
; TEST: perror (err=-22)
|
|
lea rdi, [rel msgPerror2]
|
|
call print
|
|
mov rax, -22
|
|
lea rdi, [rel perrorStr]
|
|
call perror
|
|
|
|
; TEST: perror (err=7)
|
|
lea rdi, [rel msgPerror3]
|
|
call print
|
|
mov rax, 7
|
|
lea rdi, [rel perrorStr]
|
|
call perror
|
|
|
|
; TEST: perror (err=-50)
|
|
lea rdi, [rel msgPerror4]
|
|
call print
|
|
mov rax, -50
|
|
lea rdi, [rel perrorStr]
|
|
call perror
|
|
%ENDIF
|
|
%IF TEST_min
|
|
lea rdi, [rel msgMin]
|
|
call puts
|
|
|
|
;TEST: min(num1, num2)
|
|
mov rdi, [rel num1]
|
|
mov rsi, [rel num2]
|
|
call min
|
|
mov rsi, rax
|
|
xor rax, rax
|
|
lea rdi, [rel msgMin1]
|
|
call printf
|
|
;TEST: minu(num1, num2)
|
|
mov rdi, [rel num1]
|
|
mov rsi, [rel num2]
|
|
call minu
|
|
mov rsi, rax
|
|
xor rax, rax
|
|
lea rdi, [rel msgMin2]
|
|
call printf
|
|
;TEST: min(num1, num3)
|
|
mov rdi, [rel num1]
|
|
mov rsi, num3
|
|
call min
|
|
mov rsi, rax
|
|
xor rax, rax
|
|
lea rdi, [rel msgMin3]
|
|
call printf
|
|
;TEST: minu(num1, num3)
|
|
mov rdi, [rel num1]
|
|
mov rsi, num3
|
|
call minu
|
|
mov rsi, rax
|
|
xor rax, rax
|
|
lea rdi, [rel msgMin4]
|
|
call printf
|
|
;TEST: min(num1, num4)
|
|
mov rdi, [rel num1]
|
|
mov rsi, [rel num4]
|
|
call min
|
|
mov rsi, rax
|
|
xor rax, rax
|
|
lea rdi, [rel msgMin5]
|
|
call printf
|
|
;TEST: minu(num1, num4)
|
|
mov rdi, [rel num1]
|
|
mov rsi, [rel num4]
|
|
call minu
|
|
mov rsi, rax
|
|
xor rax, rax
|
|
lea rdi, [rel msgMin6]
|
|
call printf
|
|
;TEST: min(num2, num4)
|
|
mov rdi, [rel num2]
|
|
mov rsi, [rel num4]
|
|
call min
|
|
mov rsi, rax
|
|
xor rax, rax
|
|
lea rdi, [rel msgMin7]
|
|
call printf
|
|
;TEST: minu(num2, num4)
|
|
mov rdi, [rel num2]
|
|
mov rsi, [rel num4]
|
|
call minu
|
|
mov rsi, rax
|
|
xor rax, rax
|
|
lea rdi, [rel msgMin8]
|
|
call printf
|
|
%ENDIF
|
|
%IF TEST_max
|
|
lea rdi, [rel msgMax]
|
|
call puts
|
|
;TEST: max(num1, num2)
|
|
mov rdi, [rel num1]
|
|
mov rsi, [rel num2]
|
|
call max
|
|
mov rsi, rax
|
|
xor rax, rax
|
|
lea rdi, [rel msgMax1]
|
|
call printf
|
|
;TEST: maxu(num1, num2)
|
|
mov rdi, [rel num1]
|
|
mov rsi, [rel num2]
|
|
call maxu
|
|
mov rsi, rax
|
|
xor rax, rax
|
|
lea rdi, [rel msgMax2]
|
|
call printf
|
|
;TEST: max(num1, num3)
|
|
mov rdi, [rel num1]
|
|
mov rsi, num3
|
|
call max
|
|
mov rsi, rax
|
|
xor rax, rax
|
|
lea rdi, [rel msgMax3]
|
|
call printf
|
|
;TEST: maxu(num1, num3)
|
|
mov rdi, [rel num1]
|
|
mov rsi, num3
|
|
call maxu
|
|
mov rsi, rax
|
|
xor rax, rax
|
|
lea rdi, [rel msgMax4]
|
|
call printf
|
|
;TEST: max(num1, num4)
|
|
mov rdi, [rel num1]
|
|
mov rsi, [rel num4]
|
|
call max
|
|
mov rsi, rax
|
|
xor rax, rax
|
|
lea rdi, [rel msgMax5]
|
|
call printf
|
|
;TEST: maxu(num1, num4)
|
|
mov rdi, [rel num1]
|
|
mov rsi, [rel num4]
|
|
call maxu
|
|
mov rsi, rax
|
|
xor rax, rax
|
|
lea rdi, [rel msgMax6]
|
|
call printf
|
|
;TEST: max(num2, num4)
|
|
mov rdi, [rel num2]
|
|
mov rsi, [rel num4]
|
|
call max
|
|
mov rsi, rax
|
|
xor rax, rax
|
|
lea rdi, [rel msgMax7]
|
|
call printf
|
|
;TEST: maxu(num2, num4)
|
|
mov rdi, [rel num2]
|
|
mov rsi, [rel num4]
|
|
call maxu
|
|
mov rsi, rax
|
|
xor rax, rax
|
|
lea rdi, [rel msgMax8]
|
|
call printf
|
|
%ENDIF
|
|
%IF TEST_strlen
|
|
lea rdi, [rel msgStrlen]
|
|
call puts
|
|
|
|
; TEST: strlen(str1)
|
|
lea rdi, [rel str1]
|
|
call strlen
|
|
mov rsi, rax
|
|
xor rax, rax
|
|
lea rdi, [rel msgStrlen1]
|
|
call printf
|
|
; TEST: strlen(str2)
|
|
lea rdi, [rel str2]
|
|
call strlen
|
|
mov rsi, rax
|
|
xor rax, rax
|
|
lea rdi, [rel msgStrlen2]
|
|
call printf
|
|
; TEST: strlen(str3)
|
|
lea rdi, [rel str3]
|
|
call strlen
|
|
mov rsi, rax
|
|
xor rax, rax
|
|
lea rdi, [rel msgStrlen3]
|
|
call printf
|
|
; TEST: strlen(str4)
|
|
lea rdi, [rel str4]
|
|
call strlen
|
|
mov rsi, rax
|
|
xor rax, rax
|
|
lea rdi, [rel msgStrlen4]
|
|
call printf
|
|
%ENDIF
|
|
%IF TEST_islower
|
|
lea rdi, [rel msgIslower]
|
|
call puts
|
|
|
|
; TEST: islower(str1[0])
|
|
lea rdi, [rel str1]
|
|
call islower
|
|
mov rsi, rax
|
|
xor rax, rax
|
|
lea rdi, [rel msgIslower1]
|
|
call printf
|
|
; TEST: islower(str1[1])
|
|
lea rdi, [rel str1+1]
|
|
call islower
|
|
mov rsi, rax
|
|
xor rax, rax
|
|
lea rdi, [rel msgIslower2]
|
|
call printf
|
|
; TEST: islower(str1[5])
|
|
lea rdi, [rel str1+5]
|
|
call islower
|
|
mov rsi, rax
|
|
xor rax, rax
|
|
lea rdi, [rel msgIslower3]
|
|
call printf
|
|
%ENDIF
|
|
%IF TEST_isupper
|
|
lea rdi, [rel msgIsupper]
|
|
call puts
|
|
|
|
; TEST: isupper(str1[0])
|
|
lea rdi, [rel str1]
|
|
call isupper
|
|
mov rsi, rax
|
|
xor rax, rax
|
|
lea rdi, [rel msgIsupper1]
|
|
call printf
|
|
; TEST: isupper(str1[1])
|
|
lea rdi, [rel str1+1]
|
|
call isupper
|
|
mov rsi, rax
|
|
xor rax, rax
|
|
lea rdi, [rel msgIsupper2]
|
|
call printf
|
|
; TEST: isupper(str1[5])
|
|
lea rdi, [rel str1+5]
|
|
call isupper
|
|
mov rsi, rax
|
|
xor rax, rax
|
|
lea rdi, [rel msgIsupper3]
|
|
call printf
|
|
%ENDIF
|
|
%IF TEST_strcpy
|
|
lea rdi, [rel msgStrcpy]
|
|
call puts
|
|
|
|
; TEST: strcpy(strBuff1, str4)
|
|
lea rdi, [rel strBuff1]
|
|
lea rsi, [rel str4]
|
|
call strcpy
|
|
mov rsi, rax
|
|
xor rax, rax
|
|
lea rdi, [rel msgStrcpy1]
|
|
call printf
|
|
; TEST: strcpy(strBuff1, str2)
|
|
lea rdi, [rel strBuff1]
|
|
lea rsi, [rel str2]
|
|
call strcpy
|
|
mov rsi, rax
|
|
xor rax, rax
|
|
lea rdi, [rel msgStrcpy2]
|
|
call printf
|
|
; TEST: strcpy(strBuff1, str1)
|
|
lea rdi, [rel strBuff1]
|
|
lea rsi, [rel str1]
|
|
call strcpy
|
|
mov rsi, rax
|
|
xor rax, rax
|
|
lea rdi, [rel msgStrcpy3]
|
|
call printf
|
|
%ENDIF
|
|
%IF TEST_strlcpy
|
|
lea rdi, [rel msgStrlcpy]
|
|
call puts
|
|
|
|
; TEST: strlcpy(strBuff2, str1, -1)
|
|
lea rdi, [rel strBuff2]
|
|
lea rsi, [rel str1]
|
|
mov rdx, -1
|
|
call strlcpy
|
|
mov rsi, rax
|
|
xor rax, rax
|
|
lea rdi, [rel msgStrlcpy1]
|
|
lea rdx, [rel strBuff2]
|
|
call printf
|
|
; TEST: strlcpy(strBuff2, str1, 0)
|
|
lea rdi, [rel strBuff2]
|
|
lea rsi, [rel str1]
|
|
mov rdx, 0
|
|
call strlcpy
|
|
mov rsi, rax
|
|
xor rax, rax
|
|
lea rdi, [rel msgStrlcpy2]
|
|
lea rdx, [rel strBuff2]
|
|
call printf
|
|
; TEST: strlcpy(strBuff2, str1, 5)
|
|
lea rdi, [rel strBuff2]
|
|
lea rsi, [rel str1]
|
|
mov rdx, 5
|
|
call strlcpy
|
|
mov rsi, rax
|
|
xor rax, rax
|
|
lea rdi, [rel msgStrlcpy3]
|
|
lea rdx, [rel strBuff2]
|
|
call printf
|
|
; TEST: strlcpy(strBuff2, str4, 8)
|
|
lea rdi, [rel strBuff2]
|
|
lea rsi, [rel str4]
|
|
mov rdx, 8
|
|
call strlcpy
|
|
mov rsi, rax
|
|
xor rax, rax
|
|
lea rdi, [rel msgStrlcpy4]
|
|
lea rdx, [rel strBuff2]
|
|
call printf
|
|
%ENDIF
|
|
%IF TEST_strclr
|
|
lea rdi, [rel msgStrclr]
|
|
call puts
|
|
|
|
; TEST: strclr(strBuff1)
|
|
lea rdi, [rel strBuff1]
|
|
call strclr
|
|
mov rsi, rax
|
|
xor rax, rax
|
|
lea rdx, [rel strBuff1]
|
|
lea rdi, [rel msgStrclr1]
|
|
call printf
|
|
; str3->strBuff1
|
|
lea rdi, [rel strBuff1]
|
|
lea rsi, [rel str3]
|
|
call strcpy
|
|
mov rsi, rax
|
|
xor rax, rax
|
|
lea rdi, [rel msgStrclr2]
|
|
call printf
|
|
; TEST: strclr(strBuff1)
|
|
lea rdi, [rel strBuff1]
|
|
call strclr
|
|
mov rsi, rax
|
|
xor rax, rax
|
|
lea rdi, [rel msgStrclr3]
|
|
lea rdx, [rel strBuff1]
|
|
call printf
|
|
%ENDIF
|
|
%IF TEST_strlclr
|
|
lea rdi, [rel msgStrlclr]
|
|
call puts
|
|
|
|
; TEST: strlclr(strBuff1, 32)
|
|
lea rdi, [rel strBuff1]
|
|
mov rsi, 32
|
|
call strlclr
|
|
xor rax, rax
|
|
lea rdi, [rel msgStrlclr1]
|
|
lea rsi, [rel strBuff1]
|
|
call printf
|
|
; str3->strBuff1
|
|
lea rdi, [rel strBuff1]
|
|
lea rsi, [rel str3]
|
|
call strcpy
|
|
mov rsi, rax
|
|
xor rax, rax
|
|
lea rdi, [rel msgStrlclr2]
|
|
call printf
|
|
; TEST: strlclr(strBuff1, 32)
|
|
lea rdi, [rel strBuff1]
|
|
mov rsi, 32
|
|
call strlclr
|
|
xor rax, rax
|
|
lea rdi, [rel msgStrlclr3]
|
|
lea rsi, [rel strBuff1]
|
|
call printf
|
|
%ENDIF
|
|
%IF TEST_strcat
|
|
lea rdi, [rel msgStrcat]
|
|
call puts
|
|
|
|
; TEST: strcat(strBuff1, str3)
|
|
lea rdi, [rel strBuff1]
|
|
lea rsi, [rel str3]
|
|
call strcat
|
|
mov rsi, rax
|
|
xor rax, rax
|
|
lea rdi, [rel msgStrcat1]
|
|
call printf
|
|
; CLEAR strBuff1
|
|
lea rdi, [rel msgStrcat2]
|
|
call puts
|
|
lea rdi, [rel strBuff1]
|
|
call strclr
|
|
; TEST: strcat(strBuff1, str1)
|
|
lea rdi, [rel strBuff1]
|
|
lea rsi, [rel str1]
|
|
call strcat
|
|
mov rsi, rax
|
|
xor rax, rax
|
|
lea rdi, [rel msgStrcat3]
|
|
call printf
|
|
; TEST: strcat(strBuff1, str3)
|
|
lea rdi, [rel strBuff1]
|
|
lea rsi, [rel str3]
|
|
call strcat
|
|
mov rsi, rax
|
|
xor rax, rax
|
|
lea rdi, [rel msgStrcat4]
|
|
call printf
|
|
%ENDIF
|
|
%IF TEST_tolower
|
|
lea rdi, [rel msgTolower]
|
|
call puts
|
|
|
|
lea rdi, [rel strBuff1]
|
|
lea rsi, [rel str3]
|
|
call strcpy
|
|
|
|
; TEST: tolower(strBuff1[0])
|
|
lea rdi, [rel strBuff1]
|
|
call tolower
|
|
mov rsi, rax
|
|
xor rax, rax
|
|
lea rdi, [rel msgTolower1]
|
|
call printf
|
|
|
|
; TEST: tolower() whole strBuff1
|
|
lea rdi, [rel strBuff1]
|
|
call strlen
|
|
mov rcx, rax
|
|
.tolowerLoop:
|
|
movzx r10, byte [rdi]
|
|
mov byte [rdi], r10b
|
|
mov r11, rcx
|
|
call tolower
|
|
mov rcx, r11
|
|
mov byte [rdi], al
|
|
inc rdi
|
|
inc r10
|
|
loop .tolowerLoop
|
|
xor rax, rax
|
|
lea rdi, [rel msgTolower2]
|
|
lea rsi, [rel strBuff1]
|
|
call printf
|
|
%ENDIF
|
|
%IF TEST_toupper
|
|
lea rdi, [rel msgToupper]
|
|
call puts
|
|
|
|
lea rdi, [rel strBuff1]
|
|
lea rsi, [rel str3]
|
|
call strcpy
|
|
|
|
; TEST: tolupper(strBuff1[0])
|
|
lea rdi, [rel strBuff1]
|
|
call toupper
|
|
mov rsi, rax
|
|
xor rax, rax
|
|
lea rdi, [rel msgToupper1]
|
|
call printf
|
|
|
|
; TEST: toupper() whole strBuff1
|
|
lea rdi, [rel strBuff1]
|
|
call strlen
|
|
mov rcx, rax
|
|
.toupperLoop:
|
|
movzx r10, byte [rdi]
|
|
mov byte [rdi], r10b
|
|
mov r11, rcx
|
|
call toupper
|
|
mov rcx, r11
|
|
mov byte [rdi], al
|
|
inc rdi
|
|
inc r10
|
|
loop .toupperLoop
|
|
xor rax, rax
|
|
lea rdi, [rel msgTolower2]
|
|
lea rsi, [rel strBuff1]
|
|
call printf
|
|
%ENDIF
|
|
%IF TEST_strcmp
|
|
lea rdi, [rel msgStrcmp]
|
|
call puts
|
|
|
|
lea rdi, [rel strBuff1]
|
|
mov rsi, 32
|
|
call strlclr
|
|
lea rdi, [rel strBuff1]
|
|
lea rsi, [rel str1]
|
|
call strcpy
|
|
lea rdi, [rel strBuff1+7]
|
|
call toupper
|
|
mov [strBuff1+7], al
|
|
|
|
xor rax, rax
|
|
lea rdi, [rel msgStrcmpStrs]
|
|
lea rsi, [rel str1]
|
|
lea rdx, [rel str2]
|
|
lea rcx, [rel str4]
|
|
lea r8, [rel strBuff1]
|
|
call printf
|
|
|
|
; TEST: strcmp(strbuff1, str1)
|
|
lea rdi, [rel strBuff1]
|
|
lea rsi, [rel str1]
|
|
call strcmp
|
|
mov rsi, rax
|
|
xor rax, rax
|
|
lea rdi, [rel msgStrcmp1]
|
|
call printf
|
|
; TEST: strcmp(str1, str2)
|
|
lea rdi, [rel str1]
|
|
lea rsi, [rel str2]
|
|
call strcmp
|
|
mov rsi, rax
|
|
xor rax, rax
|
|
lea rdi, [rel msgStrcmp2]
|
|
call printf
|
|
; TEST: strcmp(strBuff1, str2)
|
|
lea rdi, [rel strBuff1]
|
|
lea rsi, [rel str2]
|
|
call strcmp
|
|
mov rsi, rax
|
|
xor rax, rax
|
|
lea rdi, [rel msgStrcmp3]
|
|
call printf
|
|
; TEST: strcmp(str4, str1)
|
|
lea rdi, [rel str4]
|
|
lea rsi, [rel str1]
|
|
call strcmp
|
|
mov rsi, rax
|
|
xor rax, rax
|
|
lea rdi, [rel msgStrcmp4]
|
|
call printf
|
|
; TEST: strcmp(str1, str4)
|
|
lea rdi, [rel str1]
|
|
lea rsi, [rel str4]
|
|
call strcmp
|
|
mov rsi, rax
|
|
xor rax, rax
|
|
lea rdi, [rel msgStrcmp5]
|
|
call printf
|
|
; TEST: strcmp(str1, str1)
|
|
lea rdi, [rel str1]
|
|
mov rsi, rdi
|
|
call strcmp
|
|
mov rsi, rax
|
|
xor rax, rax
|
|
lea rdi, [rel msgStrcmp6]
|
|
call printf
|
|
%ENDIF
|
|
%IF TEST_file1
|
|
lea rdi, [rel msgFileB]
|
|
call puts
|
|
|
|
; TEST: fopen()
|
|
lea rdi, [rel testFile1]
|
|
mov rsi, 'w'
|
|
call fopen
|
|
%IF TEST_perror
|
|
lea rdi, [rel perror_fopen]
|
|
call perror
|
|
%ENDIf
|
|
mov r15, rax ;store filepointer to R15
|
|
mov rsi, rax
|
|
xor rax, rax
|
|
lea rdi, [rel msgFileB1]
|
|
call printf
|
|
|
|
; TEST: fwrite()
|
|
mov rdi, r15
|
|
lea rsi, [fileStr1]
|
|
call fwrite
|
|
%IF TEST_perror
|
|
lea rdi, [rel perror_fwrite]
|
|
call perror
|
|
%ENDIF
|
|
mov rsi, rax
|
|
xor rax, rax
|
|
lea rdi, [rel msgFileB2]
|
|
call printf
|
|
|
|
; TEST: fclose()
|
|
mov rdi, r15
|
|
call fclose
|
|
%IF TEST_perror
|
|
lea rdi, [rel perror_fclose]
|
|
call perror
|
|
%ENDIF
|
|
mov rsi, rax
|
|
xor rax, rax
|
|
lea rdi, [rel msgFileB3]
|
|
call printf
|
|
%ENDIF
|
|
|
|
leave
|
|
mov rdi, 0
|
|
call exit
|