Comportement inexplicable des maquereaux

[Naheulf]

Bonjour à tous et à toutes.

Cet après midi j'ai fait quelques expériences avec les macros et je suis tombé sur des comportements ... originaux. Je vous partage les codes.

Si je remplace le nom d'une macro par son contenu, je suis bien sensé avoir la même chose ?

Code : Tout sélectionner

Macro Chrono(code, message=MacroExpandedCount)
	debut.q = ElapsedMilliseconds()
	For i = 1 To 1000000
		code
	Next
	fin.q = ElapsedMilliseconds()
	Debug "Test : " + message
	Debug "Temp : " + Str(fin-debut) + "ms"
EndMacro

Macro Example
	a=1: a+1
EndMacro

Chrono(Example, "Assignation")
Chrono(a = 1: a+1, "Assignation")

Si j'ai bien compris, c'est bien le contenu qui appelle le nom de la macro ?

Code : Tout sélectionner

Macro titi
	Debug "Et gros minet"
EndMacro

Macro toto
	tata
EndMacro

Macro toto()
	titi
EndMacro

Macro tata()
	Debug "Bonjour ma tante !"
EndMacro

toto()

Note : essayez de changer le contenu de chacune des macros "toto" ou de changer celle qui à les parenthèses.
EDIT : J'utilise PB 5.62 (x64) sous windows 8.1

[Ar-S]

Ton

Code : Tout sélectionner

macro toto
tata
endmacro

Ne veut rien dire, vu que tu as mis de parenthèses à tata pour la macro tata()
De plus, une macro sans parenthèse sert éventuellement à remplacer une commande (un alias)

Il est préférable d'utiliser des valeurs entre parenthèses pour tes macros.

Code : Tout sélectionner

Macro tata(text1,text2)
  Debug text1 + " " + text2
EndMacro

Tata ("bonjour","tata Michèle")


Macro toto(arg1)
  
  arg1
  
EndMacro

toto (tata("coucou","la voilà"))

[Naheulf]

Ton

Code : Tout sélectionner

macro toto
tata
endmacro

Ne veut rien dire,

C'est l'ensemble du deuxième code qui est purement inutile.

J'ai mis les deux codes pour montrer le bizarreries générées par le compilateur.
Pour le second code il s'agit d'une double erreur :

Ligne 13 : Erreur de syntaxe.

La ligne 13 c'est la ligne "Macro tata()". C'est un début de déclaration de macro tout à fait normal. Cette erreur d'affiche en même temps que l'erreur de macro suivante. Tout se passe donc à la même ligne.

Code : Tout sélectionner

Macro Debug "Et gros minet"

Que viens faire Gros Minet dans la déclaration de la macro tata() alors qu'il fait parti de la macro titi ???

[boby]

Code : Tout sélectionner

Macro titi
   Debug "Et gros minet"
EndMacro

; Macro toto
;    tata
; EndMacro

Macro toto()
   titi
EndMacro

Macro tata()
   Debug "Bonjour ma tante !"
EndMacro

toto()

Dans ton "code" tu crée deux fois la macro toto. C'est normal que tu nimporte quoi en résulta si tu code nimporte quoi.

[Naheulf]

Meci boby.
Au départ je croyais que les macros simples et les macros avec paramètres étaient gérées séparément. Je voulais donc savoir laquelle des deux macros toto était appelé en premier.

Avec ta réponse, je pense enfin avoir compris ce qu’il se passe dans le second bout de code :

1. Macro 1 : titi --> RAS
2. Macro 2 : toto --> RAS
3. Macro 3 : toto() --> La macro 2 remplace « toto » par « tata ». La macro 3 s’appelle donc « tata()»
4. Macro 4 : tata() --> La macro 3 remplace « tata()» par « titi ». La macro 1 remplace ensuite « titi » par « Debug "Et gros minet"»

En revanche, cela n'explique pas pourquoi le caractère ":" est considéré comme une virgule dans le premier morceau de code .

[Ar-S]

Salut
Quelle virgule ?
Ce qui me gêne dans ton code c'est :

Code : Tout sélectionner

Chrono(a = 1: a+1, "Assignation")
les : signifient un retour à la ligne dans PB
;Donc c'est comme si tu faisais 
Chrono (a = 1
a +1, "Assignation")

Je suis déjà étonné qu'il ni ait pas un message d'erreur plus hardcore.

Dans ta macro tu indiques ensuite qu'il y aura 2 éléments, et non plus.

Code : Tout sélectionner

Macro Chrono(code, message=MacroExpandedCount)

Sinon tu veux faire quoi exactement.

[Naheulf]

Sinon tu veux faire quoi exactement.

Pour cette macro là, l'idée était de voir si l'on pouvait injecter du code dans une macro. En l’occurrence pour mesurer le temps d'exécution du code concerné.
Mais comme je l'ai mis dans mon premier message :

Cet après midi j'ai fait quelques expériences avec les macros

Il n'y a pas vraiment de but précis.

Ce qui me gêne dans ton code c'est :

Code : Tout sélectionner

Chrono(a = 1: a+1, "Assignation")
les : signifient un retour à la ligne dans PB
;Donc c'est comme si tu faisais 
Chrono (a = 1
a +1, "Assignation")

Je suis déjà étonné qu'il ni ait pas un message d'erreur plus hardcore.

