Skip to content

2.4 Tamgu comme langage de script

Jump to bottom
Claude Roux edited this page Oct 19, 2022 · 2 revisions

Tamgu comme langage de script

English Version

Tamgu est un langage de programmation qui offre une combinaison des paradigmes impératifs, fonctionnels et logiques...

Mais surtout, Tamgu peut aussi être utilisé comme langage de script à la façon de « Awk » ou de « Perl ».

Standard Input: stdin

Après tout, pour utiliser un langage de programmation comme langage de script, il suffit d’intercepter le « standard input » : stdin. Autrement dit, il faut pouvoir placer dans une suite de « pipes » votre code qui appliquera la transformation voulue sur la sortie du programme précédent.

Nous voudrions avoir quelque chose qui ressemble à ça:

ls -1 | tamgu … | …

En fait, c'est exactement ce que Tamgu vous donne et même plus encore...

Différents modes

Tamgu offre deux modes différents pour vous permettre de l'utiliser comme langage de script:

  • Un mode dynamique: chaque entrée est interceptée et modifiée à la volée
  • Un mode exploratoire: on récupère toutes les entrées et on écrit un script pour les manipuler

Le mode dynamique: -p, -pb, -pe.

  • L’option « -p »permet de fournir quelques instructions Tamgu sur la ligne de commande.
  • L’option « -pb » permet de fournir quelques instructions d’initialisation
  • L’option « -pe » permet de fournir quelques instructions finales.

L'option « -p » en plus vous offre gratuitement les variables prédéclarées suivantes:

    bool a,b,c;
    int i,j,k;
    float f,g,h;
    string s,t,u;
    map m;
    vector v;

Ces variables peuvent être utilisées n'importe où dans votre code. Quant à la ligne courante lue depuis stdin, elle est directement accessible via une autre variable offerte généreusement par Tamgu: « l ».

Voici donc à quoi pourrait ressembler un filtre sur les noms de fichier:

ls -1 | tamgu -p " if (’.txt’ in l) println(l);"

Autrement dit, on ne choisit que les fichiers qui ont « .txt » comme extension.

test23.txt
test123.txt
...

Vous pouvez aussi initialiser certaines variables avant coup:

ls -1 | tamgu -pb "i=1;" —p " if ('.txt’ in l) println(i,l); i++;"

Dans l’exemple ci-dessus, nous initialisons « i », une variable prédéclarée, à 1. De cette façon, on peut afficher la liste des fichiers filtrés en les numérotant à partir de 1 au lieu de 0.

1 test23.txt
2 test123.txt
...

Vous pouvez aussi afficher votre solution sous la forme d’un vecteur à la toute fin de l'exécution, grâce à « -pe ».

ls -1 | tamgu —p "if (’.txt’ in l) v. push(l);" -pe "println(v);"

A chaque itération, on sauvegarde « l » dans un vecteur et en fin d’exécution on affiche ce vecteur. « v » est bien sûr une variable prédéclarée.

["test123.txt","test23.txt", ...]

Attention, si vous déclarez une variable dans la section « -p », celle-ci sera réinitialisée à chaque itération. Si vous voulez une variable qui survive, il faut la déclarer dans la section « -pb ».

Lecture d'un fichier

Tamgu offre une méthode particulière associée au type « string »: read. La méthode « read » ouvre un fichier et en lit le contenu, ce qui permet d'effectuer certaines opérations très rapides.

ls -1 | tamgu -p "if ('.txt' in l) {\\
        s.read(l); if ("TOTO" in s and "TITI" in s) println(s["TITI":100]);}"

Ainsi, en une opération, on teste l'extension du nom de fichier, on lit le contenu du fichier dans la variable « s » et on vérifie que ce contenu contient les chaines "TOTO" et "TITI". On affiche alors les 100 caractères commençant à partir de la position de "TITI" dans le fichier. C'est une façon de faire un « grep » certes un peu compliqué, mais qui offre l'avantage de combiner plusieurs tests ensemble avec des opérateurs Booléens.

Exploratoire: -a

Evidemment, la méthode au-dessus n’est valable que si le code qui suit « -p » est petit. Un code trop long peut vite devenir très complexe à lire ou à corriger. Tamgu propose une autre façon de gérer stdin: « -a ».

« -a » lit l’intégralité de stdin et place chaque ligne dans le vecteur « _args » qui dans Tamgu sert à enregistrer les arguments sur la ligne de commande.

Il existe deux façons d’exploiter ce vecteur.

