Voilà comment programmer en "script C" (compilé à la volée). C'est suffisament rustique pour passer n'importe où (par exemple, dans mon école, ya des A.I.X. de la guerre 14... alors ruby, tu oublies), et c'est vraiment pratique.
#!/bin/bash
total_lignes=`cat $0 | wc -l` ; ligne_arob=`grep "@""@" -m 1 -n $0 | cut -f1 -d:`
cat $0 | tail -$[ $total_lignes - $ligne_arob ] > /tmp/cs.$$.c
gcc -Wall -o /tmp/cs.$$ /tmp/cs.$$.c && /tmp/cs.$$ $* ; rm /tmp/*$$* ; exit
@@ fin de l'en-tête
ensuite on met un fichier C des familles (avec main(), et tout), on enregistre ça (j'ai pris l'habitde de nommer les fichiers avec le suffixe .cs), on chmod +x et roulez jeunesse (les arguments passent, ça peut se lancer en démon, tout et tout).
Si il y a des gens que ça intéresse (vous êtes tordus !) je peux détailler le fonctionnement de la chose (c'est simple en réalité).
# Re: Astuce pour compiler du C à la volée
Posté par shelton2 (site web personnel) . Évalué à 3.
# tcc
Posté par free2.org . Évalué à 3.
y'a aussi de vrais interpréteurs C
[^] # Re: tcc
Posté par Salagnac . Évalué à 1.
Si tu te balades de machine en machine avec tes scripts, c'est bien quand l'interpréteur est standard (ici, avec gcc, bash, grep, cut, on reste en famille)
[^] # Re: tcc
Posté par free2.org . Évalué à 2.
mais bon je concois que sur certaines machines paranoiaques on puisse pas (mais elles interdisent peut-etre de lancer gcc aussi non ?)
[^] # Re: tcc
Posté par Salagnac . Évalué à -1.
Par portabilité je n'entendais pas transportabilité car là, une disquette roulaize ; mais plutôt foncionnement transparent sur plusieurs architectures, plusieurs systèmes...
(Quant à la paranoïa, c'est une autre affaire. Les gens qui veulent sécuriser sérieusement un ordinateur installent Windows 2000 dessus, avec la gestion des droits poil aux bras)
[^] # Re: tcc
Posté par Boa Treize (site web personnel) . Évalué à 1.
# Bash
Posté par Boa Treize (site web personnel) . Évalué à 2.
Bash fonctionne sur des AIX de la guerre de 14 ?
#! /bin/sh ce serait pas plus portable ?
[^] # Re: Bash
Posté par Salagnac . Évalué à 1.
et j'avais pas envie de me plonger dans awk. mais ça doit pas être insurmontable... (et oui, bash fonctionne ;-)
[^] # Re: Bash
Posté par Pascal Terjan (site web personnel) . Évalué à 3.
# Re: Astuce pour compiler du C à la volée
Posté par Damien Metzler . Évalué à 3.
#!/bin/sh
cat <<-. >/tmp/cs.$$.c && gcc -Wall -o /tmp/cs.$$ /tmp/cs.$$.c && /tmp/cs.$$
$*; rm -f /tmp/cs.$$*
#include <stdio.h>
#include <stdlib.h>
int main(void){
printf("Hello World\n");
return 0;
}
.
[^] # Re: Astuce pour compiler du C à la volée
Posté par Damien Metzler . Évalué à 2.
cat <<-. >/tmp/cs.$$.c && gcc -Wall -o /tmp/cs.$$ /tmp/cs.$$.c && /tmp/cs.$$$*; rm -f /tmp/cs.$$*
sur une seule ligne ;)
[^] # Re: Astuce pour compiler du C à la volée
Posté par Salagnac . Évalué à 1.
D'ailleurs ça marche même sans le point à la fin du fichier puisque de base, le cat s'arrêtera sur EOF.
Par contre il y a un problème car le fichier lui-même se fait passer à la moulinette d'interprétation du shell :
printf("%d args $*\n",argc);
for(i=0;i<argc;i++)
printf("arg %d: %s\n",i,argv[i]);
affichera les arguments du programme deux fois... (mais ça doit pas être grand chose à modifier)
Merci beaucoup en tous cas (ta solution est adoptée !)
[^] # Re: Astuce pour compiler du C à la volée
Posté par Damien Metzler . Évalué à 1.
En tout cas l'idée de départ est bien sympa !
A+
# Re: Astuce pour compiler du C à la volée
Posté par MrTout (site web personnel) . Évalué à 2.
#!/bin/sh
tail +3 $0 >/tmp/cs.$$.c && gcc -Wall -o /tmp/cs.$$ /tmp/cs.$$.c && /tmp/cs.$$ $*; rm -f /tmp/cs.$$*; exit
#include<stdio.h>
int main(int argc, char** argv) {
if (argc <= 1)
puts("Hello Word!");
else
printf("Hello %s!\n", argv[1]);
return 0;
}
le truc c'est le '+' de tail qui simplifie bien les choses. Sinon c'est vraiment se casser la tête car le C n'est pas un magnifique langage de script (c'est plus un macro-assembleur)
[^] # Re: Astuce pour compiler du C à la volée
Posté par Salagnac . Évalué à 1.
int main() { float total=0 , compte=0 , val=0; while(scanf("%f",&val) >0) { total += val; compte ++; } printf("%f\n",total/compte); }[^] # Re: Astuce pour compiler du C à la volée
Posté par MrTout (site web personnel) . Évalué à 1.
perl -e 'while (<>) {$s+=$_}; print $s;'
en ruby c'est sans doute
ruby -e 's=0; $stdin.each{|l| s+=l.to_i}; print s'
Voila :)
[^] # Re: Astuce pour compiler du C à la volée
Posté par MrTout (site web personnel) . Évalué à 1.
n=0; while read a; do n=$(($n+$a)); done; echo $n
[^] # Re: Astuce pour compiler du C à la volée
Posté par Salagnac . Évalué à 1.
Quant à Ruby et Perl je ne parle aucun de ces deux langages, et (je veux pas troller) je n'ai l'intention d'apprendre ni l'un ni l'autres (pour diverses raisons, respectivement)
Alors C roulaize ; et en plus c'est super puissant (p/r à bash en tout cas) et lisible.
Mais j'aime bien le lego technique alors les one-liners de tous langages me plaisent tout le temps. (PS: comment on dit one-liner dans la langue de Molière ?)
[^] # Re: Astuce pour compiler du C à la volée
Posté par MrTout (site web personnel) . Évalué à 1.
Ah oui, tiens, j'ai cru que c'étais la somme pas la moyenne. Ça m'apprendra à lire trop vite.
Mais C pèche surtout pour la gestion de chaines, des listes, des tables de hashages, des classes, des fonctions lambdas et du méta-niveau reflexif... Enfin, ça dépend sûrement de l'utilité qu'on en a je pense, et généralement moi j'ai besoin de tout ça pour mes scripts (au moins des 3 premiers, le reste c'est pour la frimefacilité de programmation inhérente).
[^] # Re: Astuce pour compiler du C à la volée
Posté par Salagnac . Évalué à 1.
Plus sérieusement, ce que j'aime bien dans C/java/php (je n'aime pas le C++ sauf dans l'api BeOS mais c'est une autre histoire) c'est qu'on n'a pas à ré-apprendre à coder à chaque programme/script/page dynamique : la syntaxe est la même, claire, lisible, standard depuis 30 ans (et moi j'ai 20 ans) et donc mes personalisations d'emacs sont les mêmes aussi.
# Re: Astuce pour compiler du C à la volée
Posté par Cédric Chantepie . Évalué à 1.
de l'astuce de Salagnac (voir http://linuxfr.org/tips/197.html(...)). Cette adaptation permet de faire des test en Java sans avoir à compiler puis interpreter, à la JIT shell.
===( Fichier "jit.sh" )===
#! /bin/sh
cat > /tmp/Test.java << EOF
public class Test {
public static void main(String[] args) {
EOF
tail +2 $1 >> /tmp/Test.java
cat >> /tmp/Test.java << EOF
}
}
EOF
javac /tmp/Test.java
rm -f /tmp/Test.java
java -classpath /tmp Test
rm -f /tmp/Test.class
===( Fin fichier "jit.sh" )===
Ensuite à chaque fois que l'on veux tester quelque chose en java en shell il suffit de executer un fichier sh du type :
#! /bin/sh [ABSOLUTE_PATH_TO]/jit.sh
System.out.println("#Test");
Suivre le flux des commentaires
Note : les commentaires appartiennent à celles et ceux qui les ont postés. Nous n’en sommes pas responsables.