(Mode non explicite) - Erreur furtive de syntaxe

[Ollivier]

Je n'ai étrangement aucun message d'erreur (5.22 LTS). Est-ce que les versions plus récentes réagissent idem?

Code : Tout sélectionner

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

[Ar-S]

Pas de message d'erreur, d’ailleurs ça passe avec n'importe quoi :

Code : Tout sélectionner

Procedure xProc()
  Biscuit *PurBeurre ; Erreur de syntaxe
  ProcedureReturn @PurBeurre
EndProcedure
Debug xProc()

Et @PurBeurre retourne bien une adresse
testé en 5.43 et 5.50

[falsam]

Bonjour Ollivier. Ce n'est pas une erreur de syntaxe.

Tu es en train de faire une multiplication de Protyected par Alpha

Code : Tout sélectionner

Procedure xProc()
  Debug Protyected
  Debug Alpha

  Debug Protyected *Alpha
EndProcedure
xProc()

Le compilateur a vu deux variables qui sont Protyected et Alpha par défaut initialisé avec la valeur 0.

EnableExplicit en tete de code et tu aurais eu un message explicite.


Ar-s

[Zorro]

l'a une ptite faim le Ar-s

[Ollivier]

EnableExplicit en tete de code et tu aurais eu un message explicite.

Weup! Tire pas trop vite ta cartouche (Surtout quand le titre est explicite, car indiquant "non explicite" !).

Code : Tout sélectionner

Structure PIF
Zoup.I
Zot.I
Paf.I
EndStructure

Procedure xProc()
Protyected *A.PIF ; Erreur de syntaxe non signalée
*A = AllocateMemory(SizeOf(PIF) )
; Pavasse de lignes
*A\Paf = 1 ; Erreur réellement signalée (absence de structure)
EndProcedure

C'est comme ça que je l'ai senti venir :

Code : Tout sélectionner

"Ligne 11: La variable suivante n'a pas de 'Structure' associee: *A"

Avec une pavasse de lignes à la place du commentaire "; Pavasse de lignes", j'ai tout retourné le programme pour la retrouver ma blague, et là, chèr Falsam, dont toute ma majeure admiration pour ton constructivisme t'est allouée, je ne la vois pourtant point la multiplication !

