+ Répondre à la discussion
Affichage des résultats 1 à 17 sur 17

Discussion: Chargement de fichier

  1. #1
    Invité de passage
    Profil pro
    Inscrit en
    février 2012
    Messages
    9
    Détails du profil
    Informations personnelles :
    Localisation : Belgique

    Informations forums :
    Inscription : février 2012
    Messages : 9
    Points : 0
    Points
    0

    Par défaut Chargement de fichier

    Bonjour a tous,

    J'aimerai bien réaliser un petit programme en assembleur, son utilité serait de retourner entièrement un petit fichier hexadécimal de max 64Ko, il serait chouette si on pourrait l'utiliser de cette façon impec.exe progaretourner.bin -re
    Je ne connais pas grand chose à l'assembleur sur PC. J'ai bien fait des recherches sur le net on parle des int 21h... Pas facile sans des exemples concrets.Si quelqu'un sait m'aider. Merci pour votre aide

  2. #2
    Membre Expert
    Avatar de Forthman
    Homme Profil pro
    conception mécanique
    Inscrit en
    janvier 2005
    Messages
    509
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 39
    Localisation : France, Tarn et Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : conception mécanique
    Secteur : Industrie

    Informations forums :
    Inscription : janvier 2005
    Messages : 509
    Points : 1 120
    Points
    1 120

    Par défaut

    Ni une ni deux, je te refiles mon exercice d'info...

  3. #3
    Invité de passage
    Profil pro
    Inscrit en
    février 2012
    Messages
    9
    Détails du profil
    Informations personnelles :
    Localisation : Belgique

    Informations forums :
    Inscription : février 2012
    Messages : 9
    Points : 0
    Points
    0

    Par défaut ca galere a l'aide

    Et bien voila, j'ai acheté un livre pas loin des 60 euros et dedans il y a une routine intéressante pour charger un fichier en memoire comme je veux le probleme c'est que ca va pas quelqu'un sait m'aider et trouver les bugs ?


    alors il dit
    size permet de retourner soit la taille totale du fichier si aucune lecture n'est faite, soit le nombre d'octets lus
    path pointe vers une chaine de caracteres contenant le chemin du fichier
    fptr pointe vers un descripteur de zone de memoire
    off pointe vers le premier octet a charger a l'interieur du fichier

    j'ai assemble le tout avec fasm et ça bloque sur OFF

    Code asm :
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    DOSread:
            push eax ebx ecx edx edi esi
            mov edi,[.fptr]
            mov edx,[.path]
            or edx,edx
            je .error
            mov ax,[edx+2]
            mov dx,[edx+0]
            push ds
            or ax,ax
            je @f
            mov ds,ax
    @@:
            mov ax,3d00h
            int 21h
            pop dx
            jc .error
            or edi,edi
            je .close
            mov bx,ax
            mov ah,42h
            mov al,0
            mov cx,[.off+2]
            mov dx,[.off]
            int 21h
            jc .error
            mov ax,[edi+2]
            mov dx,[edi+0]
            mov ecx,[edi+4]
            push ds
            or ax,ax
            je @f
            mov ds,ax
    @@:
            mov ah,3fh
            int 21h
            pop ds
            jc .error
            movzx eax,ax
            mov [edi+fptr.size],eax
     
    @@:     
            mov ah,3eh
            int 21h
            jc .error
     
    .end:
            pop esi edi edx ecx ebx eax
            ret
    .close:
            call .id
            jmp @b
    .error:
            mov dword[.size],0
            jmp .end
     
    .id :   mov ah,42h
            mov al,2
            mov cx,0
            mov dx,0
            int 21h
            mov word[.size],ax
            mov word[.size+2],dx
            ret
    .off dd 4000h
    .size dd 4000h
    .path dd c:\pouet.bin
    .fptr dd 4000h

  4. #4
    Membre confirmé Avatar de golden boy
    Homme Profil pro
    Étudiant
    Inscrit en
    novembre 2010
    Messages
    120
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : novembre 2010
    Messages : 120
    Points : 216
    Points
    216

    Par défaut

    Tu n'aurais pas oublié des deux-points ':' après ton .off, .path etc. ?

  5. #5
    Invité de passage
    Profil pro
    Inscrit en
    février 2012
    Messages
    9
    Détails du profil
    Informations personnelles :
    Localisation : Belgique

    Informations forums :
    Inscription : février 2012
    Messages : 9
    Points : 0
    Points
    0

    Par défaut quelques parentheses en moins !

    Et bien j'ai enlevé les parentheses a path ligne 3 ainsi qu a off et off+2 et modifié la variable db pour le nom je ne sais pas si c'est la bonne solution en tout cas j'ai réussi a compiler le prog, j'aimerai bien voir s'il fonctionne comment je dois faire pour voir s'il a bien charger mon programme test.bin en 0030h:4000h ? j'ai essayé avec debug du dos option d 0030:4000 j'ai pas ce qui faut ou est l'erreur ?



    Code asm :
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    DOSread:
    	push eax ebx ecx edx edi esi
    	mov edi,[.fptr]
    	mov edx,.path
    	or edx,edx
    	je .error
    	mov ax,[edx+2]
    	mov dx,[edx+0]
    	push ds
    	or ax,ax
    	je @f
    	mov ds,ax
    @@:
    	mov ax,3d00h
    	int 21h
    	pop dx
    	jc .error
    	or edi,edi
    	je .close
    	mov bx,ax
    	mov ah,42h
    	mov al,0
    	mov cx,.off+2
    	mov dx,.off
    	int 21h
    	jc .error
    	mov ax,[edi+2]
    	mov dx,[edi+0]
    	mov ecx,[edi+4]
    	push ds
    	or ax,ax
    	je @f
    	mov ds,ax
    @@:
    	mov ah,3fh
    	int 21h
    	pop ds
    	jc .error
    	movzx eax,ax
    	mov [edi+8000h],eax
     
    @@:	
    	mov ah,3eh
    	int 21h
    	jc .error
     
    .end:
    	pop esi edi edx ecx ebx eax
    	ret
    .close:
    	call .id
    	jmp @b
    .error:
    	mov dword[.size],0
    	jmp .end
     
    .id:	
    	mov ah,42h
    	mov al,2
    	mov cx,0
    	mov dx,0
    	int 21h
    	mov word[.size],ax
    	mov word[.size+2],dx
    	ret
     
    .off dd 0030h:4000h
    .size dd 0030h:4000h
    .path db "c:\test.bin"
    .fptr dd 0030h:4000h

  6. #6
    Membre chevronné Avatar de edfed
    être humain
    Inscrit en
    décembre 2007
    Messages
    471
    Détails du profil
    Informations professionnelles :
    Activité : être humain

    Informations forums :
    Inscription : décembre 2007
    Messages : 471
    Points : 628
    Points
    628

    Par défaut

    Citation Envoyé par velus Voir le message
    Code :
    1
    2
    3
    4
    5
     
    .off dd 4000h
    .size dd 4000h
    .path dd c:\pouet.bin
    .fptr dd 4000h
    sont des pointeurs pour la plupart.

    .off sert à indiquer l'adresse de debut de lecture dans le fichier, ici, tu lis à partir du 4000hième octet.

    .path doit pointer vers un pointeur de chaine, car l'interruption 21h, avec ax=3d00h attend le pointeur ds:dx vers une chaine de caractère asciiz.

    .fptr pointe vers une structure fptr indiquant la zone de mémoire à charger et sa taille.

    .size n'est pas utilisé en entrée, il est utilisable en sortie donc, pas besoin de l'initialiser.

    au final, il faut ecire ça
    Code :
    1
    2
    3
    4
    5
    6
    7
    8
    9
     
    .off: dd 0;pour lire dès le premier octet
    .size: dd ?;
    .path: dd chemin; indique le pointeur de chaine
    .fptr: dd ram;
     
    ram: dd 30h:4000h,0ffffh;
    chemin: dd 0:fichier
    fichier: db "c:/pouet.bin",0
    pour tester, tu peux essayer ceci:
    Code :
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
     
     
            org 100h
            call DOSread
            push es 0b800h
            pop es
            mov si,buffer
            mov di,0
            mov ah,67h
    @@:
            lodsb
            cmp al,0
            je @f
            stosw
            jmp @b
    @@:
            pop es
            ret
    fptr:
    .off=0
    .seg=2
    .size=4
    DOSread:
            push eax ebx ecx edx edi esi
            mov edi,[.fptr]
            mov edx,[.path]
            or edx,edx
            je .error
            mov ax,[edx+fptr.seg]
            mov dx,[edx+fptr.off]
            push ds
            or ax,ax
            je @f
            mov ds,ax
    @@:
            mov ax,3d00h
            int 21h
            pop dx
            jc .error
            or edi,edi
            je .close
            mov bx,ax
            mov ah,42h
            mov al,0
            mov cx,[.off+2]
            mov dx,[.off]
            int 21h
            jc .error
            mov ax,[edi+fptr.seg]
            mov dx,[edi+fptr.off]
            mov ecx,[edi+fptr.size]
            push ds
            or ax,ax
            je @f
            mov ds,ax
    @@:
            mov ah,3fh
            int 21h
            pop ds
            jc .error
            movzx eax,ax
            mov [edi+fptr.size],eax
     
    @@:     
            mov ah,3eh
            int 21h
            jc .error
     
    .end:
            pop esi edi edx ecx ebx eax
            ret
    .close:
            call .id
            jmp @b
    .error:
            mov dword[.size],0
            jmp .end
     
    .id :   mov ah,42h
            mov al,2
            mov cx,0
            mov dx,0
            int 21h
            mov word[.size],ax
            mov word[.size+2],dx
            ret
    .off:   dd 0
    .size:  dd 0
    .path:  dd chemin
    .fptr:  dd zone
     
    zone    dd 0:buffer,1000
    chemin  dd 0:fichier
    fichier db "c:/pouet.inc",0
    buffer: rb 1000
    et normalement, ça marche.

  7. #7
    Invité de passage
    Profil pro
    Inscrit en
    février 2012
    Messages
    9
    Détails du profil
    Informations personnelles :
    Localisation : Belgique

    Informations forums :
    Inscription : février 2012
    Messages : 9
    Points : 0
    Points
    0

    Par défaut encore un p'tit effort

    Merci pour la solution

    Je viens de tester ça, je ne retrouve pas mon fichier pouet.inc en memoire ou est-il exactement ? Est-ce qu'il a bien été chargé ? Désolé je suis vraiment novice sur l'assembleur

  8. #8
    Membre chevronné Avatar de edfed
    être humain
    Inscrit en
    décembre 2007
    Messages
    471
    Détails du profil
    Informations professionnelles :
    Activité : être humain

    Informations forums :
    Inscription : décembre 2007
    Messages : 471
    Points : 628
    Points
    628

    Par défaut

    ici, le premier octet du fichier chargé en mémoire est à l'adresse buffer:, tout à la fin du code, dans le segment DS qui pointe au meme endroit que le segment CS ( ES et SS egalement) car c'est un executable DOS .com.


    la routine d'affichage de l'exemple pointe sur buffer:, qui est aussi l'adresse de chargement du fichier.

    le fait que le contenu du fichier s'affiche signifie qu'il est chargé en mémoire, sinon, il ne s'afficherait rien du tout ou n'importe quoi.

  9. #9
    Invité de passage
    Profil pro
    Inscrit en
    février 2012
    Messages
    9
    Détails du profil
    Informations personnelles :
    Localisation : Belgique

    Informations forums :
    Inscription : février 2012
    Messages : 9
    Points : 0
    Points
    0

    Par défaut rien en memoire

    Salut j'ai bien compris que ca devrait etre en 1000 mais moi je ne trouve aucun octet chargé, comment je fais pour être sur que c'est dedans. J'ai fait des tests avec debug du dos

    je tape debug d pour desassembler

    d 1000 rien pas les bons octets
    d 0000:1000 rien pas les bons octets
    d 1000:1000 rien pas les bons octets

    ou est-il alors ?

  10. #10
    Membre chevronné Avatar de edfed
    être humain
    Inscrit en
    décembre 2007
    Messages
    471
    Détails du profil
    Informations professionnelles :
    Activité : être humain

    Informations forums :
    Inscription : décembre 2007
    Messages : 471
    Points : 628
    Points
    628

    Par défaut

    Code :
    1
    2
     
    buffer: rb 1000 ;reserver 1000 octets à l'adresse buffer.
    ici, buffer, c'est un symbole (une etiquette) qui sera transformé par le compilo en une adresse et il vaut 01E5h (le buffer est à la fin du fichier, qui fait 0E5h octets de long, et est chargé à 100h dans le segment ds (org 100h) donc buffer est egal à 1E5h.


    donc, le premier octet du fichier chargé sera à l'adresse [DS:1E5h], qui est en fait le buffer de 1000 octets, donc [ds:buffer]

  11. #11
    Invité de passage
    Profil pro
    Inscrit en
    février 2012
    Messages
    9
    Détails du profil
    Informations personnelles :
    Localisation : Belgique

    Informations forums :
    Inscription : février 2012
    Messages : 9
    Points : 0
    Points
    0

    Par défaut Tour de magie ?

    Pourquoi pas ! Je constate bien que le programme fait E5 de longueur ça ok mais pour le reste j'ai toujours le meme probleme ou sont les données je ne retrouve rien en memoire meme pas les octets du programme ? Ce n'est pas possible j'ai fait une recherche avec WINEXE de la ram et rien. Si je lance debug je tape quoi pour voir ma zone. Je comprends rien ça devrait pas etre si compliqué quand meme !

    d 1000:1e5 ???

  12. #12
    Membre chevronné Avatar de edfed
    être humain
    Inscrit en
    décembre 2007
    Messages
    471
    Détails du profil
    Informations professionnelles :
    Activité : être humain

    Informations forums :
    Inscription : décembre 2007
    Messages : 471
    Points : 628
    Points
    628

    Par défaut

    le seul bon moyen de voir ta ram, ici, ça serait d'utiliser une routine d'affichage, ce qui est déja le cas, ou un vrai debugger. parce que bon, debug de dos, ou winexe laissent à desirer.

    quoi qu'il en soit, si tu arrives à voir le contenu de ton fichier sur l'ecran, en gris sur fond orange, alors c'est bien chargé en mémoire, là où on lui à dit de le mettre, à l'adresse buffer, dans le segment ds.

    d 1000:E5 est erroné dans deux sens.

    primo, le premier champ (1000) doit être la valeur du segment DS, qui n'est surement pas égal à 1000h, mais serait plutot defini à la volée par le système.

    E5 aussi est erroné, car le fichier executable est chargé dans le segment à partir de 100h, donc, il faut ajouter 100h à 0E5h, soit 1E5h.

    n'utilisant pas debug, je ne saurait te dire comment recuperer la valeur du segment DS du programme. mais ça ne doit pas etre bien dur.

    peut etre d DS:1E5 ?

    peut etre qu'en utilisant une routine de convertion binaire->hexadecimal, tu pourrais afficher la valeur du segment DS et l'adresse de buffer.
    avec ce code, tu veras la valeur de ces deux words en haut de l'ecran. prêts à copier dans la commande debug.

    Code :
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
     
            org 100h
            call DOSread
            call debug
            push es 0b800h
            pop es
            mov si,buffer
            mov di,0
            mov ah,67h
    @@:
            lodsb
            cmp al,0
            je @f
            stosw
            jmp @b
    @@:
            pop es
            ret
    debug:
            push eax ebx ecx edx
            mov ax,ds
            call wordtohexa
            mov [buffer],eax
            mov byte[buffer+4],':'
            mov ax,buffer
            call wordtohexa
            mov [buffer+5],eax
            pop edx ecx ebx eax
            ret
    wordtohexa:
            mov bx,ax
            shr ax,8
            call @f
            xchg bx,ax
            call @f
            shl eax,16
            mov ax,bx
            ret
     
    @@:
            mov ah,al
            and al,0fh
            call @f
            xchg al,ah
            shr al,4
    @@:
            cmp al,10
            cmc
            sbb dl,dl
            and dl,7
            add al,dl
            add al,'0'
            ret    
     
    fptr:
    .off=0
    .seg=2
    .size=4
    DOSread:
            push eax ebx ecx edx edi esi
            mov edi,[.fptr]
            mov edx,[.path]
            or edx,edx
            je .error
            mov ax,[edx+2]
            mov dx,[edx+0]
            push ds
            or ax,ax
            je @f
            mov ds,ax
    @@:
            mov ax,3d00h
            int 21h
            pop dx
            jc .error
            or edi,edi
            je .close
            mov bx,ax
            mov ah,42h
            mov al,0
            mov cx,[.off+2]
            mov dx,[.off]
            int 21h
            jc .error
            mov ax,[edi+2]
            mov dx,[edi+0]
            mov ecx,[edi+4]
            push ds
            or ax,ax
            je @f
            mov ds,ax
    @@:
            mov ah,3fh
            int 21h
            pop ds
            jc .error
            movzx eax,ax
            mov [edi+fptr.size],eax
     
    @@:     
            mov ah,3eh
            int 21h
            jc .error
     
    .end:
            pop esi edi edx ecx ebx eax
            ret
    .close:
            call .id
            jmp @b
    .error:
            mov dword[.size],0
            jmp .end
     
    .id :   mov ah,42h
            mov al,2
            mov cx,0
            mov dx,0
            int 21h
            mov word[.size],ax
            mov word[.size+2],dx
            ret
    .off:   dd 0
    .size:  dd 0
    .path:  dd chemin
    .fptr:  dd zone
    zone    dd 0:buffer,1000
    chemin  dd 0:fichier
    fichier db "c:\fool\shell.asm",0
    buffer:
    mais si je continue à te donner les solutions, tu ne vas pas progresser.

  13. #13
    Invité de passage
    Profil pro
    Inscrit en
    février 2012
    Messages
    9
    Détails du profil
    Informations personnelles :
    Localisation : Belgique

    Informations forums :
    Inscription : février 2012
    Messages : 9
    Points : 0
    Points
    0

    Par défaut Un pas

    Je vais essayer ce soir d'utiliser le segment DS pour mettre une valeur dedans comme ça je serai ou le programme est.

  14. #14
    Invité de passage
    Profil pro
    Inscrit en
    février 2012
    Messages
    9
    Détails du profil
    Informations personnelles :
    Localisation : Belgique

    Informations forums :
    Inscription : février 2012
    Messages : 9
    Points : 0
    Points
    0

    Par défaut Suis trop nul

    Bon ça n'avance guère mes recherches

    j'ai rajouté ces qq octets afin de charger mon programme dans une zone déterminée mais comment on fait pour le mettre en 0000:7000

    mov ax,7000h
    mov ds,ax

    avec mon instruction ça doit se mettre en ????:7000

  15. #15
    Membre chevronné Avatar de edfed
    être humain
    Inscrit en
    décembre 2007
    Messages
    471
    Détails du profil
    Informations professionnelles :
    Activité : être humain

    Informations forums :
    Inscription : décembre 2007
    Messages : 471
    Points : 628
    Points
    628

    Par défaut

    Citation Envoyé par velus Voir le message
    Bon ça n'avance guère mes recherches

    j'ai rajouté ces qq octets afin de charger mon programme dans une zone déterminée mais comment on fait pour le mettre en 0000:7000

    mov ax,7000h
    mov ds,ax

    avec mon instruction ça doit se mettre en ???? :7000

    si ds=7000h, l'adresse s'écrit 7000h???.

    lorsque tu changes la valeur d'un registre de segment, tu ne change que la valeur d'un registre de segment, en aucun cas le contenu de la mémoire n'est déplacé ou copié.

    le dos charge ton programme à un endroit ou l'allocateur de mémoire estime qu'il y a de la place et tu ne peux pas le changer ou le forcer, tu pourrais, à la limite, demander au dos de te donner une autre zone de ram ou lancer une autre copie du programme... mais là encore, tu ne peux pas forcer l'adresse de chargement, le dos l'interdit.
    le seul interet de forcer le chargement est lors de la programmation d'os ou tu prend la main sur le dos pour faire tourner ton systeme en mode test, car un os, une fois booté, ne vois pas le dos, sauf s'il est un dos lui même.

    donc, tu ne peux pas forcer ton programme à être à une adresse particulière juste en changeant la valeur de DS.


    je pense que tu ne devrais pas bruler les étapes, et commencer par une longue série d'essais des divers mode d'adressages et instructions, il ne te reste plus qu'à commencer par le commencement, en affichant des caractère un par un, puis en copiant des caractères d'une zone de ram à une autre avant de l'afficher, puis en convertissant des chaines en nombres, des nombres en chaines, faire des boucles, et essayer de coder les fonction les plus elementaires.

    parce que là, tu utilise du code assez complexe pour un debutant, sans même comprendre ce qu'il fait, tu n'es pas à l'abri d'une erreur fatale, du genre qui effacerait tout tes fichiers en ne changeant que quelques lignes de code au hazard par ci par là.

    donc, je te reconseille une fois de plus de faire simple pour commencer, et petit à petit, lorsque tu auras assimilé le modèle mémoire et le fonctionnement du cpu, tu pourras passer à l'utilisation (et l'ecriture) de fonctions compliquées.

    fais surtout des belles sauvegardes de ton code lorsqu'il marche bien, et dès que tu n'arrives plus à le faire fonctionner à cause des modifs, tu supprime tout, et tu restaures la dernière sauvegarde à la place.

  16. #16
    Invité de passage
    Profil pro
    Inscrit en
    février 2012
    Messages
    9
    Détails du profil
    Informations personnelles :
    Localisation : Belgique

    Informations forums :
    Inscription : février 2012
    Messages : 9
    Points : 0
    Points
    0

    Par défaut

    OK mais moi mon but c'est
    1. Charger un ficher Ok
    2. Le retourner comment je saurais le retourner si je ne connais pas l'adresse ou il est implanté ?
    3. Le sauver

  17. #17
    Membre chevronné Avatar de edfed
    être humain
    Inscrit en
    décembre 2007
    Messages
    471
    Détails du profil
    Informations professionnelles :
    Activité : être humain

    Informations forums :
    Inscription : décembre 2007
    Messages : 471
    Points : 628
    Points
    628

    Par défaut

    il est là:
    Code :
    1
    2
    3
    4
     
    .fptr:  dd zone
     
    zone    dd 0:buffer,1000
    ici, le segment à 0 signifie segment DS car dans le code:
    Code :
    1
    2
    3
    4
    5
    6
    7
    8
     
            mov ax,[edx+fptr.seg] ;charger la partie segment du fptr
            mov dx,[edx+fptr.off]
            push ds ;sauver DS
            or ax,ax ;egal à 0?
            je @f    ;ouais, on saute par dessus
            mov ds,ax ;non, on charge ds avec la partie segment du fptr
    @@:;mais si on à sauté par dessus, ds ne change pas
    peut importe l'emplacement du fichier chargé, il faut comprendre l'adressage par pointeurs. au lieu de manipuler des adresses, tu manipules des pointeurs, ce qui est bien plus facile car un pointeur peut pointer où on veut, et etre modifié à chaud.

Liens sociaux

Règles de messages

  • Vous ne pouvez pas créer de nouvelles discussions
  • Vous ne pouvez pas envoyer des réponses
  • Vous ne pouvez pas envoyer des pièces jointes
  • Vous ne pouvez pas modifier vos messages
  •