Discussion :

[AiYori]

Bonjour,

J'aimerais faire passer un scalaire au travers du programme 'php', et récupérer la sortie dans un autre scalaire.
Voici ce que j'ai écrit, et qui semble fonctionner.

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
18
19
20
21
22
23
24
25
26
27
 
use strict;
use warnings;
use utf8;
 
my $entree = <<'FIN';
<?php
print "OK.\n";
?>
FIN
 
my $sortie = "";
my $pid = open FILS, "-|";
if ($pid) {
    while ( my $ligne = <FILS> ) {
        $sortie .= $ligne;
    }
} else {
    open PHP, "| php";
    print PHP $entree;
    close PHP;
    exit;
}
close FILS ;
 
 
print "<<$sortie>>\n";

Je trouve ça un peu lourd. Intuitivement, je me dis qu'il y a sûrement une méthode plus élégante et plus concise, en utilisant des backquotes par exemple, ou quelque chose du genre

Code :

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

open PHP, "| php |"

, mais je n'y arrive pas.
Si vous avez des éléments d'information, je suis preneur.

[Lolo78]

Pourquoi as-tu besoin de PHP? Es-tu sûr de ne pas pouvoir faire ce que tu veux faire en Perl pur? Ce serait quand même le plus simple.

Sinon, oui, sans doute les backquotes avec quelque chose du genre:

Code :

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

1
2
3
4
5
 
# ...
my $input = "toto";
# ...
my $output = `programme_php $input`;

Je ne peux pas en dire beaucoup plus car je ne comprends pas bien ce que tu cherches à faire et l'exemple que tu donnes n'éclaire pas beaucoup.

Sinon, je te conseillerais d'utiliser des descripteurs de fichiers lexicaux et de vérifier que l'ouverture du fichier a bien fonctionné:

Code :

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

1
2
3
 
my $fichier = "./toto.txt";
open my $FILE, "<", $fichier or die "ouverture impossible de $fichier  $!";

[AiYori]

J'utilise PHP en tant que pré-processeur de texte. Son mode d'intégration (interprétation entre deux balises données) me plaît. J'ai besoin de faire exactement comme un site INTERNET. Je vois difficilement comment je pourrais faire cela proprement en Perl.

Ensuite, j'aimerais éviter de passer par des fichiers temporaires, car ce n'est vraiment pas utile.

Voici plus précisément mon projet final :

• Je pars d'un source, qui a sa propre syntaxe, mais qui ressemble beaucoup à du SGML.
• Je fait passer m4 sur ce source, de manière à pouvoir faire du pré-traitement généraliste ('if', ...).
• Je fais passer un filtre écrit en Perl, qui me permet d'analyser certains types de macros.
• Je fais passer PHP, de manière à pouvoir faire du pré-traitement plus évolué (fonctions évoluées du langage PHP, en utilisant la POO).
• J'interprète le résultat, qui normalement doit être du SGML pur.
• J'en sors un document dans un format arbitraire (manpage, HTML, TeX, Word, ...).

Voici le source que j'ai aujourd'hui, en suivant les conseils de Lolo78.

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
18
19
20
21
22
23
24
25
26
27
 
use strict;
use warnings;
use utf8;
 
my $entree = <<'FIN';
<?php
print "OK.\n";
?>
FIN
 
my $sortie = "";
my $pid = open my $fils, "-|" // die "Erreur 'open' - 'fork'.";
if ($pid) {
    while ( my $ligne = <$fils> ) {
        $sortie .= $ligne;
    }
} else {
    open my $php, "| php" or die "Erreur 'open' - 'exec'.";
    print $php $entree;
    close $php;
    exit;
}
close $fils;
 
 
print "<<$sortie>>\n";

D'un point de schématique (mais ça ne marche pas), je me demandais s'il pouvait exister un moyen de procéder de la manière suivante.

Code :

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

1
2
 
$sortie = print $entree > `| php`

J'ai bien pensé faire quelque chose comme le code suivant, mais il faudrait que je déspécifie (suivant la norme shell) tous les caractères donnés en argument de la comment 'echo', et je ne trouve pas ça très propre.

Code :

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

1
2
 
$sortie = `echo $entreedespecifiee | php`;

[Lolo78]

Il y a environ 120.000 modules Perl sur le CPAN (y compris des dizaines pour parser du SGML, du XML, du HTML, du XHTML, du JSON, du CSV, etc.) , je doute que ce que tu fais en PHP ne puisse pas être fait en Perl à peu près aussi simplement, que ce soit en POO ou dans d'autres styles de programmation. Il y a aussi plusieurs frameworks destinés à Internet (Mojolicious, Dancer, Plack, sans compter les vénérables ModPerl et CGI). Même si PHP est aujourd'hui sans doute plus utilisé que Perl sur le Web, Perl a été pendant une dizaine d'années le principal moteur des sites dynamiques, et reste tout-à-fait capable de faire à peu près tout ce que l'on veut. Et il y a encore d'innombrables sites fonctionnant avec Perl et sans avoir besoin de recourir au PHP. Rien n'empêche bien sûr d'utiliser les deux (plus éventuellement du Javascript ou d'autres langages) pour faire différentes choses, mais dans ton cas, tu me sembles te compliquer la vie en voulant les utiliser ensemble pour faire une seule et même chose.

