Voilà mon pb:  
 

Si P=0 ou N=P  
alors
res=1
sinon
traitement
finsi

 
Or, je ne sais pas comment faire en assembleur (TASM 8086) pour que le programme prenne en compte les 2 comparaisons avant de faire un JMP suite.

ben tu peux pas, tu ne peux faire qu'une seule comparaison à la fois, n'oublie pas que tu fais de l'assembleur

Si je fais ça:  
Code:  
 
si:  
        cmp bx, 0  
        jne sinon  
         
        cmp ax, bx  
        jne sinon  
         
        mov ax,1  
        jmp finsi  
sinon:  
        ...  
finsi:  
        ...  
 
 
Le problème est que si bx est différent de 0 mais que ax=bx, le programme va quand à sinon... alors que je voudrais qu'il continue puisque ax=bx...

c'est quoi ton code en équivalent C ?
 
genre ça:
 
if( !a || !b )
{
   // code....
}

En fait, c'est  
 
if((p=0)||(n=p))
   {
   // code
   }
else
   {
   // code
   }

donc déjà tu peux retourner les conditions histoire de voir si ça t'arrange:
 
if( !p || n==p )  
{  
 // code 1
}  
else  
{  
 // code 2
}
 
est équivalent à:
 
if( p && n!=p )
{
  // code 2
}
else
{
  // code 1
}

ça ne me dit pas comment faire en assembleur...

la version optimisée:
 
mov ax,n  
sub ax,p  ; n-p
 
cmp ax,1  ; si n-p = 0, 0 étant inférieur à 1, la retenue sera mise sinon, la retenue sera à 0
 
sbb ax,ax ; ax => 0 si n==p, -1 (0xffff) si n!=p
           
and ax,p  ; ax => 0 si p est nul, quelque chose si p n'est pas nul
jz Code1 ; valà on si p est nul OU que n==p
 
; Code2
jmp fin
 
Code1:
 
fin:

sinon la version normale:
 
mov ax,p
or ax,ax
jz code1
cmp ax,n
je code1
 
;Code 2
jmp fin
 
code1:
 
fin:

 
porké j'appelles ça une verion "optimisée", passke y'a qu'un seul saut, les deux comparaisons sont "cumulée".
il faut considérer les branchement comme "très" lents (cassent le flux du pipeline)
 
donc la philosophie:
 
1) on soustrait n à p ou p à n on s'en fous
 
2) si ils sont égaux la soustraction est nulle (0)
 
3) donc si ils sont égaux le cmp ax,1 mettre la ratenue (because 0 < 1)
 
4) par le sbb ax,ax ; on mets AX à 0, puis si y'a retenue (n==p donc), on retire la retenue ce qui donne -1 (0xffff ou 0ffffh)
 
5) on a donc si n==p, ax = 0ffffh, sinon 0
 
6) on fait un AND avec p, ce qui fait que si p est nul, on obtiens 0, si p est non on obtiens quelque chose.
 
7) le AND mettant à jour la flag Zero, on peut brancher en conséquence.

ça te plait ou pas ?