Cunostinta va deschide lumea intelepciunii - Referate profesionale unice

Acasa » scoala » informatica » calculatoare
Structures simples et fichiers

Structures simples et fichiers

But :

- Utiliser des structures simples ;

Utiliser les principales fonctions d'accès à des fichiers disques.

On dispose de fichiers texte écrits en langage HPGL (HP Graphic Language : langage standard utilisé pour le pilotage des traceurs numériques). Ici, on ne va utiliser qu'une version réduite du langage : cinq instructions seulement. Le problème que l'on se propose de traiter, consiste à compiler le texte écrit en HPGL, de manière à obtenir un fichier objet qui sera constitué d'une suite de structures contenant les informations numériques permettant la commande des deux moteurs (en X et en Y) du traceur.

Exemple de fichier HPGL

SP4;PU;PA1000,1000;PD;PR0,10;PR-1,9;

Le caractère point virgule termine une instruction, tandis que la virgule sépare les arguments d'une même instruction quand ils sont plusieurs. De plus, il n'existe aucun autre séparateur (espace, tabulation), ni CR, ni LF.

Description des instructions HPGL utilisées

SPn; Select Pen : 1 n 8 est le numéro de plume

PU; Pen Up : lever la plume courante

PD; Pen Down : baisser la plume courante

PAxa,ya; Position Absolue : aller à la position (xa, ya)

PRxr,yr; Position Relative : partant de la position courante (x,y), aller jusqu'à la position absolue (x + xr, y + yr)

Toutes les coordonnées de position sont des entiers, l'unité étant le millième de pouce.

Description de la structure d'entrée utilisée

Chaque commande HPGL devra être associée à une structure d'entrée correspondante.

// Ensemble des commandes connues

enum;

// Nombre de paramètres numériques maximum d'une commande

#define NBMAXPARAM 2

typedef struct CommandeHpgl;

Structure correspondant à une commande HPGL d'entrée

Description de la structure de sortie utilisée

Les structures de sortie que vous allez devoir créer et stocker sur disque sont associées aux déplacements de la plume à effectuer selon des segments de droite (une structure par déplacement). Chaque déplacement est caractérisé par la plume qu'il utilise (numéro et état : up/down) et les coordonnées des points de départ et d'arrivée. Il faudra donc à partir de la structure d'entrée, reflet des données HPGL, remplir une suite de structures de sortie correspondant au modèle défini ci-après :

typedef struct Point ;

typedef struct Mouvement;

Structure correspondant au format de sortie

La structure de sortie respecte les règles suivantes :

Dans le membre plume de la structure de sortie, on stockera le code ASCII du numéro de plume contenu dans le fichier HPGL.

Les coordonnées de départ et d'arrivée sont toujours des coordonnées absolues.

Une nouvelle structure devra être créée à chaque fois que l'on modifie la position actuelle (commandes PA et PR).

On suppose qu'au départ, la plume est toujours située en position absolue (0,0).

Exemple :

Pour vous aider dans la mise au point de votre programme, nous vous donnons un exemple de conversion d'un fichier HPGL en fichier objet.

Fichier HPGL de départ :

SP4;PU;PA400,1000;PD;PR300,500;PR0,-1000; PR-300,500;PU;

SP2;PU;PA1300,1500; PD;PR500,0;PR-500,-1000;PU;PA0,0;

La structure d'entrée possèdera au fur et à mesure des lectures les valeurs suivantes :

commande	Param[0]	Param[1]
COMSP
COMPU
COMPA
COMPD
COMPR
COMPR
COMPR
COMPU
COMSP
COMPU

Le fichier objet obtenu contiendra les valeurs suivantes (on a représenté dans le tableau, le contenu des différentes structures de sortie créées en inscrivant une structure par ligne) :

n°

up/down

Le programme à développer comporte un programme principal (fonction main()) dans lequel un menu est proposé à l'utilisateur. Les choix possibles au niveau de ce menu sont :

la conversion d'un fichier HPGL en fichier objet ; pour cela la fonction main() fait appel à la fonction TraduireFichier(.), qui opère quatre traitements successifs :

lire une commande HPGL dans le fichier d'entrée (fonction LectureCommande(.))

transformer la commande lue en une structure d'entrée équivalente (fonction TraduireCommande(.) )