Alors mes deux questions peuvent se résoudre à celles-ci :
1) Est-ce une maladresse qui a été mouchée dans les versions plus récentes? Parce que je vois mal un pointeur structuré ou non structuré servir de produit multipliant (a contrario d'une taille mémoire pointée).

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? Dans ce cas, effectivement Falsam, le mode explicite reste seule solution.

[Zorro]

bon relit ça plusieurs fois :

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

que vois tu ??

moi je vois que tu essais de multiplier a variable Protyected par une variable A ayant comme type ".PIF" ; là tu aurai du avoir une erreur de syntaxe
mais plus j'utilise Pb 5.50 plus je me rends compte qu'il ne signale plus pleins de trucs ...
mais apres tout le type ".pif" est peut etre un nouveau type inconnu ... genre une variable au contenu surprise, aléatoire

ensuite ta ligne : *A\Paf , déclenche une erreur de structure , tout simplement parceque dans ton code
il n'y a pas de Structure "A" et encore moins de membre \Paf de cette structure inexistante .....

tu as fait une structure avec un membre \¨Paf, mais elle n'est pas validé , ni dimensionnée !!
elle l'aurai peut etre été en utilisant la formule magique

Protected *A.PIF au lieu de Protyected *A.PIF

Alors peut etre y vois tu autre chose .... mais faut arreter de fumer hein


ton code , sans erreur :

Code : Tout sélectionner

 Structure PIF
Zoup.I
Zot.I
Paf.I
EndStructure

Procedure xProc()
Protected *A.PIF ; plus d'Erreur de syntaxe a signaler
*A = AllocateMemory(SizeOf(PIF) )
; Pavasse de lignes
*A\Paf = 1 ; plus d'erreur
EndProcedure 

[Ollivier]

le type ".pif" est inconnu en
Purebasic

Oui, c'est une structure bien indiquée en bonne et dûe forme. Une structure assignant forcément un pointeur (pas un flottant, ni même un entier usé en multiplication).

Ce n'est pas remettre en cause mon savoir-lire ce que j'écris, même bugué le cas étant, (ni le pouvoir-fumer en passant, raisin du dimanche !!) mais bien de me dire si je me plante quand je dis qu'un pointeur n'a pas sa place au sein d'une multiplication.

Code : Tout sélectionner

Protyected *Valeur.PIF ; "Protyected" ou "Biscuit" ou autre...

c'est comme écrire

Code : Tout sélectionner

Entier * *Pointeur ; Puisqu'il y a ".PIF"

Or, je doute qu'accumuler le produit d'une multiplication par une adresse soit chose probable (Soit n un entier, "n égale n
fois adresse-mémoire" me semble absolument impossible à servir en programmation, c'est ça que je souhaite voir débattu éventuellement au départ). Si tel est le cas, une amélioration de compilation est envisageable (en théorie).

[Zorro]

[quote="Ollivier"]

Code : Tout sélectionner

Protyected *Valeur.PIF ; "Protyected" ou "Biscuit" ou autre...

c'est comme écrire

Code : Tout sélectionner

Entier * *Pointeur ; Puisqu'il y a ".PIF"

ben non !! c'est pas pareil !

deja le fait qu'il y ai ".PIF" ,'implique absolument pas qu'on parle de pointeur !

les pointeurs ne sont plus typé depuis un moment en Purebasic !

Code : Tout sélectionner

Protyected *Valeur.PIF 

c'est bien une multiplication du fait
(pas de type sur les pointeur ) donc le compilo ne peut pas considerer ça comme un pointeur !

il s'agit bel et bien d'une multiplication !
de la variable Protyected avec une variable A.Pif ....

la variable A.pif car c'est une variable , a un type etrange , mais le compilo sais que ce ne peut etre un pointeur !
puisque les pointeurs ne peuvent etre typé

donc pour ce code :

Code : Tout sélectionner

Protyected *A.PIF

tout au plus tu aurai du avoir une erreur du genre
"les pointeurs ne peuvent comporter de Type" s'il voyait cela comme un pointeur .....

ou alors "la variable A comporte un type inconnu" s'il voit cela comme une variable mal typé

en traçant ce code , tout va bien

Code : Tout sélectionner

Declare xproc()


Structure PIF
		Zoup.I
		Zot.I
		Paf.I
EndStructure
A.PIF ; declaration de la structure
CallDebugger

xProc()


Procedure xProc()
		debug Protyected * A.PIF ; ça c'est bien une multiplication ! (la tete a toto)
		*A = AllocateMemory(SizeOf(PIF) )
		; Pavasse de lignes
		A\Paf = 1 
EndProcedure
; Epb

[Ollivier]

Ça tourne en rond, à défaut de tourner rond malheureusement !

deja le fait qu'il y ai ".PIF" ,'implique absolument pas qu'on parle de pointeur !

Et beh si !
Pointeur = adresse mémoire
Structure = Manière d'indexer un buffer/bloc mémoire

Soit tu as .98765 ce qui ne nous intéresse pas plus que ça.
Soit tu as .abcdef qui est un suffixe assignant "abcdef" (en tant que structure) à un pointeur nommé à gauche du point, et uniquement un pointeur. Un entier algébrique usé en calculs, dont la multiplication, n'aura jamais la possibilité de se faire assigner une structure puisqu'il a déjà une structure native de type INTEGER, LONG, QUAD, BYTE, etc...

Si une structure est assignée avec ".UneStructure" c'est forcément pour assigner un pointeur de cette connue manière :

Code : Tout sélectionner

JeSuisForcementUnPointeur.UneStructure

et, bien il en faut :

Code : Tout sélectionner

*AvecOuSansEtoile.UneStructure

L'étoile sert uniquement à déterminer le mode de prise en charge mémoire :
Sans étoile, c'est le compilateur qui gère, et c'est statique.
Avec étoile, c'est le programmeur qui s'y colle, et c'est dynamique.

Cette règle étant rappelée, le compilateur, dans le cas d'une multiplication de confort

Code : Tout sélectionner

operandeA * operandeB

peut, par cette règle, parfaitement détecter un "expressionB1 point expressionB2" ("expressionB1.expressionB2") qui signifie absolument, à moins que expressionB2 soit une succession de chiffres, que expressionB1 est un pointeur, statique ou dynamique, peu importe. Aussi cette détection, si elle est constatée dans OperandeB au sein d'une multiplication "OperandeA * OperandeB" peut déclencher un message d'erreur de type "Calcul non autorisé" à l'endroit exact où il y a l'anomalie, et non pas x lignes plus tard, sur une conséquence de l'anomalie avec un message d'erreur autre que la nature réelle de l'anomalie.

[Zorro]

Ça tourne en rond, à défaut de tourner rond malheureusement !

c'est aussi ce que je pense lorsque je te lis !

deja le fait qu'il y ai ".PIF" ,'implique absolument pas qu'on parle de pointeur !

Et beh si !
Pointeur = adresse mémoire
Structure = Manière d'indexer un buffer/bloc mémoire

Soit tu as .98765 ce qui ne nous intéresse pas plus que ça.
Soit tu as .abcdef qui est un suffixe assignant "abcdef" (en tant que structure) à un pointeur nommé à gauche du point,

mais c'est du n'importe quoi !!

où as tu vu qu'en Purebasic, le point etait un suffixe de structure ??

en Purebasic c'est le signe "\" ; pas le point !

en Purebasic un point xxxx qui suit une variable indique un TYPE !! ET RIEN D'AUTRE !

on est pas en C++ on est en Purebasic !

JeSuisForcementUnPointeur.UneStructure

Reponse :

Code : Tout sélectionner

ben_non_je_suis_une_variable.et_un_type

tant que ta structure n'a pas d’existence, ce que tu crois etre un pointeur sur structure, est en fait, une variable mal typé !

tu confonds, Type et structure !! , une Structure permet de Typer une variable , avec un Type Personalisé !

car en plus tu fais ton erreur au moment de la declaration de ta structure
donc Elle n'existe pas !!
elle est ecrite syntaxiquement dans ton listing (entre Structure et EndStructure )
mais n'a pas d'existence au niveau du code !!

ici : la structure existe, car elle est correctement declarée !

Code : Tout sélectionner

Structure PIF
		Zoup.I
		Zot.I
		Paf.I
EndStructure
A.PIF ; declaration correcte de la structure
; la variable A a un nouveau Type "PIF"
a.pif\Zoup.i=10 ; le type PIF existe !!
CallDebugger

alors que la : la declaration etant mauvaise, la structure n'existe pas !!

Code : Tout sélectionner

 Structure PIF
      Zoup.I
      Zot.I
      Paf.I
EndStructure
Protyected *A.PIF  ; mauvaise declaration de la structure
; Le présumé pointeur *A se retrouve avec un mauvais TYPE qui n'existe pas !!puisque la declaration n'a pas été faite
; mais aussi parceque de toute façons les pointeurs n'ont pas de type en Purebasic !! donc ce n'est pas un pointeur !! 

; tel quel , il s'agit d'une multiplication de la variable "Protyected" avec une variable A mal typé !!
; puisque la declaration a foiré, donc le type "Pif" n'existe pas ....
Protyected.Pif\Zoup.i=10 ; ce type Pif n'existe pas
Calldebugger

voila avec un pointeur : (mais il ya peut etre plus simple )

Code : Tout sélectionner

calldebugger
 ; comme ça , ça marche !!! 
Structure PIF
      Zoup.I
      Zot.I
      Paf.I
EndStructure
A.Pif ; la structure (et donc le type "PIF" ) est bien déclaré

A.Pif\Zoup.i=10 ; ce type Pif existe on a attribué une valeur (en mode pas a pas laisse le pointeur souris sur "a" pour voir l'attribution avec le popup )
*B=@A.Pif\Zoup.i ; on transfert le contenu dans un pointeur (en fait on pointe l'adresse de notre Variable A Typé "Pif"  membrée Zoup.i, )
debug PeekI(*B) ; on affiche le contenu du pointeur (qui affiche bien 10 ) un pointeur n'a pas de Type (en fait c'est toujours un .I)
Calldebugger

c'est pourtant simple a comprendre .....


rappel de la Doc :
les premier mots sont :

Structure est utile pour définir un type utilisateur

autre exemple plus detaillée avec pointeurs :

Code : Tout sélectionner

calldebugger
Structure PIF
		Zoup.I
		Zot.I
		Paf.I
EndStructure
A.Pif  ; <------- Variable Typé Pif (structuré ) parfaitement declarée
; comme ça , ça marche !!! 
;******* attribution des valeurs ***********************
		A.Pif\Zoup.i=10 ;> ce type Pif existe on a attribué une valeur 
		A.Pif\Zot.i=20 ;> ce type Pif existe on a attribué une valeur
		A.Pif\ Paf.i=30 ;> ce type Pif existe on a attribué une valeur
; *************************************************

;******** creation des pointeurs sur les membres de la structure ********
		*B=@A.Pif\Zoup.i ;> on pointe l'adresse du membre de la structure de la variable ATypé PIF
		*C=@A.Pif\Zot.i ;> on pointe l'adresse du membre de la structure de la variable A Typé PIF
		*D=@A.Pif\Paf.i ;> on pointe l'adresse du membre de la structure de la variable A Typé PIF
; *****************************************************************

; *********** Affichage des résultats **********************************
		debug PeekI(*B) ;> on affiche le contenu du pointeur (qui affiche bien 10 )
		debug PeekI(*C) ;> on affiche le contenu du pointeur (qui affiche bien 20 )
		debug PeekI(*D) ;> on affiche le contenu du pointeur (qui affiche bien 30 )
; *******************************************************************

Calldebugger

[Ollivier]

Un pointeur peut être assigné par une structure contenant, elle-même, un ensemble de variables aux types divers.

Pas de confusion là-dedans.

[Zorro]

Un pointeur peut être assigné par une structure contenant, elle-même, un ensemble de variables aux types divers.

Pas de confusion là-dedans.

tu compliques tout , meme dans tes explications
j'aurai pas aimé t'avoir comme prof , genre, apres ta reponse, on ne sais plus qu'elle etait la question

perso , ma définition du pointeur :
un pointeur est une Variable , contenant une Adresse mémoire ! ; plus simple tu meurs !

[JohnJohnsonSHERMAN]

Mais vous avez tous les deux raison !
Un pointeur n'a pas de type. Mais il peut pointer vers une zone mémoire dans laquelle est une structure, auquel cas tout se comporte comme si le pointeur était "virtuellement" typé, c'est juste une adresse vers une une zone de mémoire qui elle est typée...

Essayez ce code et vous verrez que la structure est bien passée a la procédure via le pointeur, et qu'on peut ensuite faire comme s'il était typé en récupérant ses "membres" : *Pointeur\Membre.
Le pointeur indique une adresse mémoire contenant une structure, ici celle de MaVariable, et on accéde grâce au pointeur directement à la structure sans appeler MaVariable.

Code : Tout sélectionner

Structure MaStructure ;Quelle que soit la structure, on peut "l'affecter" au pointeur dans la procédure....
  BoutDeTexte1.s
  BoutDeTexte2.s
  TrucMachin.i
  NombreStupide.i
  Autrechampquisertarien.s
  Sherman.s
EndStructure

MaVariable.MaStructure
MaVariable\BoutDeTexte1="Voila, ca marche !"
MaVariable\BoutDeTexte2="On peut affecter une structure à un pointeur !"
MaVariable\NombreStupide=643615455
MaVariable\TrucMachin=$02153
MaVariable\Autrechampquisertarien="Aloha"
MaVariable\Sherman="L'auteur a raison"

Procedure  FaitUnTruc(*Pointeur.Mastructure);...Mais le pointeur n'a pas de type... c'est juste une adresse pointant sur une zone de mémoire ou se trouve la structure.
  Debug *Pointeur\BoutDeTexte1;Et on peut en récupérer tous les éléments
  Debug *Pointeur\BoutDeTexte2
EndProcedure

FaitUnTruc(MaVariable)

Donc même si le pointeur n'a pas réellement de type, tout se comporte ici comme s'il en avait virtuellement un... Certes c'est pas trés clair tout ca, mais ca marche.

[Zorro]

tu ajoutes un complément d'information sur
le fait qu'on puisse grace au pointeur acceder aux membres d'une structure
(mais ça on le savais )

mais tu n'a pas lu le topic depuis le debut !

il ne s'agit pas d'expliquer ce qu'est un pointeur
mais d'expliquer pourquoi au moment de la declaration d'une structure
on ne peut pas utiliser de pointeur

et que donc ceci (code de Ollivier ) :

Code : Tout sélectionner

Structure PIF
      Zoup.I
      Zot.I
      Paf.I
EndStructure
Protyected *A.PIF  ; mauvaise declaration de la structure

est une erreur de declaration de structure , car le

Protyected *A.PIF est vu comme une multiplication de deux terme (Protyected et A )
et non pas comme une declaration d'une structure PIF avec un pointeur *A

il faut d'abord declarer la Structure

Code : Tout sélectionner

A.PIF

ensuite creer un pointeur dessus

Code : Tout sélectionner

A.PIF
*pointeur=@A.Pif

et ensuite comme tu le rappel faire un acces de la façon suivante
d'ou mon commentaire

voila avec un pointeur : (mais il ya peut etre plus simple )

Code : Tout sélectionner

debug *pointeur\Zoup.I

[Ollivier]

j'aurai pas voulu t'avoir comme prof

T'as raison : j'aurai fait un délit de faciès avec ta lampe !

Ce n'est pas une chose simple cette erreur, sinon ça se saurait...

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...