PureBasic

oui en effet...

Le plus simple est bien sûr de ne pas faire d'erreur a Protected...

C'est sur que si le compilo ne reconnait pas un mot clé,il en déduit que c'est une multiplication...

Ollivier a écrit : Un chemin plus simple par élimination de méthode : essaie de me trouver une multiplication valable avec un total et libre choix de la structure qui s'associerait au 2nd terme.
Code : Tout sélectionner
X * N.UneStructureQueTuChoisis
A mon humble avis, il n'en existe aucune de multiplication valable en programmation. Mais je peux me tromper...

defit relevé

Code : Tout sélectionner

calldebugger
Structure PIF
		Zoup.I
		Zot.I
		Paf.I
EndStructure
A.Pif  ; <------- Variable Typé Pif (structuré ) parfaitement declarée

x=10

debug X * A.Pif ; ça correspond a 10 * adresse de A.pif

Calldebugger

debug x * @A.pif  ; la preuve

Code : Tout sélectionner

calldebugger
Structure PIF
		Zoup.I
		Zot.I
		Paf.I
EndStructure
A.Pif  ; <------- Variable Typé Pif (structuré ) parfaitement declarée

x=10

debug X * A.Pif ; ça correspond a 10 * adresse de A.pif

Calldebugger

debug x*@A.pif  ; la preuve

; maintenant si tu veux faire une multiplication utile (par l'un des membres )

; on attribut une valeur a un membre sinon il serait egale a zero
A.Pif\Zoup.I=10

debug X * A.Pif\Zoup.I ; resultat 100 (10*10)

Déjà, merci de relever le défi ! Maintenant, ça sert à quoi "10 fois l'adresse" ?

Ollivier a écrit :Déjà, merci de relever le défi ! Maintenant, ça sert à quoi "10 fois l'adresse" ?

houla, mais là on passe a l'aspect philosophique

en Programmation, il existe je pense pleins d'occasions de se demander a quoi sert tel ou tel truc

je reponds juste au fait que syntaxiquement c'est vue comme une multiplication ...
apres, le pourquoi, du comment .....

par contre, avec une addition ça prends son sens

Code : Tout sélectionner


Structure PIF
		Zoup.I
		Zot.I
		Paf.I
EndStructure
A.Pif  ; <------- Variable Typé Pif (structuré ) parfaitement declarée

; on attribut une valeur a un membre sinon il serait egale a zero
A.Pif\Zoup.I=10 
A.Pif\Zot.I=20 
A.Pif\Paf.I=30 
; qu'on peut remplacer par :
; for i=0 to 8 Step 4
; 		x=x+10
; 		debug pokei(i + A.Pif, x) 
; next i

;******************************

calldebugger
for i=0 to 8 Step 4
		debug peeki(i + A.Pif ) 
next i

je suppose donc qu'une multiplication permettrai des sauts de X Pas ...

Et tu n'aurais pas une réponse plus simple pour dire que ça ne sert à rien !?!

Ollivier a écrit :Et tu n'aurais pas une réponse plus simple pour dire que ça ne sert à rien !?!

ben non , ça ne sert pas a rien
ça ne TE sert a rien .... c'est pas pareil

quelqu'un peut tres bien avoir une Big Structure , et vouloir acceder a certains membre
comme pour le calcul matriciel par exemple
la structure est un Segment de memoire, on peut vouloir acceder a une partie disséminées de façon régulière de ce segment

en utilisant les multiplication/additions , ça deviens possible
maintenant, je te l'accorde, il y a plethore de moyens de faire autrement, mais c'est le sens meme de la programmation

Programmation = multivoies ... les chemins vers une solution

Mais c'est qu'ils continuent à se battre ces deux là ^^

Ollivier dans ton premier message tu te demandes pourquoi le compilateur de détecte aucune erreur dans ce code que je vais remettre ici

Code : Tout sélectionner

Procedure xProc()
   Protyected *Alpha ; Erreur de syntaxe
EndProcedure
xProc()

Je t'ai donné une réponse simple que Zorro a confirmé : Protyected *Alpha c'est une multiplication. Dans ton code tu multiplies Protyected par Protyected. (Protyected * Alpha ou P * A)

Je vais posé cette question stupide mais qui me brûle les lèvres : J’espère que tu as vu que Protected est mal écrit ?

1) Est-ce une maladresse qui a été mouchée dans les versions plus récentes?

Non c'est de ta faute le compilateur n'y peut rien.

2) Si non, durant la compilation, est-ce que le temps d'analyse du type est trop important pour permettre de préciser (et localiser) l'erreur de syntaxe?

la seule erreur ici est que tu as mal orthographié Protected. Dans ce cas le compilateur considère que c'est une variable initialisée par défaut avec la valeur 0.

Comme tu peux le constater mes réponses sont simples à comprendre contrairement à tes joutes verbales dans lesquelles ont finit par lâcher prise tellement elles sont complexes ou dénuées de sens.

Cordialement .... falsam ^^

Quelqu'un avait émis il y a quelques temps l'idée intéressante que l'IDE écrive d'office une première ligne EnableExplicite dès qu'on créé un nouveau document

Libre à chacun de l’effacer ensuite, mais en toute connaissance de cause

Libre à chacun de la placer ou pas pour ma part...

Marc56 a écrit :Quelqu'un avait émis il y a quelques temps l'idée intéressante que l'IDE écrive d'office une première ligne EnableExplicite dès qu'on créé un nouveau document
Libre à chacun de l’effacer ensuite, mais en toute connaissance de cause