Maintenant, je ne dis pas cela pour essayer de te dissuader d'utiliser du PHP, peu m'importe, mais seulement pour te suggérer qu'il y a sans doute une architecture plus simple que celle que tu envisages.

[Philou67430]

Pour les communications inter-process, il y a les modules IPC::open2 et IPC::open3, mais leur utilisation peut entrainer des dead-lock, et la gestion bufferisée des entrées sorties est souvent un problème majeur à l'emploi de cette technique.
Je suis du même avis que Lolo que le plus simple, c'est de tout faire dans un seul process, ou alors, de créer une architecture client/server (à base de RPC, SOAP ou je ne sais quoi) si le besoin est vraiment d'avoir une architecture distribuée.

[AiYori]

Il y a environ 120.000 modules Perl sur le CPAN (y compris des dizaines pour parser du SGML, du XML, du HTML, du XHTML, du JSON, du CSV, etc.) , je doute que ce que tu fais en PHP ne puisse pas être fait en Perl à peu près aussi simplement, que ce soit en POO ou dans d'autres styles de programmation. Il y a aussi plusieurs frameworks destinés à Internet (Mojolicious, Dancer, Plack, sans compter les vénérables ModPerl et CGI). Même si PHP est aujourd'hui sans doute plus utilisé que Perl sur le Web, Perl a été pendant une dizaine d'années le principal moteur des sites dynamiques, et reste tout-à-fait capable de faire à peu près tout ce que l'on veut. Et il y a encore d'innombrables sites fonctionnant avec Perl et sans avoir besoin de recourir au PHP. Rien n'empêche bien sûr d'utiliser les deux (plus éventuellement du Javascript ou d'autres langages) pour faire différentes choses, mais dans ton cas, tu me sembles te compliquer la vie en voulant les utiliser ensemble pour faire une seule et même chose.

Maintenant, je ne dis pas cela pour essayer de te dissuader d'utiliser du PHP, peu m'importe, mais seulement pour te suggérer qu'il y a sans doute une architecture plus simple que celle que tu envisages.

Voici typiquement un exemple de code que j'aimerais pouvoir exploiter.

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
18
19
20
21
 
 
<titre>Devis.</titre>
 
<tabledesmatieres/>
 
<h1>&Y-EAi;tudes.</h1>
 
<?php tab_couts([
  [ "Libellé", "Coût unitaire", "Quantité" ],
  [ "Suppression du mur central", 12.30, 3 ],
  [ "Renforcement du plancher", 30.12, 5 ],
]); ?>
 
<h1>Matériel.</h1>
 
<?php tab_couts([
  [ "Libellé", "Coût unitaire", "Quantité" ],
  [ "Bois", 8.23, 34 ],
  [ "Acier", 7.65, 12 ],
]); ?>

L'avantage avec l'interpréteur PHP, c'est qu'il est prévu pour faire ce genre de choses. J'imagine bien pouvoir le faire en Perl, en identifiant le couple de balises de <?perl - ?> par exemple et lançant un 'eval()' à l'intérieur. C'est la procédure que vous me conseillez ?
Le code suivant donne un exemple d'une difficulté à laquelle je risque d'être confronté, et que j'aurais typiquement bien aimé éviter.

Code :

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

1
2
 
<?perl fonction("?>"); ?>

[AiYori]

Pour les communications inter-process, il y a les modules IPC::open2 et IPC::open3, mais leur utilisation peut entrainer des dead-lock, et la gestion bufferisée des entrées sorties est souvent un problème majeur à l'emploi de cette technique.
Je suis du même avis que Lolo que le plus simple, c'est de tout faire dans un seul process, ou alors, de créer une architecture client/server (à base de RPC, SOAP ou je ne sais quoi) si le besoin est vraiment d'avoir une architecture distribuée.

Je connais toute la complexité de ce genre de programmes, et ce n'est clairement pas ce que je cherche. Je cherchais juste un moyen propre et simple pour faire interpréter une chaîne de caractères par un programme dont l'image binaire est sur le VFS. Je trouve d'ailleurs que, dans la solution que je vous ai proposé, le fait de passer par un processus fils est artificiel, donc à éviter : je lance le fils, j'attends qu'il ait fini de s'exécuter, et j'utilise son résultat. Je n'utilise à aucun moment le caractère multi-tâches de mon système.
En fait, je pense que pour faire ce genre de choses, on passe obligatoirement par un fork - exec. Mais, étant donné que je ne fais qu'attendre la fin d'exécution du fils après l'avoir lancé, sans faire quoi que ce soit entre temps, je me disais qu'il aurait pu exister une syntaxe simple pour le faire.

[Philou67430]