transformer la structure d'entrée en structure de sortie (fonction ConversionStructure(.) )

sauver si besoin la structure de sortie sur le disque (fonction EcritureCommande(.) )

l'édition d'un fichier objet ; dans ce cas, on fait appel à la fonction AfficherFichier(.),

la fin du programme.

L'ossature du programme principal vous est donnée en annexe. Elle est stockée dans le fichier Principal.c qui vous est fourni.

Pour pouvoir tester de manière progressive les quatre exercices suivants, vous pouvez modifier petit à petit la fonction TraduireFichier (Conversion.c).

Le format d'entrée

Exercice 1

Mettre au point la méthode LectureCommande (FichierEntree.c) qui permet la lecture d'une unique commande HPGL dans un tableau de caractères en enlevant le « ; » de fin de commande.

Exercice 2

Mettre au point la méthode TraduireCommande (FichierEntree.c) qui permet la traduction d'une unique commande HPGL contenue dans un tableau de caractères vers une structure d'entrée.

La conversion du format d'entrée vers le format de sortie

Exercice 3

Mettre au point la méthode ConversionStructure (Conversion.c) qui permet la traduction d'une structure d'entrée vers une structure de sortie.

Le format de sortie

Exercice 4

Mettre au point la méthode EcritureCommande (FichierSortie.c) qui permet la sauvegarde sur disque d'une structure de sortie.

Annexe : Les fichiers fournis à compléter

FichierEntree.h

* file FichierEntree.h

* brief Prototypes et structures de gestion d'un fichier au format hpgl

* @author Ivan LEPLUMEY

* @date : 22 novembre 2006 : création du fichier

#ifndef FICHIERENTREE

#define FICHIERENTREE

#include <stdio.h>

#include <stdlib.h>

#define BOOLEEN int

#define VRAI 1

#define FAUX 0

// Nombre de paramètre numériques maximum d'une commande

#define NBMAXPARAM 2

// Ensemble des commandes connues

enum;

// Nombre de commandes effectives

#define NBCOM 5

#define LGMAXTAMPON 20

// Séparateur entre commandes

#define SEPARATEUR ';'

// Structure mémoire correspondant à une commande d'entrée

typedef struct CommandeHpgl;

// Méthodes de manipulation du format d'entrée

void LectureCommande(FILE *f,char *com);

CommandeHpgl TraduireCommande(char *tampon);

#endif

FichierSortie.h

* file FichierSortie.h

* brief Prototypes et structures de gestion d'un fichier au

* format liste de vecteurs

* @author Ivan LEPLUMEY

* @date : 22 novembre 2006 : création du fichier

#ifndef FICHIERSORTIE

#define FICHIERSORTIE

#include <stdio.h>

#include <stdlib.h>

// Valeurs initiales pour un mouvement

#define PLUMINIT '1'

#define COORDONNEEINIT 0

// Valeur possible pour le lever/poser de plume

enum;

// Structure décrivant un point

typedef struct Point;

// Structure utilisée pour la description dans le fichier .lst

typedef struct Mouvement;

// Méthodes d'utilisation du format de sortie

void AfficherMouvements(FILE *pf);

void AfficherFichier(char *nom);

void InitialiserMouvement(Mouvement *result, char plume, char lever,

Point pDebut, Point pFin);

#endif

Conversion.h

* file Conversion.h

* brief Prototypes des méthodes de conversion de format

* @author Ivan LEPLUMEY

* @date : 22 novembre 2006 : création du fichier

#ifndef CONVERSION

#define CONVERSION

#include 'FichierEntree.h'

#include 'FichierSortie.h'

BOOLEEN ConversionStructure(CommandeHpgl *initiale, Mouvement *resultant);

void TraduireFichier(char *nome, char *noms);

#endif

FichierEntree.c

* file FichierEntree.c

* brief Fonctions d'utilisation d'un fichier au format hpgl

* @author Véronique HAESE-COAT, Michel JULLIERE

* @date : 22 novembre 2006 : création du fichier

#include 'FichierEntree.h'

#include 'FichierSortie.h'

* fn void LectureCommande(FILE *f,char *com)

* Lecture d'une commande du fichier d'entrée; le séparateur (;) entre

* commande est enlevé

