Catégorie : Programmation

Naviguer dans du code source grâce à des tags HTML

Blabla d’introduction

En tant que développeur, je suis souvent confronté au fait de retrouver des bouts précis de code source dans des dizaines de milliers de lignes de code. Pour ce faire, tout développeur connait ctags. Oui mais là, je voulais une sortie qui me génère un ensemble de fichiers HTML.

Voilà la solution…

Action

Il faut tout d’abord installer le paquet global

sudo apt-get install global

puis générer une liste des fichiers que l’on souhaite « tagger ».

ATTENTION: en théorie, on n’a pas besoin de générer une telle liste mais le problème, c’est que l’utilitaire gtags suit les liens symbolique comme un âne et si vous avez une boucle récursive, on va droit au message suivant : « Stack Overflow ».

donc pour générer le fichier :

cd /repertoire/dans/lequel/on/veut/faire/la/recherche

find . -iname "*.java" -o -iname "*.[ch]" -o -iname "*.xml" > files.txt

Dans ce cas, je liste les fichiers de type XML, JAVA, C et H.

Note: Pour de plus amples informations sur cette ligne => man find

puis on demande à gtags de créer les tags à partir de cette liste

gtags -v -f files.txt

et enfin on demande à htags de générer les fichiers html :

htags -v

ce qui donne en condensé :

find . -iname "*.java" -o -iname "*.[ch]" -o -iname "*.xml" > files.txt && ctags -f files.txt && htags

A la suite de l’ensemble des traitements, vous trouverez un dossier HTML dans le dossier racine de votre recherche et un beau fichier index.html qui vous permettra de naviguer facilement dans un gros code source.

malloc, kmalloc, etc…

Article originellement écrit par Rajendra David pour http://blog.emax.ath.cx le lundi 12 février 2007 à 22:36
Si vous vous amusez à mettre en place des structures en C et que vous avez commencé votre vie de geek par le Java, vous avez surement besoin de lire ce post.
Si vous utilisez malloc ou kmalloc (allocation de mémoire pour l’espace noyau), faites les proprement!!! Donc pas comme moi :-)

Après l’allocation de le mémoire, pensez à initialiser l’espace que vous avez alloué.

memset(NOM_STRUCTURE, 0, sizeof(STRUCTURE))

Cette fonction permet de remplir l’espace avec des 0. Vous pouvez bien sûr mettre la valeur que vous voulez.

N’oubliez pas que la dernière impression est essentielle, en gros soignez votre conclusion: prenez de la place, initialisez la, utilisez là ET rendez là!!!

free ou kfree

La fonction printf

Article originellement écrit par Rajendra David pour http://blog.emax.ath.cx le lundi 12 février 2007 à 21:19
Pour ceux qui ont, comme moi, du mal avec cette fonction et son formatage