Mais, étant donné que je ne fais qu'attendre la fin d'exécution du fils après l'avoir lancé, sans faire quoi que ce soit entre temps, je me disais qu'il aurait pu exister une syntaxe simple pour le faire.

La fonction system ou l'opérateur qx (aussi utilisable avec l'anti-quote ``).

Voir les docs :
perldoc -f system
perldoc perlop

L'opérateur qx retourne la sortie standard du processus fils, tandis que system retourne le code de sortie du processus fils.

[AiYori]

'system' ne répond pas à mes besoins, car c'est bien la sortie standard de la commande dont j'ai besoin.
J'avais déjà regardé les possibilités qui m'étaient offertes avec 'qx'. Cependant, je ne pense pas pouvoir, par cet opérateur, envoyer du texte dans l'entrée standard du programme qui est appelé.
D'un point de vue schématique, j'avais précédemment donné la représentation suivante.

Code :

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

1
2
 
$sortie = print $entree > `| php`

En fait, l'opérateur 'qx' me permet de récupérer la sortie standard d'une commande externe, et la structure 'open $df, "| commande"' me permet d'insérer du texte dans l'entrée standard d'une commande externe. Ce que je cherche, c'est une structure qui fasse les deux à la fois : qui insère du texte dans l'entrée standard et qui récupère la sortie standard.

[6ril23]

Code :

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

1
2
 
$sortie = print $entree > `| php`

et si tu fais

Code :

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

$sortie = `echo $entree | php`

je suis pas sûr du tout mais je tenterais

[Philou67430]

Ce que je cherche, c'est une structure qui fasse les deux à la fois : qui insère du texte dans l'entrée standard et qui récupère la sortie standard.

Alors je reviens à ce que je disais précédemment : utilise le module IPC::Open2 ou IPC::Open3 (avec les risques liés aux communications inter-process, comme les deadlock, les E/S bufferisées, ...).

Mais ton besoin se limitant à émettre un contenu unique vers le process et attendre sa réponse, cela ne devrait pas créer de soucis :

Code :

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

1
2
3
4
5
6
7
8
use IPC::Open2;
 
my ($CHILD_OUT, $CHILD_IN);
my $pid = open2($CHILD_OUT, $CHILD_IN, 'php');
print { $CHILD_IN } @php_code;
#close $CHILD_IN; # NECESSAIRE ?
#waitpid( $pid, 0 ); # NECESSAIRE ?
my @php_output = <$CHILD_OUT>;

Mais attention (voir les lignes commentées), il faut que la commande se termine après la réception de @php_code (au besoin, il faudra peut-être fermer le file handle $CHILD_IN pour le forcer à finir son exécution).

[AiYori]

et si tu fais

Code :

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

$sortie = `echo $entree | php`

je suis pas sûr du tout mais je tenterais

Non, ça ne fonctionne pas. Il faudrait déspécifier '$entrée', selon les conventions de l'intepréteur de commandes utilisé ('sh' je pense).

[AiYori]

Alors je reviens à ce que je disais précédemment : utilise le module IPC::Open2 ou IPC::Open3 (avec les risques liés aux communications inter-process, comme les deadlock, les E/S bufferisées, ...).

Mais ton besoin se limitant à émettre un contenu unique vers le process et attendre sa réponse, cela ne devrait pas créer de soucis :

Code :

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

1
2
3
4
5
6
7
8
use IPC::Open2;
 
my ($CHILD_OUT, $CHILD_IN);
my $pid = open2($CHILD_OUT, $CHILD_IN, 'php');
print { $CHILD_IN } @php_code;
#close $CHILD_IN; # NECESSAIRE ?
#waitpid( $pid, 0 ); # NECESSAIRE ?
my @php_output = <$CHILD_OUT>;

Mais attention (voir les lignes commentées), il faut que la commande se termine après la réception de @php_code (au besoin, il faudra peut-être fermer le file handle $CHILD_IN pour le forcer à finir son exécution).

Je creuse cette proposition, et reviens vers vous à l'issue.
Merci à tous pour votre aide.

[AiYori]

Ca fonctionne très bien. Voici le code que j'obtiens au final.

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
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
 
use strict;
use warnings;
use utf8;
 
use IPC::Open2;
 
my $entree = <<'FIN';
<?php
print "Première ligne.\n";
print "Deuxième ligne.\n";
?>
FIN
 
#* Ouverture des descripteurs de fichiers. *
my ($df_sortie, $df_entree);
my $pid = open2($df_sortie, $df_entree, 'php');
 
#* Envoie des données en entrée du filtre. *
print $df_entree $entree;
close $df_entree;
waitpid($pid, 0);
 
#* Récupération des données en sortie de filtre. *
my $sortie;
while ( my $ligne = <$df_sortie> ) {
    $sortie .= $ligne;
}
close $df_sortie;
 
#* Affichage du résultat. *
print "<<$sortie>>\n";

Merci à tous pour votre aide. C'est exactement ce que je voulais.