[win32asm] arguments ligne de commande

Soyez le premier à donner votre avis sur cette source.

Vue 11 509 fois - Téléchargée 489 fois

Description

Ce petit code vous permet de récupérer les arguments de la ligne de commande de
la même manière qu'en langage C (avec argc et argv).
J'ai développé ce code sous MASM32, mais théoriquement il devrait aussi
fonctionner avec TASM, ou tout autre assembleur Win32ASM.

Pour revenir au code, placez-le à l'endroit où vous appelez habituellement
GetCommandLine() et déclarez les deux variables suivantes dans la section
data? :

argc db ?
argv dd 256 dup(?)

- argc contient le nombre d'arguments. S'il n'y a pas d'arguments, argc == 1
(le nom et le path du programme);
- argv est un tableau de pointeurs, par exemple si vous voulez récupérer le
premier argument vous faites argv + 4,pour le deuxième argument argv + 8, etc...

Source / Exemple :


; Win32ASM command-line arguments
; By Dean (based on a code of comrade)

call GetCommandLine      ; get the command-line string
mov esi, eax             ; store the pointer in esi
lea edi, argv            ; mov in edi the address of argv
xor ecx, ecx             ; reset ecx

cl_skipspace:
cmp byte ptr [esi], 0    ; if we are at the end
je cl_end                ; exit
cmp byte ptr [esi], 32   ; else if the character is not a space
jne cl_findarg           ; find the argument
inc esi                  ; move of one character in the command-line
jmp cl_skipspace         ; skip the spaces

cl_findarg:
mov eax, esi             ; store the pointer on the rest of the command-line in eax
mov edx, 32              ; edx = 32 ([space] character)
cmp byte ptr [esi], 34   ; the first character of the argument is a quote ?
sete cl                  ; in this case, cl = 1 (else cl = 0)
lea edx, [edx + ecx * 2] ; edx = [space] or [quote]
add eax, ecx             ; if the first character is a quote, we move of one character

cl_parsearg:
inc esi                  ; go on the next character
cmp byte ptr [esi], 0    ; we are at the end ?
je cl_storelastarg       ; ok, store the last argument in the argv array
cmp byte ptr [esi], dl   ; the character is a [space] or a [quote] ?
jne cl_parsearg          ; no, continue to parse the argument
mov byte ptr [esi], 0    ; else put a [null] character at the end of the argument
stosd                    ; store the pointer in argv
inc argc                 ; increment the counter
inc esi                  ; get the next character
jmp cl_skipspace         ; skip the spaces until the new argument

cl_storelastarg:
stosd                    ; store the pointer in argv
inc argc                 ; increment the counter

cl_end:

Conclusion :


Limitations :
- le nombre maximum d'arguments est de 256. Je pense que ça suffira, si vous
avez besoin de plus d'arguments vous pouvez changer le type des variables argc
et argv;
- l'appel à la ligne de commande peut contenir des espaces ( ) et des
guillemets ("), cependant les apostrophes (') ne sont pas prises en compte comme
"délimiteurs" d'arguments.
- les arguments ne sont pas codés en Unicode (2 octets par caractère).

Je ne pense pas que ces limitations soient importantes pour une utilisation
classique, cependant je tenais à les signaler.

Bugs :

Tous les types d'appels possibles ont été testés (Windows, ligne de commande
DOS, debugger), et aucun bug n'a été décelé. Si vous détectez un bug, n'hésitez
pas à me contacter.

Pour finir, je tiens à remercier comrad du forum Win32ASMCommunity.net, qui m'a
fourni les bases de mon code.

Codes Sources

A voir également

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.