La fonction printf


  • Syntaxe :
     #include 
     #int printf( const char *format [, arg [, arg]...]);
  • Description :Elle permet l’écriture formatée sur le flux standard de sortie stdout (l’écran par défaut).La chaîne de caractères format peut contenir à la fois :
    1. Des caractères à afficher,
    2. Des spécifications de format.

    Il devra y avoir autant d’arguments à la fonction printf qu’il y a de spécifications de format.

  • Valeur retournée :le nombre d’octets effectivement écrits ou la constante EOF (-1) en cas d’erreur.
  • Spécificateurs de format :ils sont introduites par le caractère % et se terminent par le caractère de type de conversion suivant la syntaxe suivante :
    % [drapeaux] [largeur] [.precision] [modificateur] type
     
    • drapeaux :

      drapeaux Signification
      rien justifié à droite et complété à gauche par des espaces
      - justifié à gauche et complété à droite par des espaces
      + les résultats commencent toujours par le signe + ou -
      espace le signe n’est affiché que pour les valeurs négatives
      # forme alternative. Si le type de conversion est :
      c,s,d,i,u : sans effet
      o : un 0 sera placé devant la valeur
      x, X : 0x ou 0X sera placé devant la valeur
      e, E, f : le point décimal sera toujours affiché
      g, G : même chose que e ou E, mais sans supprimer les zéros à droite

    • largeur : elle précise la nombre de caractères n qui seront affichés.Si la valeur à afficher dépasse la taille de la fenêtre ainsi définie, C utilise quand même la place nécessaire.

      largeur Effet sur l’affichage
      n affiche n caractères, complété éventuellement par des espaces
      0n affiche n caractères, complété éventuellement à gauche par des 0
      * l’argument suivant de la liste fournit la largeur

    • precision : elle précise pour :
      • un entier, le nombre de chiffres à afficher
      • un réel, le nombre de chiffres de la partie décimale à afficher (avec arrondi)
      • les chaînes, le nombre maximum de caractères à afficher.

      .precision Effet sur l’affichage
      rien précision par défaut :
      d,i,o,u,x : 1 chiffre
      e, E, f : 6 chiffres pour la partie décimale.
      .0 d,i,o,u,x : précision par défaut
      e, E, f : pas de point décimal
      .n n caractères au plus
      * l’argument suivant de la liste contient la précision

    • modificateur : Il précise comment sera interprété l’argument.

      Modificateur interprétation comme
      h un entier de type short (d,i,o,u,x,X)
      l un entier de type long (d,i,o,u,x,X)
      L un réel de type long double (e,E,f,g,G)

    • type : type de conversion de l’argument.

      Type Format de la sortie
      d ou i entier décimal signé
      o entier octal non signé
      u entier décimal non signé
      x entier hexadécimal non signé
      X entier hexadécimal non signé en majuscules
      f réel de la forme [-]dddd.ddd
      e réel de la forme [-]d.ddd e [+/-]ddd
      E comme e mais l’exposant est la lettre E
      g format e ou f suivant la précision
      G comme g mais l’exposant est la lettre E
      c caractère
      s affiche les caractères jusqu’au caractère nul ‘\0′
      ou jusqu’à ce que la précision soit atteinte
      p pointeur

  • Exemple :
    #include 
    main() {
    int nbre = 5;
    char *chaine = "Le langage C";
    long prix = 12.0L;
    long double result = prix * nbre;
    printf("Bonjour\n");
    printf("Nombre %d prix %ld Total %9ld\n",nbre, prix, prix * nbre);
    printf("%s est facile\n", chaine);
    printf("%8.2Lf \n", result);
    printf("%*.*Lf \n", 8, 2, result); /* equivalent a %8.2Lf */
    printf("\n"); /* affichage du caractère % */
    return 0;
    }
    /*-- résultat de l'exécution ------------------------------------
    Bonjour
    Nombre 5 prix 12 Total 60
    Le langage C est facile
    60.00 60.00 -----------------------------------------------------------------*/
  • Exemple d’utilisation des formats numériques :

    instruction C résultat
    printf(« |%d|\n »,12345); |12345|
    printf(« |%+d|\n »,12345); |+12345|
    printf(« |%8d|\n »,12345); | 12345|
    printf(« |%8.6d|\n »,12345); | 012345|
    printf(« |%x|\n »,255); |ff|
    printf(« |%X|\n »,255); |FF|
    printf(« |%#x|\n »,255); |0xff|
    printf(« |%f|\n »,1.23456789012345); |1.234568|
    printf(« |%10.4f|\n »,1.23456789); | 1.2346|

source http://membres.lycos.fr/dancel/c/c60_10.htm

(cherchez pas, c’est le même site)

Création dynamique de tableau à 2 dimensions en C

Article originellement écrit par Jean-François Pinçon pour http://blog.emax.ath.cx le mercredi 7 février 2007 à 01:55
Un jour, j’ai vu un oiseau et…

Plus sérieusement, je glandais devant l’ordi et une idée tordue pour un électronicien m’a traversée la tête : Faire une interpolation de Lagrange et par conséquence faire du calcul matriciel en C.

Bilan, j’avais besoin d’un tableau en 2 dimensions.

Dans les grandes lignes, il faut créer un tableau dans lequel chaque indice correspond à l’adresse d’un tableau.

Après, il est possible d’étendre le principe à n dimensions.

#include
#include

int main()

{

int i;
int dim1 = 3, dim2 = 5;

// Création dynamique d’un tableau à 2 dimensions
int** tab = (int**) malloc(dim1 * sizeof (int*) );
for (i=0; i<dim1; i++)
{
tab[i] = (int*) malloc (dim2 * sizeof (int) );
}

// Libération mémoire : tableau dynamique à 2 dimensions
for (i=0; i<dim1; i++)
{
free (tab[i]);
}
free(tab);
}

Introduction à l’Orienté Objet

Article originellement écrit par Rajendra David le dimanche 17 décembre 2006 à 22:05
Ma première intervention sur cette encyclopie du « Savoir Relatif et Absolu » concernera l’orienté objet en Java

La grande spécificité de java est d’être portable sur divers plateformes. En effet, un code compilé sur Windows peut être éxécuté sur une machin tournant avec le pinguin.
Mais Java c’est avant tout une language orienté objet.

Vous trouverez de la littérature sur le web à ce propos, je vais juste (humblement) essayer de vous faire sentir cette notion à travers des exemples très simples.

Le code en Java est structuré en classe. Alors kézakokecetruk?
Une classe est en fait une boite qui a des fonctionnalités.

Prenons pour exemple votre lecteur MP3. Ce dernier peut faire un certain nombre de chose: charger de la musique, écouter de la musique, baisser et augmenter le son, etc.
L’objet est le lecteur MP3 et les fonctions sont les fontionnalités que j’ai citées plus haut. De plus, ce lecteur MP3 contient des données que vous ne pouvez voir comme le nombre de fois que vous avez écouté les pistes ou le chemin de stockage des pistes MP3 dans la mémoire interne. Ces dernières sont appelées attributs.

C’est le programmeur qui va coder ces fonctions et attributs et qui va choisir ce qui est accessible de ce qui ne l’est pas, c’est le principe de l’orienté objet.
Vous êtes encore là? Bon pour les plus téméraires, je vais descendre un peu dans le code.

Voici un code typique en Java :

public class Lecteur_MP3
{

private int nbr_read; //nombre de fois que la musique est lue
private String path; //chemin où est stockée la musique

//Constructeur de la classe
public Lecteur_MP3()
{
//du code…
}

private void loadMusik()
{
//du code…
}

public void play(String nomMusik)
{
//du code…
}

public void increaseSound()
{
//du code…
}

public void decreaseSound()
{
//du code…
}

}

Non ce ne sont pas des formules sataniques, c’est bien du code qui permet de faire des programmes.
Voyons les principaux mots-clé:

  • « public » est un mot clé qui permet de dire que la fonction ou attribut est visible de l’extérieur.
  • « private » est le mot clé qui interdit l’acces à l’extérieur. Ainsi, seul l’objet lui même pourra y accéder.

Ces deux notions nous montrent déjà que cette boite (l’objet) contient des choses qui ne sont pas accessibles pour tout le monde. Il en est ainsi pour des raisons de sécurité et de propreté de programmation. Par exemple, quand on appuie sur le bouton pour augmenter le son, on ne veut pas que ce dernier déclenche le chargement des musiques.

Nous pouvons voir que nbr_read, path et loadMusik() ne sont pas accessibles de l’extérieur.

Ensuite qu’avons nous?

aaaa les types. Contrairement au C (ça n’est pas un reproche :-) ), le Java est très strict concernant le type des données. Un entier naturel est un entier naturel et pas un caractère!
Voici les types que j’ai évoqué dans mon code.

  • « int » ce type correspond aux entiers relatifs.
  • « String » ce type correspond à une chaine de caractère cad que ce type peut être une lettre, un mot ou une phrase. (donc rien à voir avec le bout de tissu du même nom…)
  • « void » vide en anglais.

