Autour de Linux

Il y a deux commandes importantes pour la gestion des tâches d’impression. N’avez-vous jamais lancé une impression d’un document et puis de vous ravisez et de vouloir interrompre l’impression? N’avez-vous jamais lancé une impression pour vous rendre compte que la cartouche d’encre est vide et qu’il vaudrait mieux tout arrêter?

Deux simples commandes à introduire dans une console permettent de gérer le tâches d’impression (printer jobs). D’abord lpq qui affiche l’état de la file d’attente de l’imprimante (printer queue). Voilà, par exemple, ce qui s’affiche chez moi pendant l’impression d’un document:

$ lpq
DeskJet-6540 est prête et en cours d’impression
Rang    Propr.  Tâche  Fichiers                       Taille totale
active  nobody  214     smbprn.00000164 Microsoft Word  2205696 octets

Que peut-on tirer de cette commande? Premièrement, le nom de l’imprimante qui, soit dite en passant, est prête, cela veut dire qu’elle peut recevoir de nouvelles tâches, et qu’elle est en cours d’impression. Ensuite, sur les deux lignes suivantes, on voit le détail de l’impression en cours. Il s’agit d’un document word envoyé par samba, actif, ce qui veut dire que c’est ce document-là qui est imprimé en ce moment, et dont le numéro de tâche est 214. Ce numéro est important car c’est de lui dont on aura besoin pour tuer la tâche en cours.

La seconde commande est lprm qui permet de supprimer une tâche d’impression. Pour cela, il suffit de lui passer en argument le numéro de la tâche donné par lpq et que l’on veut supprimer de la file d’attente (printer queue):

$ lprm 214

ou

$lprm -

pour supprimer de la file toutes les tâches.

Voilà, vous avez pris un peu d’assurance, vous commencez à diviser votre code en plusieurs unités (ce qui est une bonne pratique) et vous avez plusieurs fichiers à compiler et à lier ensemble pour en faire une application. Inconvénient, la ligne de commande à taper au clavier dans une console devient beaucoup trop longue et impossible à gérer surtout si en plus vous utilisez quelques librairies. La solution est d’utiliser un fichier appelé makefile. Un makefile regroupe toutes les directives nécessaires au compilateur et au lieur pour créer votre exécutable.

Je vous propose ci-dessous un makefile générique qui devrait fonctionner dans la plupart des cas:

CC = g++
CFLAGS = -Wall
EXEC_NAME = nom_de_votre_exécutable
INCLUDES =
LIBS =
OBJ_FILES = fichier_1.o fichier_2.o
INSTALL_DIR = /usr/bin

all : $(EXEC_NAME)

clean :
  rm $(EXEC_NAME) $(OBJ_FILES)

$(EXEC_NAME) : $(OBJ_FILES)
  $(CC) -o $(EXEC_NAME) $(OBJ_FILES) $(LIBS)

%.o: %.cpp
  $(CC) $(CFLAGS) $(INCLUDES) -o $@ -c $<

%.o: %.cc
  $(CC) $(CFLAGS) $(INCLUDES) -o $@ -c $<

%.o: %.c
  gcc $(CFLAGS) $(INCLUDES) -o $@ -c $<

install :
  cp $(EXEC_NAME) $(INSTALL_DIR)

Voyons comment vous pouvez customiser ce makefile pour qu’il s’adapte à vos besoins.

CC= le compilateur que vous utiliser. Ici, c’est g++ mais ça pourrait être un autre.

CFLAGS = les options à passer au compilateur. Dans ce cas-ci, -Wall active tous les warnings.

EXEC_NAME = le nom de l’exécutable que vous désirez.

INCLUDES = le chemin vers les fichiers header nécessaire à la compilation. Par exemple, si vous utilisez la glib2, vous écrirez
INCLUDES = -I/usr/include/glib-2.0 -I/usr/lib/glib-2.0/include
Notez le switch -I devant le chemin.

LIBS = le chemin vers les librairies que vous utilisez. Par exemple dans le cas de la glib2 LIBS = -lglib-2.0 Le switch est -l. Si vous devez ajoutez une librairie statique et non plus un chemin vous ajoutez cette librairie avec son chemin directement. Pour reprendre notre exemple et y ajouter la librairie statique /usr/lib/libgpod.so, vous le faites sur la même ligne et sans switch: LIBS = /usr/lib/libgpod.so -lglib-2.0

OBJ_FILES = la liste des fichiers objets que vous devez obtenir.

all : $(EXEC_NAME) est ce qui va être appelé par make lorsque vous taper $ make dans une console.

clean : appelé par make lorsque vous taper $ make clean dans une console. Ici, cela delete les fichiers .o du répertoire.

install : appelé par make lorsque vous taper $ make install dans une console. Ici, cela copie l’exécutable dans le répertoire INSTALL_DIR qui dvrait se trouver dans le path.

Le reste sont des directives pour le compilateur et le lieur leur disant quoi faire en présence d’un fichier .cpp, .cc ou .c

ATTENTION: les lignes qui sont indentées le sont au moyen d’un caractère TAB et non pas d’espaces. C’est important.

Si vous utilisez Geany, L’option Make All dans le menu Construire appelle make et lance le all: de votre makefile.

