Code : Tout sélectionner
If Not x=0 And Not x=1Code : Tout sélectionner
If x<>0 And x<>1
Debug "Vrai"
Else
Debug "Faux"
EndIfCode : Tout sélectionner
If Not (x=0) And Not (x=1)
Debug "Vrai"
Else
Debug "Faux"
EndIf
Code : Tout sélectionner
; Condition 1 AND condition 2
If (Not (x=0 And x=1) ) And (Not (x=1 Or x=0) )
Debug "Vrai"
Else
Debug "Faux"
EndIfCode : Tout sélectionner
; Code kelebrindae n°1
If Not x=0 And Not x=1
Debug "Vrai"
Else
Debug "Faux"
EndIf
; Donnes => FAUX
; Equivalence compilateur n°2
If (Not x)=0 And (Not x)=1
Debug "Vrai"
Else
Debug "Faux"
EndIf
; Donnes => FAUX
; Code kelebrindae n°3
If Not (x=0) And Not (x=1)
Debug "Vrai"
Else
Debug "Faux"
EndIf
; Donnes => VRAI
; Equivalence compilateur n°4
If (Not (x=0)) And (Not (x=1))
Debug "Vrai"
Else
Debug "Faux"
EndIf
; Donnes => FAUXCode : Tout sélectionner
If Not (x=0) And Not (x=1)Code : Tout sélectionner
If Not ((x=0) And Not (x=1) )J'avais loupé cette partie. Étonnante cette particularité ! Y'a - t - il une raison ?Ollivier a écrit :Je vous l'ai dit plus haut, ça compile de droite à gauche...
Cls a écrit :J'avais loupé cette partie. Étonnante cette particularité ! Y'a - t - il une raison ?Ollivier a écrit :Je vous l'ai dit plus haut, ça compile de droite à gauche...
). Code : Tout sélectionner
Procedure.b test(t.s)
Debug "Test " + t
ProcedureReturn #True
EndProcedure
If #False And test("false") : EndIf
If #True And test("true") : EndIfCode : Tout sélectionner
x=1
; Code kelebrindae n°3
If Not (x=0) And Not (x=1)
Debug "Vrai"
Else
Debug "Faux"
EndIf
; Donne => VRAI
; Code théoriquement identique
If ~(x=0) And ~(x=1)
Debug "Vrai"
Else
Debug "Faux"
EndIf
; Donne => FAUX
Les deux codes ne sont donc pas identiques. En cherchant un peu dans la doc, j'ai enfin trouvé le pourquoi du comment. Il suffisait de lire un peu :Notre Not n'arrive qu'en seconde position dans l'ordre des priorité. En gros, il sera évalué en dernier, juste avant les ET / OU ! Maintenant tout s'explique, ou presque car il y a, du coup, toujours un souci. Que ça compile de droite à gauche ou de gauche à droite, le Not devrait être évalué avant le And, comme précisé dans le tableau ci - dessus. Le compilateur n'a pas à ajouter de parenthèses à notre insu. Du coup je pense kelebrindae a bien remonté un bug.Priorité des opérateurs
Niveau de priorité | Opérateurs
--------------------+---------------------
8 (haute) | ~, -
7 | <<, >>, %, !
6 | |, &
5 | *, /
4 | +, -
3 | >, >=, <, <=, =, <>
2 | Not
1 (basse) | And, Or, XOr
ça dépend ce qui précède la nuit en question...Cls a écrit :Comme la nuit porte conseil
Désolé pour le tas de fautes illisibles. Un sursaut de lucidité insassiable a dû me traverser l'esprit hier après une dégustation poussée pour tenter d'opérer une telle réponse. ça ne se reproduira plus. Et, bien sûr, la niaule est à consommer modérément, pour ceux que mon message ferait replonger ou dériver vers l'addiction.Cls a écrit :et que la réponse d'Ollivier ne me convenait pas
Code : Tout sélectionner
x = #False
If Not x = 1 And Not x = 0
Debug "VRAI"
Else
Debug "FAUX"
EndIf
If Not (x = 1) And Not x = 0
Debug "VRAI"
Else
Debug "FAUX"
EndIfCode : Tout sélectionner
x = #False
If (Not (x = 1) ) And (Not (x = 0) )
Debug "VRAI"
Else
Debug "FAUX c.q.o.v."
EndIfCode : Tout sélectionner
x=4
A_0=(Not x=4)=0
Debug A_0
;************** généré ASM de A_0=(Not x=4)=0
; x=4
; MOV dword [v_x],4
; ; A_0=(Not x=4)=0
; MOV ebx,dword [v_x]
; CMP ebx,4
; JNE No0
; XOR eax,eax
; JMP Ok0
; No0:
; MOV eax,1
; Ok0:
; MOV ebx,eax
; AND ebx,ebx
; MOV dword [v_A_0],0 ====> simple affectation de la valeur 0 a v_A_0 donc à A_0 et non résultat d'une relation logique
; ; Debug A_0
x=4
A_1=(Not x=4)=1
Debug A_1
;************** généré ASM de A_1=(Not x=4)=1
; ; x=4
; MOV dword [v_x],4
; ; A_1=(Not x=4)=1
; MOV ebx,dword [v_x]
; CMP ebx,4
; JNE No1
; XOR eax,eax
; JMP Ok1
; No1:
; MOV eax,1
; Ok1:
; MOV ebx,eax
; CMP ebx,1
; MOV dword [v_A_1],1 ====> simple affectation de la valeur 1 a v_A_1 donc à A_1 et non résultat d'une relation logique
; ; Debug A_1
;**************** maintenant avec double parenthèses pour essayer que l'opérateur "=" soit un opérateur logique
x=4
A_0=((Not x=4)=0)
Debug A_0
;************** généré ASM de A_0=((Not x=4)=0)
; ; x=4
; MOV dword [v_x],4
; ; A_0=((Not x=4)=0)
; MOV ebx,dword [v_x]
; CMP ebx,4
; JNE No2
; XOR eax,eax
; JMP Ok2
; No2:
; MOV eax,1
; Ok2:
; MOV ebx,eax
; AND ebx,ebx
; MOV dword [v_A_0],0====> simple affectation de la valeur 0 a v_A_0 donc à A_0 et non résultat d'une relation logique
; ; Debug A_0
; ************ Les doubles parenthèses ne suffisent pas a changer l'opérateur "=" d'affectation en opérarteur logique
;**************** il existe des opérateurs qui ne nécessitent qu'une opérande. Il sont appelés opérateurs Monadiques.
;**************** Comme Not et un opérateur monadique de priorité 2 nous allons utiliser deux not => qui correspondent à ne rien faire
;**************** Comme "=" Opérateur logique a un niveau de priorité de 3 il faut placer deux NOT de priorité 2 qui ne font rien d'autre que
;**************** d'obtenir que "=" soit une opérateur logique
x=4
A_0=(Not(Not(Not (x=4))=0))
Debug A_0
;************** généré de A_0=(Not(Not(Not (x=4))=0))
; ; x=4
; MOV dword [v_x],4
; ; A_0=(Not(Not(Not (x=4))=0))
; MOV ebx,dword [v_x]
; CMP ebx,4
; JNE No2
; XOR eax,eax
; JMP Ok2
; No2:
; MOV eax,1
; Ok2:
; MOV ebx,eax
; AND ebx,ebx
; JNE No3
; XOR eax,eax
; JMP Ok3
; No3:
; MOV eax,1
; Ok3:
; AND eax,eax
; JE No4
; XOR eax,eax
; JMP Ok4
; No4:
; MOV eax,1
; Ok4:
; MOV dword [v_A_0],eax
; ; Debug A_0
;************************ POUR VERIFICATION INVERSONS LE TEST AVEC 1
x=4
A_1=(Not(Not(Not (x=4))=1))
Debug A_1
; ; x=4
; MOV dword [v_x],4
; ; A_1=(Not(Not(Not (x=4))=1))
; MOV ebx,dword [v_x]
; CMP ebx,4
; JNE No5
; XOR eax,eax
; JMP Ok5
; No5:
; MOV eax,1
; Ok5:
; MOV ebx,eax
; CMP ebx,1
; JNE No6
; XOR eax,eax
; JMP Ok6
; No6:
; MOV eax,1
; Ok6:
; AND eax,eax
; JE No7
; XOR eax,eax
; JMP Ok7
; No7:
; MOV eax,1
; Ok7:
; MOV dword [v_A_1],eax
; ; Debug A_1
; ********************** Les Résulats sont conforment à la logique CQFD ****************************