Vous savez maintenant comment définir des attributs et des fonctions à savoir :
« accessibilité » « type » « nom de la fonction ou de l’attribut » et les données à entrer dans la fonctions si elle en a besoin. Ces dernières sont appelées argument.

Le type pour une fonction correspond au type de retour de la fonction. En effet, je n’ai pas trouvé d’exemple pour le lecteur MP3 mais une fonction peut retourner une donnée lorsqu’elle est appelée.
Prenons comme exemple une calculatrice. On pourrait avoir la fonction qui retourne la somme de deux chiffres fournis en argument. Nous aurons la déclaration suivante:

public int sum(int a, int b) //accessibilité type nom (argument)
{
return a+b;
}

Nous avons donc une fonction qui prend en argument deux entiers et qui retourne un entier. Le mot-clé return, finit la fonction est renvoie le résultat.

Mais alors quelle est l’utilité de définir un type qui correspond au vide? En fait, ce mot est utilisé dans la déclaration des fonctions. En effet, une fonction peut retourner des données mais peut ne rien retourner du tout (c’est son droit après tout) dans ce cas, on met « void » et on dénominera ces fontionnalités « méthode » plutot que fonction.

Voilà, vous savez le minimum vital sur Java.

Bon je suis de bonne humeur et c’est mon premier post, je vais donc faire ma BA de la journée (voir du mois) en révélant comment appeler une fonction en Java.