Autre avantage des makefiles, seuls les fichiers modifiés ont besoin d’être recompilés. Make examine automatiquement les fichiers, détermine ceux qui doivent être recompilés, lance le compilateur et s’il y a lieu le lieur (linker). C’est une vrai facilité et un réel gain de temps pour le programmeur.

Dans une console, lorsque vous appuyez sur les flèches haute et basse, les commandes que vous avez tapé défilent dans un sens ou dans l’autre. C’est très pratique lorsqu’on a des commandes répétitives à entrer au clavier. Ca évite de devoir les retaper chaque fois. Mais de temps à autre, on aimerait vider cet historique. Ceci peut se faire très simplement avec la commande:

$ history -c

Si dans la console vous tapez Ctrl+r, vous pouvez, à l’instar de grep, faire une recherche dans l’historique. Imaginez que vous cherchiez par exemple quelle commande vous avez bien pu taper pour lister les modules chargés au démarrage. Tout ce dont vous vous souvenez c’est qu’il y avait mod dedans. Et bien, tapez Ctrl+r et ensuite mod et la commande lsmod dont vous ne vous souveniez plus apparaît.

Autre option intéressante: il est possible de sauvegarder (et même d’importer) tout l’historique dans un fichier. Je m’en sers lorsque je dois taper au clavier une série de commandes compliquées et que je voudrais bien en garder une trace pour le jour où j’aurai de nouveau besoin de cette suite de commandes. Dans ce cas, je procède comme suit:

$ history -c

Ceci vide l’historique. Ensuite, je tape ma série de commandes et je fais:

$ history -w mon_fichier

Cette dernière commande écrit dans mon_fichier le contenu de l’historique et donc dans ce cas la liste des commandes qui m’intéressent.

Je vous invite à lire la page de manuel de history parce qu’il a encore beaucoup d’autres possibilités à découvrir.

Si comme moi vous avez besoin du pavé numérique dès le login parce que vous avez des chiffres dans votre mot de passe, ceci vous intéressera peut-être. C’est un truc connu mais pour ne pas l’oublier lorsque vous ferez une fresh-install la prochaine fois, voici un petit rappel.

Il faut ajouter dans le fichier /etc/gdm/Init/Default les lignes suivantes:

test -x /usr/bin/numlockx && /usr/bin/numlockx on

Ceci teste si le programme numlockx existe et le lance.

Cette ligne est équivalente à celles ci-dessous qui sont sans doute plus faciles à comprendre (easier to read dit-on en anglais):

NUMLOCK="/usr/bin/numlockx"
if [ -x $NUMLOCK ]; then
$NUMLOCK on
fi

Si numlockx n’existe pas, il faut l’installer:

$ sudo aptitude install numlockx

Simple mais…efficace.

Il y a quelques jours, un collègue me disait apprendre le C++. Pour cela, il avait acheté un livre dont le tout premier exemple de C++ commencait par:

#include <iostream.h>

Le .h n’est pas nécessaire et même proscrit car non-standard.

#include <iostream>

La librairie standard C++ et pas seulement la STL (Standard Template Library) est entièrement dans le namespace std et la façon ANSI d’inclure un fichier d’entête est de ne pas mettre .h. Néanmoins, le fichier avec le .h existe en général pour des raisons de compatibilité (backward compatibility). D’ailleurs, si vous regardez dans votre PC sous Ubuntu, vous trouverez deux fichiers iostream par exemple, un sans le .h et un avec:

$ slocate iostream
/usr/include/c++/4.1.3/iostream
/usr/include/c++/4.1.3/backward/iostream.h

Cette façon de faire est dépendante du vendeur de la librairie et n’est pas du tout obigatoire. Il pourrait très bien ne fournir que la version sans .h.

Geany est un éditeur de texte avec des fonctions qui en font un petit environnement de développement léger.

• création de projets
• coloration syntaxique
• liste des fonctions, classes…
• compilation et link à partir de geany
• plugins
• …

C’est le programme idéal si vous écrivez de petits programmes ou pour débuter et apprendre la programmation.

Pour l’installer et pour pouvoir compiler, vous devrez installer les paquets suivants:

$ sudo aptitude install geany build-essential

Et comme vous êtes sous Ubuntu bien sûr 😉 et donc sous l’environnement Gnome, vous aurez besoin de la glib2. Pour pouvoir l’utiliser dans vos programmes, vous devez ajoutez aux options du compilateur le chemin vers les fichiers d’entêtes (#includes) et indiquer au linker où se trouve la librairie. Dans le menu Construire de Geany, cliquez sur Définir les includes et les options. Une fenêtre apparaît. Modifiez les champs Compiler et Construire en ajoutant `pkg-config glib-2.0 –cflags –libs` (attention aux ` !) . Les deux lignes doivent contenir quelque chose du genre:

Compiler : g++ -Wall -c "%f" `pkg-config glib-2.0 --cflags --libs`

Construire : g++ -Wall "%f" `pkg-config glib-2.0 --cflags --libs`
Essayons le petit programme suivant qui affiche Mon premier programme dans la console et puis sort. Rien de très excitant et en plus il n’utilise pas la glib2. Mais après tout, c’est juste pour essayer.

#include <iostream>
#include <string>
int main()
{
  std::string s("Mon premier programme!");
  std::cout<<s<<std::endl;
  return 0;
}

Cliquez dans le menu Construire sur Construire et si tout se passe bien, cliquez sur Exécuter dans le même menu. Une console devrait apparaître affichant votre message.