Hi Guys
I'm sure what I'm trying to do is straightforward, however, I'm getting nowhere.
I'm trying to convert a decimal number which is in ASCII format (user input) to an unsigned hexadecimal (binary) number.
The number, when converted, will not exceed 64 bits in length.
I've tried atoi and GetDlgItemInt, both of which only seem to support 32 bit integers.
I use WinAsm and Masm32 as they were released, so I'm not comfortable with using something like MasmBasic, surely there must be some built in API that can achieve this? It just seems to be the reverse of sprintf %llu.
Kind regards, and thanks in advance.
It is indeed possible with MasmBasic:
include \masm32\MasmBasic\MasmBasic.inc
SetGlobals MyQ:QWORD
Init
Let esi="-4995072469926809587"
MovVal MyQ, esi
Print Hex$(MyQ)
EndOfCode
Output: BAADF00D BAADF00D
Check SOF (https://stackoverflow.com/questions/28777876/how-to-scanf-long-long-long-int-in-c), they might have a solution.
Something like this? This is for unsigned integers.
From masm64.lib "atou_ex"
; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
.code
; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
atou_ex proc
; ------------------------------------------------
; Convert decimal string into UNSIGNED QWORD value
; ------------------------------------------------
; argument in RCX
xor r11, r11
movzx rax, BYTE PTR [rcx]
test rax, rax
jz quit
lea r11, [r11+r11*4]
lea r11, [rax+r11*2-48]
movzx rax, BYTE PTR [rcx+1]
test rax, rax
jz quit
lea r11, [r11+r11*4]
lea r11, [rax+r11*2-48]
movzx rax, BYTE PTR [rcx+2]
test rax, rax
jz quit
lea r11, [r11+r11*4]
lea r11, [rax+r11*2-48]
movzx rax, BYTE PTR [rcx+3]
test rax, rax
jz quit
lea r11, [r11+r11*4]
lea r11, [rax+r11*2-48]
movzx rax, BYTE PTR [rcx+4]
test rax, rax
jz quit
lea r11, [r11+r11*4]
lea r11, [rax+r11*2-48]
movzx rax, BYTE PTR [rcx+5]
test rax, rax
jz quit
lea r11, [r11+r11*4]
lea r11, [rax+r11*2-48]
movzx rax, BYTE PTR [rcx+6]
test rax, rax
jz quit
lea r11, [r11+r11*4]
lea r11, [rax+r11*2-48]
movzx rax, BYTE PTR [rcx+7]
test rax, rax
jz quit
lea r11, [r11+r11*4]
lea r11, [rax+r11*2-48]
movzx rax, BYTE PTR [rcx+8]
test rax, rax
jz quit
lea r11, [r11+r11*4]
lea r11, [rax+r11*2-48]
movzx rax, BYTE PTR [rcx+9]
test rax, rax
jz quit
lea r11, [r11+r11*4]
lea r11, [rax+r11*2-48]
movzx rax, BYTE PTR [rcx+10]
test rax, rax
jz quit
lea r11, [r11+r11*4]
lea r11, [rax+r11*2-48]
movzx rax, BYTE PTR [rcx+11]
test rax, rax
jz quit
lea r11, [r11+r11*4]
lea r11, [rax+r11*2-48]
movzx rax, BYTE PTR [rcx+12]
test rax, rax
jz quit
lea r11, [r11+r11*4]
lea r11, [rax+r11*2-48]
movzx rax, BYTE PTR [rcx+13]
test rax, rax
jz quit
lea r11, [r11+r11*4]
lea r11, [rax+r11*2-48]
movzx rax, BYTE PTR [rcx+14]
test rax, rax
jz quit
lea r11, [r11+r11*4]
lea r11, [rax+r11*2-48]
movzx rax, BYTE PTR [rcx+15]
test rax, rax
jz quit
lea r11, [r11+r11*4]
lea r11, [rax+r11*2-48]
movzx rax, BYTE PTR [rcx+16]
test rax, rax
jz quit
lea r11, [r11+r11*4]
lea r11, [rax+r11*2-48]
movzx rax, BYTE PTR [rcx+17]
test rax, rax
jz quit
lea r11, [r11+r11*4]
lea r11, [rax+r11*2-48]
movzx rax, BYTE PTR [rcx+18]
test rax, rax
jz quit
lea r11, [r11+r11*4]
lea r11, [rax+r11*2-48]
movzx rax, BYTE PTR [rcx+19]
test rax, rax
jz quit
lea r11, [r11+r11*4]
lea r11, [rax+r11*2-48]
movzx rax, BYTE PTR [rcx+20]
test rax, rax
jnz out_of_range
quit:
lea rax, [r11] ; return value in EAX
or rcx, -1 ; non zero in RCX for success
ret
out_of_range:
xor rax, rax ; zero return value on error
xor rcx, rcx ; zero in ECX is out of range error
ret
atou_ex endp
; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
end
Quote from: zedd151 on August 18, 2023, 12:07:59 AMSomething like this? This is for unsigned integers.
I'm using MASM32, I don't suppose that you have anything in 32 bit?
Quote from: colinr on August 18, 2023, 12:10:29 AMI'm using MASM32, I don't suppose that you have anything in 32 bit?
Ok, I just read that, I missed it the first time. Sorry.
I didn't realise that you were looking for ascii to qword conversion for masm32 code.
I don't have anything offhand, for 32 bit.
See qw.zìp attached in reply #1.
-4995072469322841890 is a nice decimal to play with.
Quote from: jj2007 on August 18, 2023, 12:38:57 AMSee qw.zìp attached in reply #1.
-4995072469322841890 is a nice decimal to play with.
I can't seem to get my head around the syntax, if I don't have any luck with figuring this out via WinAPI or something I write, I'll stand it up in a clean environemnt as the project is too advanced to change how it works at the moment.
The simple example I posted in reply #1 assembles fine with a standard Masm32 installation, and I didn't use any special syntax. Explain why you have difficulties.
Quote from: jj2007 on August 18, 2023, 01:30:32 AMExplain why you have difficulties.
Init - ??
Let esi="-4995072469926809587" -- ESI is a 32 bit register, how can it contain this ASCII value or is it a pointer?
MovVal MyQ, esi -- Makes more sense, but why MovVal and not mov?
Print Hex$(MyQ) -- How do I access MyQ as a 64 bit hex value, exampe:
mov eax, [GET_LENGTH_INFORMATION].dLength
mov ebx, [GET_LENGTH_INFORMATION].dLength+4
Quote from: jj2007 on August 18, 2023, 01:30:32 AMExplain why you have difficulties.
1. Code from the zip does not match the code posted.
Code from zip file...
include \masm32\include\masm32rt.inc
.data
MyQ dq ?
.code
start:
print "Type your number: "
invoke crt_scanf, chr$("%llu"), addr MyQ
printf("The number read was %llx\n", MyQ)
inkey " "
exit
end startThe code from the zip
assembles fine with "Console Assemble & Link" from qeditors menu.
And
runs okay... result:
Type your number: 123456789123456789
The number read was 1b69b4bacd05f15
####################################################
Quote from: jj2007 on August 18, 2023, 01:30:32 AMExplain why you have difficulties.
2. Perhaps the code posted is a little misleading (references to MasmBasic)? Not the exact same code as in the zip file.
Posted code...
include \masm32\MasmBasic\MasmBasic.inc
SetGlobals MyQ:QWORD
Init
Let esi="-4995072469926809587"
MovVal MyQ, esi
Print Hex$(MyQ)
EndOfCode
Quote from: jj2007 on August 18, 2023, 12:38:57 AMSee qw.zìp attached in reply #1.
Plain Masm32 SDK code.
Quote from: zedd151 on August 18, 2023, 02:01:24 AMinclude \masm32\include\masm32rt.inc
.data
MyQ dq ?
.code
start:
print "Type your number: "
invoke crt_scanf, chr$("%llu"), addr MyQ
printf("The number read was %llx\n", MyQ)
inkey " "
exit
end start
Now this is looking more understandable, it apprears that crt_scanf is converting the inputted number to a QWORD, how could I do this if the value was taken from an input box on a dialog? I know how to use GetDlgItemText, just not how to take the numerical text value and convert it to the hex value.
I think I have found an answer for you.
include \masm32\include\masm32rt.inc
WndProc PROTO :DWORD,:DWORD,:DWORD,:DWORD
.data
dlgname db "TESTWIN",0
hInstance dd 0
Longnumber dq 0
longNumStr db 32 dup (0)
fmt1 db "%llu", 0
.code
start:
; #########################################################################
invoke GetModuleHandle, NULL
mov hInstance, eax
invoke DialogBoxParam,hInstance,ADDR dlgname,0,ADDR WndProc,0
invoke ExitProcess,eax
; #########################################################################
WndProc proc hWin:DWORD, uMsg:DWORD, wParam:DWORD, lParam:DWORD
.if uMsg == WM_COMMAND
.if wParam == 1000
invoke GetDlgItemText, hWin, 100, addr longNumStr, 32 ; get the long ascii string into buffer
invoke crt_sscanf, addr longNumStr, addr fmt1, addr Longnumber ; using crt_sscanf "Longnumber" will hold your qword value after conversion...
.endif
.elseif uMsg == WM_CLOSE
invoke EndDialog,hWin,0
.endif
xor eax, eax
ret
WndProc endp
; ########################################################################
end start
You can play around with it a bit for further conversion of the qword to readable format (ascii representation of the qword). :smiley:
I only got as far as testing it in ollydbg... works apparently. :tongue:
results from this code with "123456789123456789" as input:
15 5F D0 AC 4B 9B B6 01 as seen in ollydbg dump window
results from above posting:
QuoteType your number: 123456789123456789
The number read was 1b69b4bacd05f15
It took me a little while to get everything together and working as expected. :cool:
I had never really had the need myself, so we both learned something today. :biggrin:
Quote from: zedd151 on August 18, 2023, 04:06:01 AMI had never really had the need myself, so we both learned something today. :biggrin:
Thank you very much, all that is needed is: invoke crt_sscanf, addr longNumStr, addr fmt1, addr Longnumber
As long the string is null terminated, it will work.
Just used "12345678123456", Longnumber ended up being populated with 004045A4 C0 51 C2 73|3A 0B
Perfect, turned out to be a simple solution to what could have been a lot of convoluted code.
Quote from: colinr on August 18, 2023, 04:52:33 AMQuote from: zedd151 on August 18, 2023, 04:06:01 AMI had never really had the need myself, so we both learned something today. :biggrin:
Perfect, turned out to be a simple solution to what could have been a lot of convoluted code.
Perfectly understandable. Some of my first attempts were indeed convoluted. :biggrin: I had the arguments in the wrong order once, and tried a different API with odd results.
Sheesh; it ain't that complicated.
Here's a li'l testbed that does exactly what the OP wants: takes an ASCII decimal string and converts it to a quadword value, using 32-bit code. Tested, works.
Here's the heart of it, the function that does the conversion:
;====================================
; A2Q()
;
; Converts ASCII string to quadword binary value.
;
; On entry,
; EAX--> ASCII string
; Returns:
; EDX:EAX = binary value
;
; Tested: 8/17/23 --works--
;====================================
A2Q PROC
PUSH EBX
PUSH ESI
PUSH EDI
XOR EBX, EBX ;EDI:EBX = accumulator.
XOR EDI, EDI
MOV ESI, EAX
nxtdgt: XOR EAX, EAX
LODSB
TEST AL, AL
JZ done
SUB AL, '0' ;ASCII--> binary.
; Multiply accum. X 10 (64x32-bit multiply):
PUSH ESI
PUSH EAX ;Save digit just seen.
MOV EAX, EBX
MUL Ten
MOV ESI, EDX
MOV ECX, EAX ;ESI:ECX = partial product.
MOV EAX, EDI
MUL Ten
ADD ESI, EAX
POP EAX ;Get back current digit.
ADD ECX, EAX ;Add it in to accum.
ADC ESI, 0 ;Handle any carry.
MOV EDI, ESI ;Store new accum.
MOV EBX, ECX
POP ESI
JMP nxtdgt
done: MOV EAX, EBX
MOV EDX, EDI
POP EDI
POP ESI
POP EBX
RET
A2Q ENDP
Testbed program attached.
I'm sure the performance vultures are going to swoop down and point out the eleven ways from Sunday how this is inefficient, not fast enough, etc. So let me be the first to point out that this is a fairly dumbass way to do the conversion. I'm sure someone could figure out a clever way, using a bunch of XCHGs, to simplify this. But hey, it's pretty simple and IT WORKS. (Oh, yeah, you need to add a "Ten DD 10" in your .data section.)
Any questions?
A little more on a crucial part of my conversion routine, which is the 64x32-bit multiply. Looking online, I found a world of confusion over this topic, which again just ain't that complicated. Found loooooong, long discussions on places like Stack Overflow and the like which only devolved into total confusion. Then there was a comment in one of these discussions by none other than the estimable Raymond Chen, who said, basically, "work it out on paper: it's just like old-fashioned multiplication". Which it is.
The diagram below should explain this. Rather than try to copy any of the tortured, convoluted code examples that abounded on these sites, I just sat down with paper and pencil (!) and came up with a simple working routine. It ain't rocket surgery.
OK, just to cover my ass here: yes, technically this is an incomplete solution, because properly speaking a 64x32 bit multiply can yield up to a 96-bit result; it could result in overflow.
However, i think this satisfies the OP's question pretty well. Since the maximum value of a 64-bit (unsigned) number is 18,446,744,073,709,551,615 (what is that, 18-bazillion-something?), don't think there's much danger of running out of room unless you're dealing with astronomical quantities.
Quote from: NoCforMe on August 18, 2023, 06:46:50 AMAny questions?
Wow, I like it.
Will test as soon as I get the chance, which may not be until early next week now.
I don't think i'll get anywhere near exhausting the maximum number as the converted number is actually an offset into \\.\Physicaldrive
I never expected the code to be so short, a lot of thought has clearly gone into this as it's all done in registers and they need preserving between calculations.
I was looking to do this by iterating through the ASCII numbers backwards (obviously!) subtracting 30h from each one and then multiplying it by its ^10 and then subsequently adding that value to a QWORD, I knew it would be inefficient hence my reason to post on here as there had to be a simpler, more efficient way of achieving this.
Kudos to all the posters that have come up with various solutions, I'm sure there will be many others that will encounter this problem and discover this thread.
This has got me thinking now about going the other way, 64 bit unsigned to an arbitrary length ASCII decimal string without any leading zeros.
Is there an efficient way to do this? I'm currently using sprintf for these conversions, but it is not efficient and certainly not secure.
I think this is one for you Mr NoCforMe!
Quote from: colinr on September 07, 2023, 08:50:50 AMIs there an efficient way to do this?
There are several ways to do this. (https://masm32.com/board/index.php?topic=221.msg68323#msg68323) Latest version:
Intel(R) Core(TM) i5-2450M CPU @ 2.50GHz (SSE4)
30187 cycles for 100 * MasmBasic Str$()
102430 cycles for 100 * CRT sprintf
5150 cycles for 100 * uqword (Paul Dixon)
30660 cycles for 100 * MasmBasic Str$()
101666 cycles for 100 * CRT sprintf
5114 cycles for 100 * uqword (Paul Dixon)
29921 cycles for 100 * MasmBasic Str$()
101694 cycles for 100 * CRT sprintf
5108 cycles for 100 * uqword (Paul Dixon)
29902 cycles for 100 * MasmBasic Str$()
102012 cycles for 100 * CRT sprintf
5145 cycles for 100 * uqword (Paul Dixon)
29846 cycles for 100 * MasmBasic Str$()
101773 cycles for 100 * CRT sprintf
5158 cycles for 100 * uqword (Paul Dixon)
47 bytes for MasmBasic Str$()
36 bytes for CRT sprintf
711 bytes for uqword (Paul Dixon)
1234567890123456789 for MasmBasic Str$()
1234567890123456789 for CRT sprintf
1234567890123456789 for uqword (Paul Dixon)
Quote from: NoCforMe on August 18, 2023, 06:46:50 AMTestbed program attached.
I'm sure the performance vultures are going to swoop down and point out the eleven ways from Sunday how this is inefficient, not fast enough, etc. So let me be the first to point out that this is a fairly dumbass way to do the conversion. I'm sure someone could figure out a clever way, using a bunch of XCHGs, to simplify this. But hey, it's pretty simple and IT WORKS. (Oh, yeah, you need to add a "Ten DD 10" in your .data section.)
Any questions?
Just a quick one, It may be an issue my side, but I'll thow it here just in case.
I'm using this code in conjuction with the API call SetFilePointer.
Basically, when I'm seeking into a file precisely 2GB, it fails, I don't have the error code, but I think it might be something to do with it being converted to a signed integer? I'm still investigating this, but is this plausable?
Kind Regards
You probably need to specify the high order dword to move as well > 2Gb or as you suspected it will use that value as a negative and move back if possible (signed dword value).
https://learn.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-setfilepointer
[in] lDistanceToMoveThe low order 32-bits of a signed value that specifies the number of bytes to move the file pointer.
If lpDistanceToMoveHigh is not NULL, lpDistanceToMoveHigh and lDistanceToMove form a single 64-bit signed value that specifies the distance to move.
If lpDistanceToMoveHigh is NULL, lDistanceToMove is a 32-bit signed value. A positive value for lDistanceToMove moves the file pointer forward in the file, and a negative value moves the file pointer back.
[in, out, optional] lpDistanceToMoveHighA pointer to the high order 32-bits of the signed 64-bit distance to move.
If you do not need the high order 32-bits, this pointer must be set to NULL.
When not NULL, this parameter also receives the high order DWORD of the new value of the file pointer. For more information, see the Remarks section in this topic.
Or you can use the SetFilePointerEx and specify a qword size to move: https://learn.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-setfilepointerex
Quote from: fearless on September 08, 2023, 12:07:33 AMYou probably need to specify the high order dword to move as well > 2Gb or as you suspected it will use that value as a negative and move back if possible (signed dword value).
I'm specifying both, besides the high order would not be required for 2GB.
It would be much easier to help you if you posted code. Now it's just guessing, and I assure you our crystal balls suck :cool:
lpDistanceToMoveHigh
Points to the high-order word of the 64-bit distance to move. If the value of this parameter is NULL, SetFilePointer can operate only on files whose maximum size is 2^32 - 2. If this parameter is specified, the maximum file size is 2^64 - 2. This parameter also receives the high-order word of the new value of the file pointer.
To reiterate what fearless and jj2007 are telling you, read this https://learn.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-setfilepointer
It explains what you need to know.
It would be very helpful if you posted the code that is giving you these problems, full source preferred, but the code using the call might help as well, if you don't want to post the full source code for some reason.
Here is the code extract:
;EDX:EAX = binary value
lea eax, Parameter2 ;contains ASCII decimal string
call A2Q
mov OffsetHigh, edx
mov OffsetLow, eax
Followed by:
invoke SetFilePointer, DHandle, OffsetLow, OffsetHigh, FILE_BEGIN
Sorry for the brevity, just extremely busy.
I'll try and do some debugging with Olly when I get the chance, a million things going on at the moment!
Quote from: colinr on September 08, 2023, 03:10:12 AMinvoke SetFilePointer, DHandle, OffsetLow, OffsetHigh, FILE_BEGIN
SetFilePointer, hFile, LONG lDistanceToMove, PLONG lpDistanceToMoveHigh, DWORD dwMoveMethod
Quote from: jj2007 on September 08, 2023, 02:27:04 AMIt would be much easier to help you if you posted code. Now it's just guessing, and I assure you our crystal balls suck :cool:
lpDistanceToMoveHigh
Points to the high-order word of the 64-bit distance to move.
Quote from: jj2007 on September 08, 2023, 03:55:01 AMPoints to the high-order word of the 64-bit distance to move.
So it should look like this:
invoke SetFilePointer, DHandle, OffsetLow, addr OffsetHigh, FILE_BEGIN