* param[in] f descripteur du fichier d'entrée

* param[out] com commande prélevée dans le fichier

* fn CommandeHpgl TraduireCommande(char *tampon)

* Traduction d'une commande textuelle vers un format interne

* param[in] tampon tampon contenant la commande à traduire

* return la commande en format interne

FichierSortie.c

* file FichierSortie.c

* brief Fonctions d'utilisation d'un fichier au nouveau format

* @author Véronique HAESE-COAT, Michel JULLIERE

* @date : 22 novembre 2006 : création du fichier

#include 'FichierSortie.h'

* fn void AfficherMouvements(FILE *pf)

* Affichage de l'ensemble des mouvements contenus dans le fichier

* param[in] pf descripteur du fichier

void AfficherMouvements(FILE *pf) , n',

mm.plume, mm.up, mm.dep[0], mm.dep[1], mm.arr[0], mm.arr[1]) ;

}

* fn void AfficherFichier(char *nom)

* Affichage du contenu d'un fichier

* param[in] nom nom du fichier à afficher

void AfficherFichier(char *nom)

* fn void InitialiserMouvement(Mouvement *result, char plume, char lever,

* Point pDebut, Point pFin)

* Intialisation d'une structure de mouvement

* param[out] result structure de mouvement à initialiser

* param[in] plume numéro de la plume à utiliser

* param[in] lever état de la plume

* param[in] pDebut point initial

* param[in] pFin point final

void InitialiserMouvement(Mouvement *result, char plume, char lever,

Point pDebut, Point pFin)

* fn void EcritureCommande(FILE *fs, Mouvement *resultat)

* Ecriture d'un mouvement dans un fichier

* param[in] fs descripteur du fichier de sortie

* param[in] resultat mouvement à écrire

Conversion.c

* file Conversion.c

* brief Méthodes de conversion de format

* @author Ivan LEPLUMEY

* @date : 22 novembre 2006 : création du fichier

#include 'Conversion.h'

* fn BOOLEEN ConversionStructure(CommandeHpgl *initiale, Mouvement *resultant)

* Traduction d'une commande du premier format vers le second

* param[in] initiale commande dans le format initial

* param[out] resultant commande dans le format final

* return VRAI si la traduction a été effectuée

* fn void TraduireFichier(char *nome, char *noms)

* Traduction d'un fichier d'entrée en fichier de sortie

* param[in] nome nom du fichier d'origine

* param[in] noms nom du fichier résultat

void TraduireFichier(char *nome, char *noms)

fs=fopen(noms,'wb');

if (!fs)

comLoc.commande=COMINIT;

//ConversionStructure(&comLoc, &resultat);

while(!feof(fe))

}

// Fermeture des fichiers

fclose(fe);

fclose(fs);

Principal.c

* file Principal.c

* brief Programme principal de test du programme de conversion de fichiers au

* format hpgl

* @author Ivan Leplumey

* @date : 22 novembre 2006 : création du fichier

#include <strings.h>

#include 'FichierEntree.h'

#include 'FichierSortie.h'

#define OK 0

#define TMAX 60

#define TMENU TMAX*4

#define SUFFIXE 'lst'

#define LIMITEUR '.'

enum;

* fn void RemplacerSuffixe(char *init, char *res, char *suffixe)

* Changement du suffixe d'un nom de fichier

* param[in] init nom d'origine du fichier

* param[out] res nom du fichier final

* param[in] suffixe suffixe à mettre pour le nom final

void RemplacerSuffixe(char *init, char *res, char *suffixe)

else

// Ajout du LIMITEUR précédent le suffixe

res[pos]=LIMITEUR;

// Ajout du suffixe

strcpy(&res[pos+1],suffixe);

* fn void main()

* Programme principal de test des fonctions de transcodage de format

int main(void) /* fin de case : CONVERTIR */

case VISUALISER: /* fin de case : VISUALISER */

} /* fin de switch(rep) */

} while(rep != SORTIR) ;

return(OK);

} /* fin du main */

Politica de confidentialitate

.com	Copyright © 2024 - Toate drepturile rezervate. Toate documentele au caracter informativ cu scop educational.

Structures simples et fichiers

Comentarii literare

Personaje din literatura

Tehnica si mecanica

Economie

Geografie