From f827e94fb192dbfd4776d7a8d8e1cbc149713099 Mon Sep 17 00:00:00 2001
From: dling <dylan.ling.etu@univ-lille.fr>
Date: Tue, 19 Dec 2023 22:22:33 +0100
Subject: [PATCH] Ecriture et lecture partiellement partiellement fonctionnelle
---
SD/picofs.c | 236 ++++++++++++++++++++++++++++------------------------
1 file changed, 128 insertions(+), 108 deletions(-)
diff --git a/SD/picofs.c b/SD/picofs.c
index 6cdb132..9cc3640 100755
--- a/SD/picofs.c
+++ b/SD/picofs.c
@@ -13,35 +13,30 @@
#define CHUNK_SIZE 64
#define CMD_SIZE 100
-#define BLOC_NO 16
+
#define BLOCK_SIZE 512
#define MAX_FILENAME_LENGTH 16
#define MAX_BLOCKS_PER_FILE 16
-#define MAX_FILES_IN_DIRECTORY 1024
+#define MAX_FILES_IN_DIRECTORY 64
+#define MAX_BLOCKS_IN_SUPERBLOCK 1024
#define FILESYSTEM_SIZE (8 * 1024 * 1024) // 8 Mo
#define FIRST_DISPONIBILITY_CARD_BLOCK 1024
#define MAX_BLOCKS_PER_FILE_DESCRIPTION 16
#define FIRST_DATA_BLOCK 1040
-void readBlock(SD_info *sd, unsigned int numBlock, int offset, unsigned char *storage, int size) {
- //lire à un endroit spécifique du bloc de la carte SD
-
- //uint8_t * buffer_read = malloc (sizeof(char)*BLOCK_SIZE);
- //if(buffer_read == NULL) printf("erreur malloc read");
- readData(sd,numBlock,offset, size, storage);
- //strcpy(storage,(unsigned char *)buffer_read);
- //free(buffer_read);
+void readBlock(SD_info *sd, unsigned int numBlock, int offset, char *storage, int size) {
+
+ readData(sd,numBlock,offset, size, (uint8_t*) storage);
}
-void writeBlock(SD_info *sd, unsigned int numBlock, int offset, unsigned char *source, int size) {
- //écrire à un endroit spécifique du bloc de la carte SD
- uint8_t * buffer_write = malloc (sizeof(char)*BLOCK_SIZE); //sauve les données du bloc
- if(buffer_write == NULL) printf("erreur malloc write");
- readData(sd, numBlock, 0, size, buffer_write);
+void writeBlock(SD_info *sd, unsigned int numBlock, int offset, char *source, int size) {
+
+ char buffer_write[BLOCK_SIZE/2];
+ readData(sd, numBlock, 0, size, (uint8_t *)buffer_write);
if(offset + size > 512 )
{
- printf("data to write is too big");
+ printf("data to write is too big\n");
return;
}
for (int i = size - 1; i >= 0; i--) {
@@ -51,16 +46,17 @@ void writeBlock(SD_info *sd, unsigned int numBlock, int offset, unsigned char *s
for (int j = 0; j < offset; j++) {
source[j] = buffer_write[j];
}
+ //free(buffer_write);
writeBlockSD(sd,numBlock, (uint8_t *)source);
- free(buffer_write);
+
}
void LS(SD_info *sd) {
- unsigned char buffer[MAX_FILENAME_LENGTH];
+ char buffer[MAX_FILENAME_LENGTH];
int fileCount = 0;
-
- // Parcourir les blocs multiples de 16 à partir de 0 jusqu'à MAX_FILES_IN_DIRECTORY
- for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
+ printf("\n");
+ // Parcourir les blocs multiples de 16 à partir de 0 jusqu'à MAX_BLOCKS_IN_SUPERBLOCK
+ for (int blockNum = 0; blockNum < MAX_BLOCKS_IN_SUPERBLOCK; blockNum += 16) {
readBlock(sd,blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le nom de fichier est vide
@@ -72,7 +68,7 @@ void LS(SD_info *sd) {
}
if (fileCount == 0) {
- printf("Aucun fichier trouvé.\n");
+ printf("\nAucun fichier trouvé.\n");
}
}
@@ -80,17 +76,18 @@ void LS(SD_info *sd) {
void setBlockAvailability(SD_info *sd, int blockNum, int availability) {
int byteIndexInCard = blockNum / 8; //Numéro d'octet dans la carte des blocs libres
- int blockIndexInCard = byteIndexInCard / 256; //Numéro du bloc dans la carte des blocs libres
- int byteIndexInBlock = byteIndexInCard % 256; //Numéro d'octet dans le bloc contenant le bit de disponibilité
+ int blockIndexInCard = byteIndexInCard / 512; //Numéro du bloc dans la carte des blocs libres
+ int byteIndexInBlock = byteIndexInCard % 512; //Numéro d'octet dans le bloc contenant le bit de disponibilité
int bitOffset = blockNum % 8; //Numéro du bit dans l'octet n°byteIndexInBlock du bloc blockIndexInCard
//indice du bloc contenant le bit à mettre à jour dans le bloc de description
int availabilityBlockNum = FIRST_DISPONIBILITY_CARD_BLOCK + blockIndexInCard;
// Lire l'octet existant dans le bloc de disponibilité du super bloc
- unsigned char buffer;
- readBlock(sd, availabilityBlockNum, byteIndexInBlock, &buffer, 1);
-
+ char buffer512[BLOCK_SIZE/2];
+ char buffer;
+ readBlock(sd, availabilityBlockNum, byteIndexInBlock, buffer512, 1);
+ buffer = buffer512[0];
// Mettre à jour le bit d'offset correspondant :
if (availability==1) { // indisponible
buffer |= (1 << bitOffset); // Mettre le bit à 1
@@ -100,25 +97,26 @@ void setBlockAvailability(SD_info *sd, int blockNum, int availability) {
}
// Écrire l'octet mis à jour dans le bloc de disponibilité du super bloc
- writeBlock(sd,availabilityBlockNum, byteIndexInBlock, &buffer, 1);
+ writeBlock(sd,availabilityBlockNum, byteIndexInBlock, buffer512, 1);
+
}
int min(int a, int b) {
return a < b ? a : b;
}
-void RM(SD_info *sd, const char *filename) {
+void RM(SD_info *sd, char *filename) {
int fileFound = -1;
int offset;
- unsigned char fileBuffer[BLOCK_SIZE];
+ char fileBuffer[BLOCK_SIZE];
// Parcourir les blocs réservés pour la description des fichiers (superbloc)
- for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
- unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
+ for (int blockNum = 0; blockNum < MAX_BLOCKS_IN_SUPERBLOCK; blockNum += 16) {
+ char filenameBuffer[MAX_FILENAME_LENGTH];
readBlock(sd,blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc contient le nom du fichier recherché
- if (strncmp((const char *)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
+ if (strncmp(filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(sd,blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
@@ -130,27 +128,27 @@ void RM(SD_info *sd, const char *filename) {
// Fin de fonction si fichier inexistant
if (fileFound == -1) {
- printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
+ printf("\nLe fichier \"%s\" n'a pas été trouvé.\n", filename);
return;
}
- for (int blockNum = offset; blockNum < offset + 16; blockNum++) {
+ for (int blockNum = offset+1; blockNum < offset + 16; blockNum++) {
int startOffset = 0;
if (blockNum == offset) {
startOffset = MAX_FILENAME_LENGTH;
}
- for (int chunkStart = startOffset; chunkStart < BLOCK_SIZE; chunkStart += CHUNK_SIZE) {
- int chunkSize = min(CHUNK_SIZE, BLOCK_SIZE - chunkStart);
+ for (int chunkStart = startOffset; chunkStart < BLOCK_SIZE/2; chunkStart += CHUNK_SIZE) {
+ int chunkSize = min(CHUNK_SIZE, BLOCK_SIZE/2 - chunkStart);
readBlock(sd,blockNum, chunkStart, fileBuffer, chunkSize);
for (int i = 0; i < chunkSize; i += 2) {
int blockNumData = (fileBuffer[i] << 8) | fileBuffer[i + 1];
- printf("blockNumData=%d\n",blockNumData);
+
if (blockNumData == 0) {
writeBlock(sd,blockNum, chunkStart, fileBuffer, chunkSize);
- printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
+ printf("\nLe fichier \"%s\" a été supprimé avec succès.\n", filename);
return; // Sortir des boucles
}
setBlockAvailability(sd,blockNumData, 0); // Marquer le bloc comme disponible
@@ -162,30 +160,30 @@ void RM(SD_info *sd, const char *filename) {
}
}
- printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
+ printf("\nLe fichier \"%s\" a été supprimé avec succès.\n", filename);
}
// Fonction qui modifie le nom du fichier
-void MV(SD_info *sd, const char *old_filename, const char *new_filename) {
+void MV(SD_info *sd, char *old_filename, char *new_filename) {
size_t sizeNew_filename = strlen(new_filename);
- size_t sizeOld_filename = strlen(old_filename);
- unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
+ //size_t sizeOld_filename = strlen(old_filename);
+ char filenameBuffer[MAX_FILENAME_LENGTH];
int fileFound = 0;
// Parcourir les blocs réservés pour la description des fichiers (superbloc)
- for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
+ for (int blockNum = 0; blockNum < MAX_BLOCKS_IN_SUPERBLOCK; blockNum += 16) {
readBlock(sd,blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc contient le nom du fichier recherché
- if (strncmp((const char*)filenameBuffer, old_filename, MAX_FILENAME_LENGTH) == 0) {
+ if (strncmp(filenameBuffer, old_filename, MAX_FILENAME_LENGTH) == 0) {
if (sizeNew_filename < MAX_FILENAME_LENGTH) {
sizeNew_filename+=1;
}
// Écrire le nom du fichier dans l'emplacement
- writeBlock(sd,blockNum, 0, (const unsigned char *)new_filename, sizeNew_filename);
+ writeBlock(sd,blockNum, 0, new_filename, sizeNew_filename);
fileFound=1;
@@ -193,15 +191,15 @@ void MV(SD_info *sd, const char *old_filename, const char *new_filename) {
}
}
if (fileFound == 1) {
- printf("Le nom du fichier \"%s\" a été renommé avec succès.\n", old_filename);
+ printf("\nLe nom du fichier \"%s\" a été renommé avec succès.\n", old_filename);
} else {
- printf("Le fichier \"%s\" n'a pas été trouvé.\n", old_filename);
+ printf("\nLe fichier \"%s\" n'a pas été trouvé.\n", old_filename);
}
}
// Renvoie le premier bloc de donné disponible
int findAvailableBlock(SD_info *sd) {
- unsigned char availabilityBuffer[BLOCK_SIZE];
+ char availabilityBuffer[BLOCK_SIZE];
int offset;
// Lire la carte de disponibilité (à partir du bloc 1)
@@ -216,7 +214,7 @@ int findAvailableBlock(SD_info *sd) {
// Parcourir les octets de la carte de disponibilité
for (int byteIndex = offset; byteIndex < BLOCK_SIZE; byteIndex++) {
- unsigned char byte = availabilityBuffer[byteIndex];
+ char byte = availabilityBuffer[byteIndex];
// Parcourir les bits de chaque octet
for (int bitIndex = 0; bitIndex < 8; bitIndex++) {
@@ -235,37 +233,37 @@ int findAvailableBlock(SD_info *sd) {
}
// Fonction qui reconstitue le numéro de bloc à partir du tableau
-int reconsituteNumber(unsigned char blockNumberBuffer[2]) {
- unsigned char octet1 = blockNumberBuffer[0];
- unsigned char octet2 = blockNumberBuffer[1];
+int reconsituteNumber(char blockNumberBuffer[2]) {
+ char octet1 = blockNumberBuffer[0];
+ char octet2 = blockNumberBuffer[1];
int dataBlockNum = (octet1 << 8) | octet2;
return dataBlockNum;
}
// Fonction qui réparti un numéro de bloc sur deux octets
-void createNumberBuffer(int dataBlockNum, unsigned char blockNumberBuffer[2]) {
+void createNumberBuffer(int dataBlockNum, char blockNumberBuffer[2]) {
blockNumberBuffer[0] = (dataBlockNum >> 8) & 0xFF;
blockNumberBuffer[1] = dataBlockNum & 0xFF;
}
-void TYPE(SD_info *sd, const char *filename) {
+void TYPE(SD_info *sd, char *filename, char *data) {
size_t sizeFilename = strlen(filename);
- unsigned char buffer[MAX_FILENAME_LENGTH];
+ char buffer[MAX_FILENAME_LENGTH];
int placeFound = -1;
- int index_description_block = 0; // indice du bloc de descrption
+ int index_description_block = 1; // indice du bloc de descrption
int block_counter = 1; //compteur de blocs utilisés
int index_in_descrBlock = 0;
int offset;
- int first_loop=1;
+
if (sizeFilename > MAX_FILENAME_LENGTH) {
- printf("Impossible de créer le fichier, nom trop long\n");
+ printf("\nImpossible de créer le fichier, nom trop long\n");
return;
}
// Parcours des blocs réservés pour la description des fichiers (superbloc)
- for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
+ for (int blockNum = 0; blockNum < MAX_BLOCKS_IN_SUPERBLOCK; blockNum += 16) {
readBlock(sd,blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
@@ -273,42 +271,38 @@ void TYPE(SD_info *sd, const char *filename) {
if (sizeFilename < MAX_FILENAME_LENGTH) {
sizeFilename += 1; // Ajouter '\0' s'il y a de la place
}
- writeBlock(sd,blockNum, 0, (const unsigned char *)filename, sizeFilename);
+ writeBlock(sd,blockNum, 0, filename, sizeFilename);
placeFound = blockNum;
// Lire les données depuis l'entrée standard et écrire dans le fichier
int dataBlockNum = findAvailableBlock(sd); // Premier bloc de données à partir du bloc 1040
int blockSizeUsed = 0; // Compteur d'octets dans le bloc actuel
- unsigned char chunkBuffer[CHUNK_SIZE];
+ char chunkBuffer[CHUNK_SIZE];
size_t bytesRead;
+
- while ((bytesRead = fread(chunkBuffer, 1, CHUNK_SIZE, stdin)) > 0) {
-
+ bytesRead = strlen(data);
+ strcpy(chunkBuffer,data);
// Écrire le chunk dans le bloc de données
writeBlock(sd,dataBlockNum, blockSizeUsed, chunkBuffer, bytesRead);
setBlockAvailability(sd,dataBlockNum, 1);
-
// Écrire le numéro du bloc actuel dans la description du fichier
- unsigned char blockNumberBuffer[2];
+ char blockNumberBuffer[64];
createNumberBuffer(dataBlockNum,blockNumberBuffer);
-
blockSizeUsed += bytesRead;
// Si le bloc actuel est plein, passer au bloc suivant OU si c'est le premier tour dans la boucle
- if (blockSizeUsed == BLOCK_SIZE || first_loop == 1) {
-
- first_loop = -1;
-
// Ecriture du numéro de bloc utilisé dans les blocs de description
if (index_description_block == 0) {
offset = MAX_FILENAME_LENGTH;
} else {
offset = 0;
}
+
writeBlock(sd,placeFound + index_description_block, offset + index_in_descrBlock*2, blockNumberBuffer, 2);
index_in_descrBlock++;
-
+
dataBlockNum = findAvailableBlock(sd); // Passer au bloc suivant
blockSizeUsed = 0; // Réinitialiser la taille utilisée
@@ -326,8 +320,7 @@ void TYPE(SD_info *sd, const char *filename) {
printf("Le fichier a atteint sa taille maximale\n");
return;
}
- }
- }
+
break; // Fichier créé, sortir de la boucle
}
@@ -338,25 +331,27 @@ void TYPE(SD_info *sd, const char *filename) {
} else {
printf("Plus de place dans le système de fichier pour créer ce fichier.\n");
}
+
+
}
-void CAT(SD_info *sd, const char *filename) {
- unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
- unsigned char byteBuffer[2];
- unsigned char dataBuffer[CHUNK_SIZE];
+void CAT(SD_info *sd, char *filename) {
+ char filenameBuffer[MAX_FILENAME_LENGTH];
+ char byteBuffer[CHUNK_SIZE];
+ char dataBuffer[CHUNK_SIZE];
int offset;
// Parcours des blocs réservés pour la description des fichiers (superbloc)
- for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
+ for (int blockNum = 0; blockNum < MAX_BLOCKS_IN_SUPERBLOCK; blockNum += 16) {
readBlock(sd,blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc contient le nom du fichier recherché
- if (strncmp((const char *)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
+ if (strncmp(filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Le nom du fichier a été trouvé
// Parcours les blocs de description
- for (int descrBlockNum=0; descrBlockNum<MAX_BLOCKS_PER_FILE_DESCRIPTION; descrBlockNum++) {
+ for (int descrBlockNum=1; descrBlockNum<MAX_BLOCKS_PER_FILE_DESCRIPTION; descrBlockNum++) {
if (descrBlockNum==0) {
offset=MAX_FILENAME_LENGTH;
} else {
@@ -369,17 +364,16 @@ void CAT(SD_info *sd, const char *filename) {
// Lire les numéros de blocs associés à ce fichier depuis les blocs de description
int dataBlockNum = reconsituteNumber(byteBuffer);
-
// Vérifier si le numéro de bloc est valide (non nul)
if (dataBlockNum == 0) {
return; // Fin du fichier
}
- for (int chunkStart = 0; chunkStart < BLOCK_SIZE; chunkStart += CHUNK_SIZE) {
+ //for (int chunkStart = 0; chunkStart < BLOCK_SIZE; chunkStart += CHUNK_SIZE) {
// Lire et afficher le contenu du bloc de données
- readBlock(sd,dataBlockNum, chunkStart, dataBuffer, CHUNK_SIZE);
- fwrite(dataBuffer, 1, CHUNK_SIZE, stdout);
- }
+ readBlock(sd,dataBlockNum, 0, dataBuffer, CHUNK_SIZE);
+ printf("\n%s\n",dataBuffer );
+ //}
}
}
@@ -393,11 +387,11 @@ void CAT(SD_info *sd, const char *filename) {
// Fonction pour copier un fichier existant du système de fichier
-void CP(SD_info *sd, const char *source_filename, const char *destination_filename) {
- unsigned char source_filenameBuffer[MAX_FILENAME_LENGTH];
- unsigned char destination_filenameBuffer[MAX_FILENAME_LENGTH];
- unsigned char descriptionBuffer[CHUNK_SIZE];
- unsigned char numBuffer[2];
+void CP(SD_info *sd, char *source_filename, char *destination_filename) {
+ char source_filenameBuffer[MAX_FILENAME_LENGTH];
+ char destination_filenameBuffer[MAX_FILENAME_LENGTH];
+ char descriptionBuffer[CHUNK_SIZE];
+ char numBuffer[64];
int destination_offset;
int source_offset;
int offset;
@@ -406,24 +400,24 @@ void CP(SD_info *sd, const char *source_filename, const char *destination_filena
// Recherche du fichier source
source_offset = -1;
- for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
+ for (int blockNum = 0; blockNum < MAX_BLOCKS_IN_SUPERBLOCK; blockNum += 16) {
readBlock(sd,blockNum, 0, source_filenameBuffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc contient le nom du fichier source
- if (strncmp((const char *)source_filenameBuffer, source_filename, MAX_FILENAME_LENGTH) == 0) {
+ if (strncmp(source_filenameBuffer, source_filename, MAX_FILENAME_LENGTH) == 0) {
source_offset = blockNum;
break;
}
}
if (source_offset == -1) {
- printf("Le fichier source \"%s\" n'a pas été trouvé.\n", source_filename);
+ printf("\nLe fichier source \"%s\" n'a pas été trouvé.\n", source_filename);
return;
}
// Recherche d'un emplacement libre pour le fichier destination
destination_offset = -1;
- for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
+ for (int blockNum = 0; blockNum < MAX_BLOCKS_IN_SUPERBLOCK; blockNum += 16) {
readBlock(sd,blockNum, 0, destination_filenameBuffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
@@ -434,12 +428,12 @@ void CP(SD_info *sd, const char *source_filename, const char *destination_filena
}
if (destination_offset == -1) {
- printf("Plus de place dans le système de fichier pour créer la copie de \"%s\".\n", source_filename);
+ printf("\nPlus de place dans le système de fichier pour créer la copie de \"%s\".\n", source_filename);
return;
}
// Copie du nom de la copie dans le bloc de description
- writeBlock(sd,destination_offset, 0, (const unsigned char *)destination_filename, strlen(destination_filename));
+ writeBlock(sd,destination_offset, 0, destination_filename, strlen(destination_filename));
// Copier les blocs de données associés au fichier source dans de nouveaux blocs de données pour le fichier destination
for (int i = 0; i < MAX_BLOCKS_PER_FILE_DESCRIPTION; i++) {
@@ -453,7 +447,7 @@ void CP(SD_info *sd, const char *source_filename, const char *destination_filena
numDataBlock = reconsituteNumber(numBuffer);
if (numDataBlock == 0) {
- printf("La copie de \"%s\" sous le nom \"%s\" a été créée avec succès.\n", source_filename, destination_filename);
+ printf("\nLa copie de \"%s\" sous le nom \"%s\" a été créée avec succès.\n", source_filename, destination_filename);
return;
}
@@ -495,15 +489,20 @@ int main(int argc, char *argv[]) {
printf("erreur=%x\n",sd.errorCode_);
printf("type=%x\n",sd.type_);
uint32_t size=cardSize(&sd);
- printf("taille=%ld\n",size);
+ printf("taille=%ld\n\n",size);
- //char current_cmd[CMD_SIZE + 1]; // +1 pour le caractère nul
+ printf("Pico ordinateur OK\n\n");
+ // char current_cmd[CMD_SIZE + 1]; // +1 pour le caractère nul
erase(&sd, 0, 15000);
current_cmd[0] = '\0'; // Initialise la chaîne vide
+ printf("PicoOrdi>");
while (1) {
+
_delay_ms(10);
+
user_data = get_serial();
+
if (user_data == '\b'){
current_cmd[strlen(current_cmd) - 1] = '\0'; // retirer le dernier charactère de la chaine actuelle
printf("%c", user_data);
@@ -514,7 +513,8 @@ int main(int argc, char *argv[]) {
strncat(current_cmd, &user_data, 1); // Ajoute le caractère à la fin de la chaîne
if (user_data == '\r') {
- char delim = ' '; //espace délimite les arguments
+
+ char delim = ' '; // espace délimite les arguments
current_cmd[strlen(current_cmd) - 1] = '\0'; // Retire le retour à la ligne
if (strncmp(current_cmd, "LS", 2) == 0) { // Compare les deux premiers caractères
LS(&sd); //lister les fichiers
@@ -526,31 +526,51 @@ int main(int argc, char *argv[]) {
strcpy(filenameRm, tokenRm);
RM(&sd, filenameRm); // efface le fichier
- } else if (strncmp(current_cmd, "TYPE", 2) == 0){
+ } else if (strncmp(current_cmd, "TYPE", 4) == 0){
char filenameType[MAX_FILENAME_LENGTH];
- char delimType = ' ';
+
+ char dataType[CHUNK_SIZE];
char * tokenType = strtok(current_cmd, &delim);
tokenType = strtok(NULL, &delim);
strcpy(filenameType, tokenType);
- TYPE(&sd, filenameType); //crée le fichier
+ tokenType = strtok(NULL, &delim);
+ strcpy(dataType, tokenType);
+ TYPE(&sd, filenameType,dataType); //crée le fichier
} else if (strncmp(current_cmd, "MV", 2) == 0){
char filename_old[MAX_FILENAME_LENGTH];
char filename_new[MAX_FILENAME_LENGTH];
- char delim = ' ';
+
char * tokenMv = strtok(current_cmd, &delim);
tokenMv = strtok(NULL, &delim); //prend ancien nom
strcpy(filename_old, tokenMv);
tokenMv = strtok(NULL, &delim); //prend nouveau nom
strcpy(filename_new, tokenMv);
MV(&sd,filename_old, filename_new); // renommer le fichier
- }
+ } else if (strncmp(current_cmd, "CAT", 3) == 0){
+ char filenameCat[MAX_FILENAME_LENGTH];
+ char * tokenCat = strtok(current_cmd, &delim);
+ tokenCat = strtok(NULL, &delim); //prend nouveau nom
+ strcpy(filenameCat, tokenCat);
+ CAT(&sd,filenameCat); //afficher le fichier
+
+ } else if (strncmp(current_cmd, "CP", 2) == 0){
+ char filename_origin[MAX_FILENAME_LENGTH];
+ char filename_copy[MAX_FILENAME_LENGTH];
+
+ char * tokenCp = strtok(current_cmd, &delim);
+ tokenCp = strtok(NULL, &delim); //prend ancien nom
+ strcpy(filename_origin, tokenCp);
+ tokenCp = strtok(NULL, &delim); //prend nouveau nom
+ strcpy(filename_copy, tokenCp);
+ CP(&sd,filename_origin, filename_copy); // copier le fichier
+ }
else
{
- printf("La commande entree %s, n'a pas été reconnue\n", current_cmd);
+ printf("\nLa commande entree %s, n'a pas été reconnue\n", current_cmd);
}
-
+ printf("\nPicoOrdi>");
current_cmd[0] = '\0'; // Réinitialise la chaîne
}
}
--
GitLab