ça commence comme ça , et ensuite ?? on vire le Goto parcequ'il ne plait pas a tout le monde ?

Falsam a écrit :Je vais posé cette question stupide mais qui me brûle les lèvres : J’espère que tu as vu
que Protected est mal écrit ?

Je te prie de m'excuser d'avoir fait brûler tes babines ainsi.

La synthèse de ce sujet est la suivante :

La multiplication de confort

A * B

Qui signifie :

A = A * B

est aussi courte, simple d'utilisation et adéquate aux instructions x86 qu'elle est sujete à possible confusion par erreur de frappe. Il y a déjà plusieurs prises en charge d'erreurs qui existent (Cf plus bas)

L'erreur de frappe des directives Global, Static, Shared, Protected et Define est un exemple de confusion possible.

Il en émane un message d'erreur indirect (c'est ça le souci principal conséquent) lorsque l'on déclare un pointeur avec structure (Cf page 1, 3ème message) ).

La confusion se fait en substituant le préfixe '*' (étoile) du pointeur par le caractère opératoire de multiplication de confort A * B.

Or préciser implicitement que le terme B est un pointeur par l'assignation d'une structure selon la syntaxe suivante :
A *B.UneStructure

Préciser ceci, c'est exclure le souhait d'une exécution de multiplication de confort, puisqu'il n'y a pas d'application réelle (on ne programme pas un OS dans un mode CPU franchement très restreint en PureBasic, c'est précisément ce qu'implique A = A * Pointeur) (pour le calcul matriciel évoqué par Zorro, il y a un jeu d'indexation ASM équivalent à PeekI((8 * A) + (4 * B) + (2 * C) + D) nichable en une seule instruction processeur et bien plus rapide que cette simple multiplication).

Conclusion : L'erreur non détectée à la bonne ligne peut être détectée à la bonne ligne.

Je rajouterai que c'est juste interdire
A * B.UneStructure
et rien d'autre. Pas
A = A * B.UneStructure (comme ça, si ça botte quelqu'un d'y trouver un intérêt, il est libre)

Et qu'en mode non explicite,

A * B.MauvaiseStructure ; est déjà interdit (structure introuvable)
A ***B.UneStructure ; idem (erreur syntaxe)
A.UneStructure * B ; idem (erreur syntaxe)

Aussi, pourquoi laisser passer un bug vaseux alors que techniquement, il est parfaitement localisable et que l'on en a déterminé son arrêt d'application?

Enfin, en tout cas, ce n'est pas se battre... Oui, j'avais remarqué que Protyected, c'était pas bon!

Il faut virer les opérations qui effectuent une auto-référence.
A*B
C'est bien dans les autres langages mais après tout PB c'est un basic.
A=A*B
Oui, ça fait moins pro, mais ce n'est pas une grosse perte de temps non plus et au moins c'est clair pour le compilateur.

Bonjour Fig,

je pense que c'est trop bourrin ton idée, car ça reste pratique de décomposer un calcul compliqué en opérations élémentaires avant de le passer en ASM et vice-versa.

(1)

Code : Tout sélectionner

a = ((b * c) - d) * e

(2)

Code : Tout sélectionner

a = b
a * c
a - d
a * e

(3)

Code : Tout sélectionner

mov ebx, [xx] ; a=b
imul ebx, [xx] ; a*c
sub ebx, [xx] ; a-d
imul ebx, [xx] ; a*e
mov [xx], ebx ; a MàJ

Que tu aies (1), (2) ou (3), ça fonctionne. Ce n'est pas comme ça dans beaucoup de langage... Les calculs du (2) sont importants dans le contrôle d'une conversion de code PB <=> Asm. Si on les vire, ça fait un sacré vol plané de passer du (1) au (3) sans transition (et vice versa).

Moi je trouve que ce code

Code : Tout sélectionner

Protyected *A.PIF ; Erreur de syntaxe non signalée

pourrait quand même déclencher une sorte d'alerte... Voir sur quels critères avec des pros de la syntaxe ! Même en BASIC il y a des règles, ce ne seront pas ceux qui ont beaucoup pratiqué le GFA qui me diront le contraire

djes a écrit :Moi je trouve que ce code
Code : Tout sélectionner
Protyected *A.PIF ; Erreur de syntaxe non signalée
pourrait quand même déclencher une sorte d'alerte...

ha mais oui !
une alerte "ce type est inconnu" ... indiquerai exactement ce qui se passe !

(que la structure n'a pas été declaré )

PureBasic

(Mode non explicite) - Erreur furtive de syntaxe

Re: (Mode non explicite) - Erreur furtive de syntaxe

Re: (Mode non explicite) - Erreur furtive de syntaxe

Re: (Mode non explicite) - Erreur furtive de syntaxe

Re: (Mode non explicite) - Erreur furtive de syntaxe

Re: (Mode non explicite) - Erreur furtive de syntaxe

Re: (Mode non explicite) - Erreur furtive de syntaxe

Re: (Mode non explicite) - Erreur furtive de syntaxe

Re: (Mode non explicite) - Erreur furtive de syntaxe

Re: (Mode non explicite) - Erreur furtive de syntaxe

Re: (Mode non explicite) - Erreur furtive de syntaxe

Re: (Mode non explicite) - Erreur furtive de syntaxe

Re: (Mode non explicite) - Erreur furtive de syntaxe

Re: (Mode non explicite) - Erreur furtive de syntaxe

Re: (Mode non explicite) - Erreur furtive de syntaxe

Re: (Mode non explicite) - Erreur furtive de syntaxe