Discussion :

[10_GOTO_10]

Bon, vu mon pseudo, je ne peux pas ne pas me mêler au débat. Vous l'aurez compris, j'ai fait du basic et de l'assembleur (donc, je suis définitivement perdu pour l'informatique, dirait mon prof).

Est-ce que les anti-gotos pourraient me dire comment faire le programme suivant sans goto ?

Soit le programme VHDL suivant (pas de panique, même si vous ne connaissez pas le VHDL, vous comprendrez quand même):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
procedure TITI
  begin
  -- traitement
  wait on A
  -- suite du traitement
end procedure

Le VHDL est fait pour décrire des composants indépendants, donc chaque procédure tourne en parallèle.
Je voudrais faire un programme C (séquentiel, donc) qui simule ces composants. J'ai donc une fonction principale qui appelle chaque procédure alternativement. Sur le "wait on A", la procédure redonne la main à la boucle principale (donc un return), puis doit continuer le traitement à l'endroit où elle s'est interrompue quand le signal A (une variable globale, pour simplifier) est modifiée. Ca donne ceci en c:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
int TITI(int suivi)
  {
  if (suivi == 1) goto suivi1;
  // Traitement
  // Equivalent du wait on A
  return;
suivi1:
  // Suite du traitement
  }

Je ne vois pas bien comment faire ce type de programme sans gotos, à moins de faire autant de threads que de procédures, sachant qu'on va vite être limité par le nombre maxi de threads autorisés par le système.

Mais je suis sûr que les anti-gotos vont me donner une solution élégante, structurée, et sans gotos...

[Emmanuel Delahaye]

Mais je suis sûr que les anti-gotos

Argh ! Je suis repéré !

vont me donner une solution élégante, structurée, et sans gotos...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
int TITI(int suivi)
{
   if (suivi != 1)
   {
     // Traitement
     // Equivalent du wait on A
   }
   else
   {
     // Suite du traitement
   }
   return ...;
}

Trop simple. j'ai sans doute rien compris...

[10_GOTO_10]

Oui, c'est pas si simple: le wait peut être inclus dans des boucles et/ou dans des if (c'est à dire que le begin du if est dans Traitement et le end du if est dans SuiteTraitement). Il peut aussi bien sûr y avoir d'autres wait à d'autres endroits.

[Jean-Marc.Bourguet]

Oui, c'est pas si simple: le wait peut être inclus dans des boucles et/ou dans des if (c'est à dire que le begin du if est dans Traitement et le end du if est dans SuiteTraitement). Il peut aussi bien sûr y avoir d'autres wait à d'autres endroits.

Je ne vois pas en quoi goto aide. Si j'ai bonne memoire, on ne peut pas faire de goto vers l'interieur de structure de controle en C (ou bien est-ce uniquement en C++?).

De toute maniere pour implementer l'equivalent de wait, il te faut des coroutines puisqu'il peut y avoir toutes les variables de la pile d'appel a stocker. Si tu veux le gerer en C, il faut faire pas mal de chose a la main. Tellement que j'aurais tendance a definir un preprocesseur specialise pour ca, ou a tout le moins une lib complete bien pensee ce qui serait aussi du boulot. Pourquoi ne pas utiliser un vrai simulateur VHDL? Ou Verilog. Ou System C.

[10_GOTO_10]

(ou bien est-ce uniquement en C++?).

Heu, oui. je suis effectivement en C++. Ca ne change rien au débat.

De toute maniere pour implementer l'equivalent de wait, il te faut des coroutines puisqu'il peut y avoir toutes les variables de la pile d'appel a stocker.

Non, en VHDL toutes les variables sont statiques (on ne peut pas créer un bout de fil dans un composant et le détruire). J'espère qu'il n'y a pas de spécialiste VHDL dans le forum, je ne suis pas absolument sûr de ne pas dire une bêtise.

Pourquoi ne pas utiliser un vrai simulateur VHDL? Ou Verilog. Ou System C.

Alors celle là elle n'est pas mal: "N'UTILISEZ PAS DE GOTO !!! CHANGEZ DE COMPILATEUR AU BESOIN, MAIS SURTOUT N'UTILISEZ PAS DE GOTO !!!"

[Jean-Marc.Bourguet]

(ou bien est-ce uniquement en C++?).

Heu, oui. je suis effectivement en C++. Ca ne change rien au débat.

Je faisais allusion au fait qu'en C++ on ne peut pas faire de goto après une déclaration (et je me trompais car je pensais qu'on ne pouvais pas entrer dans un bloc quel qu'il soit). Ca montre que j'utilise peu les goto. Très peu.

De toute maniere pour implementer l'equivalent de wait, il te faut des coroutines puisqu'il peut y avoir toutes les variables de la pile d'appel a stocker.