Lecteur_MP3 lecteurMP3 = new Lecteur_MP3; // pour créer l’objet, on dit « instancier » quand on veut se la jouer grand programmeur.
lecteurMP3.play(« I’m singing in the rain »); //lance cette fabuleuse musique

Manipulation de fichiers en JAVA

Article originellement écrit par Joel Bourrigaud et publié sur http://emax.ath.cx

Je commencerais ce billet par :

JAVA c bien, s’en passé c’est mieux ^^.

En effet le traitement de fichier est pas si simple et il faut savoir un truc important !!!!
JAVA gere les fichiers comme des flux d’entrees/sorties. donc si comme moi vous faites une lecture integrale d’un fichier via un InputStream alors NE PAS OUBLIER de la fermer via la methode .close()
Sinon des que vous voudrez deplacer ou faire quelque chose sur ce fichier vous n’aurez comme reponse que result=false. Enervant non ? pas d’exception pas d’explication claire alors j’ai decide de le dire ici :
voici un exemple qui montre comment bien gerer les flux JAVA.
// Definition des flux de lecture
FileReader aFileReader = new FileReader(NomFichierCompletAsString);
BufferedReader aBufferedReader = new BufferedReader(aFileReader);
//parse tout le fichier jusque EOF
while((ligneFichier = aBufferedReader.readLine()) != null){ … }
// fermer le flux !!!!
aBufferedReader .close();
aFileReader.close();
File sourceFile = new File(VotreFichierSourceAsString);
File destFile = new File(VotreFichierDesAsString);
boolean success = sourceFile.renameTo(destFile);
//renvoie toujours false si vous ne fermez PAS !! sinon peut renvoyer true si les dossiers/fichiers existent

Utilisation d’ethereal (maintenant wireshark)

Article orginellement écrit par Joel Bourrigaud le samedi 9 décembre 2006 à 13:42 et publié sur http://blog.emax.ath.cx

Qui ne connait pas ethereal ?

ben moi avant de faire un stage dessus ^^. Ce super site (http://lab.erasme.org/ethereal/) explique comment l’utiliser. si vous avez besoin de l’utiliser dans un programme et de décomposer les trames il faut utiliser les libPCAP qu’on trouve sur le net.
#include « pcap.h »

 void ReadPcap ( unsigned char *temp1, const struct pcap_pkthdr *header, const unsigned char *pkt_data)

le mieux pour recuperer chaque champs est de definir des structures :
typedef struct {

unsigned long    destination_debut;    //!< \param Adresse IP destination
unsigned short    destination_fin;    //!< \param Adresse IP destination
unsigned short    source_debut;        //!< \param Adresse IP source
unsigned long    source_fin;            //!< \param Adresse IP source
unsigned short    type;                //!< \param Type de protocole

} ethernet_header;

//! \struct Structure de l’en-tete IP
typedef struct {

unsigned char    ver_ip;            //!< \param Version du protocole IP + Taille du Header (IHL)
unsigned char    tos_ip;            //!< \param Type de Service, souvent à 0.
unsigned short    tlen_ip;        //!< \param Indique la taille totale du packet
unsigned short    indent_ip;        //!< \param Numéro de chaque fragment
unsigned short    flag_fragoff_ip;//!< \param Flag + Fragment Offset
unsigned char    ttl_ip;            //!< \param Time to Live du Packet
unsigned char    proto_ip;        //!< \param Protocole dont est issu le packet
unsigned short    checksum_ip;    //!< \param Header Checksum, vérification de l’intégrité de l’en-tête
ip_address        saddr_ip;        //!< \param Addresse IP de l’envoyeur
ip_address        daddr_ip;        //!< \param Addresse IP du destinataire

} ip_header;

Thèmes WordPress - WordPress tuto