A la façon de « -p » en fournissant du code après. Dans ce cas, votre code devra lui-même boucler sur « _args ».

Si aucun code n’est fourni, alors Tamgu ouvre une console dans le terminal, dans laquelle vous pouvez commencer à jouer avec « _args ».

ls -1 | tamgu -a

ce qui donne:

Tamgu 1.2022.10.11.18(탐구)
Copyright 2019-present NAVER Corp.
64 bits

help: display available commands

◀▶2> _args
['LICENSE','Makefile','Makefile.in','NOTICE','README.md','Tamgu_license.txt',...]
◀▶2> edit

Voici à quoi ressemble votre environnement lorsque vous effectuez cette commande. Comme vous pouvez le voir, vous pouvez afficher facilement dans la console le contenu de _args.

Vous pouvez lancer autant d’exécution que vous voulez, _args contiendra toujours les mêmes données provenant de stdin. Nul besoin de lancer et relancer la commande initiale.

Editeur interne

Tamgu contient son propre éditeur interne avec lequel il est possible non seulement d’écrire du code mais aussi de débogguer. Pour le lancer, il suffit de taper la commande: « edit ».

작1> bool a,b,c;int i,j,k;float f,g,h;string s,t,u;map m;vector v;self x,y,z;
작2> 
작3> for (s in _args)
작4>     println(s);
작5>

Comme c’est le cas pour l’option « -p », Tamgu pré-déclare quelques variables que l’on voit apparaître dans l’éditeur.

Autant ces variables vont être réinitialisées à chaque exécution, autant « _args » contiendra toujours les mêmes données exécution après exécution. De cette façon, il devient possible de perfectionner le script pour qu’il donne le résultat attendu.

_sys: bibliothèque système

Tamgu comprend aussi une variable _sys qui permet d’effectuer un certain nombre d’opérations système:

_sys.ls(chemin): renvoie la liste des fichiers et des répertoires dans « chemin ».  
_sys.mkdir(chemin): construit un répertoire.
_sys.isdirectory(chemin): renvoie « true » si chemin est un répertoire.
_sys.realpath(chemin): renvoie le chemin expansé de chemin.
_sys.fileinfo(chemin): renvoie les informations du fichier pointé par chemin.
_sys.env(var,val): modifie ou renvoie la variable d’environnement var.

Mais surtout

_sys.command(command): exécute une commande système.

Grâce à « _sys.command(…) », il est possible d’exécuter des commandes système directement depuis un script Tamgu.

작1> bool a,b,c;int i,j,k;float f,g,h;string s,t,u;map m;vector v;self x,y,z;
작2> 
작3> for (s in _args)
작4>     sys.command("cp " + s + "../toto");
작5>

Variables « through »

Tamgu offre enfin un dernier type de variable tout à fait unique (enfin je crois): les variables « through ». Une variable « through » est une variable qui survit à plusieurs exécutions successives, exactement comme _args. De cette façon, il devient possible de garder la trace d’exécution successive.

Le type de la variable est indiquée par la première lettre avec le mot clef « through ».

    ithrough: est un entier
    sthrough: est une string
    vthrough: est un vecteur de strings
    mthrough: est un map de clef et valeur de type string

Voici par exemple, un script qui calcule à chaque itération le temps passé à appliquer une modification sur les arguments.

작 1> bool a,b,c;int i,j,k;float f,g,h;string s,t,u;map m;vector v;self x,y,z;  
작 2> vthrough vv;
작 3> 
작 4> time t1;
작 5> for (s in _args)
작 6>     _sys.command(...);
작 7> time t2;
작 8> float d = t2-t1;
작 9> 
작10> vv.push(d);
작11> 
작12>

A chaque exécution, le temps nécessaire pour effectuer la commande est conservé dans vv. Après dix exécutions, vv contiendra dix valeurs de temps différentes.

Attention: Cette variable perd sa valeur dès que l'on sort de Tamgu... Les valeurs ne sont conservées que pour une session donnée.

Combiner avec un nom de fichier

Vous pouvez enfin définir un nom de fichier au moment où vous lancez votre commande Tamgu et passer en mode « éditeur » immédiatement. La seule contrainte est de mettre l’option « -a » en fin de commande.

ls -1 | tamgu -e monfichier.tmg —a

Si « monfichier.tmg » existe, il sera automatiquement chargé, sinon il sera créé.

Vous pouvez désormais exécuter ce fichier directement sur vos données.

ls -1 | tamgu monfichier.tmg —a

La seule différence est que le nom est donné directement…

Clone this wiki locally