Non, en VHDL toutes les variables sont statiques (on ne peut pas créer un bout de fil dans un composant et le détruire). J'espère qu'il n'y a pas de spécialiste VHDL dans le forum, je ne suis pas absolument sûr de ne pas dire une bêtise.

Tu peux avoir des variables dans les fonctions et les procédures. Mais je ne sais plus si tu peux avoir des wait dedans (cela fait un peu trop longtemps et j'ai surtout fait de la synthèse RTL où la syntaxe est plus contrainte qu'en simulation; en synthèse RTL, tu ne peux avoir qu'un wait par process et ce doit être le premier statement du process.).

Pourquoi ne pas utiliser un vrai simulateur VHDL? Ou Verilog. Ou System C.

Alors celle là elle n'est pas mal: "N'UTILISEZ PAS DE GOTO !!! CHANGEZ DE COMPILATEUR AU BESOIN, MAIS SURTOUT N'UTILISEZ PAS DE GOTO !!!"

C'est plus que changer de compilateur, c'est changer de language. Utiliser un language adapté plutôt qu'un avec lequel il faut bricoler pour manipuler les concepts, ça me semble être la base.

Les goto ne me gène pas. Je vais les utiliser s'ils correspondent à mon besoin. Je vais les utiliser pour bâtir la primitive adéquate. Mais je ne vais pas m'acharger à utiliser un langage qui ne propose pas la primitive sur laquelle toute ma conception est bâtie. Si je ne manipule que des coroutines, j'utiliserai un langage avec des coroutines, si je ne manipule que des machine d'états, j'utilise un générateur qui prend une description de machine d'états. Ou alors je bâtit ou j'utilise une bibliothèque de manipulation de coroutine ou de machine d'états (ce qui revient à utiliser un langage, la frontière entre les deux est fort poreuse). Si je n'ai qu'une routine, qu'une machine d'états, oui là je vais utiliser des goto de manière locale (encore que pour des coroutines, je crois qu'un switch est plus adapté).

[10_GOTO_10]

Les goto ne me gène pas. Je vais les utiliser s'ils correspondent à mon besoin.

C'est uniquement ce que je voulais dire à travers cet exemple (peut-être pas très bien choisi, j'aurais pu choisir un autre language, on est d'accord).
Je voulais seulement répondre aux inté... heu, intransigeant du C qui édictent des règles absolues, "les char *, c'est mal", "les goto, on peut toujours s'en passer", etc, etc. l'informatique en général et un language en particulier, c'est un outil. Il faut en utiliser les fonctionnalités qu'ils offrent, de la meilleure façon pour chaque cas, mais sans a priori sur la façon de faire. L'important est: 1) que ça marche. 2) que ce soit clair pour celui (sans doute soi-même) qui va le relire.

[loka]

je vais rajouter 3/ que ça nuit pas à la securité

il est vrai qu'à une epoque on ne pouvait pas s'en passer (mon vieux basic :p), mais maintenant en C/C++, tout peut se faire sans goto en ameliorant le code et sa securité.
Alors pourquoi vouloir continuer à l'utiliser ?

Enfin bon je l'utilisais quand j'etais très jeune sur les vieux langages de programmation, mais ensuite quand on m'a appris a programmer en C, on m'a toujours banni de les utiliser sous peine d'être flagelé

[akoril]

Salut,

J'ai plusieurs fois était confronté a ce genre de problème en reprenant du code existant, et en voulant supprimer les 'goto ERROR' (qui ne gêné que moi entre autre!) ...

Une solution est de decouper la fonction:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
bool TITI_Process(int suivi, int &rtVal) {
  if (suivi == 1) return true; // pour suite de traitement...
  // Traitement
  // Equivalent du wait on A 
  rtVal = valeurderetour;
  return false; // sans suite du traitement...
}
 
int TITI(int suivi) {
  int rtVal;
  if (TITI_Process(suivi)) {
     // Suite du traitement...
     // affectation éventuelle du rtVal...
  }
  return rtVal;
}

Le code de base n'est pas suffisamment clair... on doit pourvoir le faire en une seule fonction je comprend que l'on est dans une boucle ?
un essai:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
int TITI(int suivi) 
{ 
  bool suite=false, end=false;
 
  while (!suite && !end) {
    if (suivi == 1) {
      suite = true;
      break;
    } 
    // Traitement... 
    // Equivalent du wait on A 
    break;   // ==> return; 
  } 
  if (suivi && suite) { 
    // Suite du traitement 
  }
}

Mais bon... a chacun ces méthodes de codage, l'essentiel c'est d'être assez clair pour des évolutions ou des corrections de Bugs et ça aussi bien par qq'un d'autre.