Je suis d'accord avec toi. Je m'attendais soit à ce que ça fonctionne comme la ligne

Code : Tout sélectionner

Chrono(Example, "Assignation")

soit que le compiler me mette une erreur du type « Il manque une parenthèse fermante » ou « caractère ':' invalide à cette position ».

Quelle virgule ?

Et du coup, pourquoi le compilateur semble lire la ligne

Code : Tout sélectionner

Chrono(a = 1: a+1, "Assignation")

comme si c'était

Code : Tout sélectionner

Chrono(a = 1, a+1, "Assignation")

D'où ma question : Pourquoi le caractère ":" est/semble être considéré comme une virgule dans les paramètres d'appel de la macro ?

[Marc56]

Il est plus rapide de filtrer la correspondance à une syntaxe et de rejeter ce qui ne correspond pas.

Par exemple, le manque de parenthèse provoque un "syntax error" et c'est tout.
Le programmeur doit savoir relire et appuyer sur F1, sans oublier que la syntaxe s'affiche toujours en barre d'état, même pour les fonctions et macros qu'on a défini soi-même.

On ne peut pas, avoir un compilateur rapide, léger et stable et demander de traiter tous les types d'erreur possibles, sinon, on se retrouve avec un produit qui occupe plusieurs Go sur le disque et qui met plusieurs secondes pour compiler "Hello World" là où PB est instantané.

[boby]

En fait le but d'une macro c'est simplement d'éviter d'avoir plusieurs fois le même code dans ton code (ouais ça fait beaucoup de fois code...)
Quand tu fais appel à ta macro, c'est comme si tu faisais un copier coller du code contenu dans ta macro à l'endroit ou tu l'appel... Je ne voie pas trop ce qu'il pose problème du coup.

[Ar-S]

@Naheulf
Oui il est bon de le préciser. Une Macro c'est vraiment simplement de l'alias. A ne pas confondre avec la procédure qui elle pourra être appelé plusieurs fois mais n'aura été créé qu'une fois par le prog.

[Naheulf]

Bonjour,

Dans la série des codes cheloux je vous présente l’intrus : Celuis qui n'aaucune raison de boguer. (Enfin à mon avis)

Code : Tout sélectionner

Macro Mode
	2
EndMacro

CompilerIf Mode = 1
	Debug "Mode 1"
CompilerElseIf Mode = 2
	Debug "Mode 2"
CompilerEndIf

Génère l'erreur "Ligne 7: Une expression numerique literale est attendue pour les directives de compilation".
En revanche ça marche avec une constante à la place de la macro. Pourtant les deux sont censés être remplacé par leurs valeurs à la compilation... Bizarre

PS : Oui j'aime les jeux de mots à une balle.

[Ar-S]

Doc : CompilerIf <expression constante>

ça ne fonctionnera pas non plus avec des macros.
Meme si tu fais

Code : Tout sélectionner

  Macro Mode
     #PB_Compiler_Processor 
  EndMacro

 CompilerIf Mode = #PB_Processor_x86
   Debug "Mode 1"
  
 CompilerElseIf Mode = #PB_Processor_x64
    Debug "Mode 2"
  CompilerEndIf

Il te faudra mettre la constante

Code : Tout sélectionner

 CompilerIf #PB_Compiler_Processor = #PB_Processor_x86
   Debug "Mode 1"
  
 CompilerElseIf #PB_Compiler_Processor = #PB_Processor_x64
    Debug "Mode 2"
  CompilerEndIf

[Naheulf]

les macros seront complètement remplacées par le code correspondant au moment de la compilation

ce qui est très important à comprendre: l'évaluation de la ligne ne commence uniquement lorsque toutes les macros trouvées sur cette ligne ont été traitées.

Donc pour moi, le traitement du CompilerIf / CompilerElseIf ne devrait même pas voir qu'il y a une macro sur la ligne.

Or j'ai l'impression que le traitement du CompilerIf court-circuite les macros.

Code : Tout sélectionner

Macro CEI : CompilerElseIf : EndMacro

CompilerIf 2 = 1
	Debug "Mode 1"
CEI #True ; devrait être équivalent à "CompilerElseIf #True"
	Debug "Mode 2"
CompilerElse
	Debug "Autre"
CompilerEndIf

Ce code affiche "Autre"

[Ollivier]

Le CompilerElseIf c'est fait pour te simplifier la vie sur le plan logique, pas sur le plan syntaxique. Il faut prendre en compte les priorités de compilation pour obtenir une simplification globale.

Tu fais une macro correcte (c'est-à-dire avec un cadre respectant les priorités du compilateur, et un objectif correspondant, à savoir se simplifier la vie).

Code : Tout sélectionner

Macro Cpl(Alpha, Beta, Gamma)

 CompilerIf (Alpha)

  Beta

 CompilerElse

  Gamma

 CompilerEndIf

EndMacro

Le résultat, c'est que ça te simplifie la vie.

Code : Tout sélectionner

Cpl(1,
   Debug "Mode 1",
   Cpl(1,
      Debug "Mode 2",
      Debug "Autre") )

[Flype]

A mon humble avis, ca s'explique facilement,

CompilerIf/Else/Endif c'est du préprocesseur
Les macros sont aussi du préprocessing.

A priori, donc, le compilateur traite les directives de compilation avant les macros, ce qui je pense est logique.

Cela signifie donc que le compilateur ne connait les macros qu'après cette étape.