Formatteur de code en c++

Commenter

Contenu du snippet

Ce code sert à formatter selon mon goût les codes sources. Il possède un interface dos nul, vraiement nul. Vous devez tapez le nom du fichier ainsi que le path qui y mène (par exemple c:\temp\divers\trucs\download\sources\MonSources.cpp et pour toutes eurreur il plante, try again. C'est pas fort mais je l'ai fait rapido lorsque j'ai eu à modifier des fichiers sources qui avait été programmé... un peu tout croche.

Source / Exemple : 


// Format.cpp : Defines the entry point for the console application.
//

#include <stdio.h>
#include <conio.h>
#include <fstream.h>
#include <string.h>
#include <fcntl.h>
#include <io.h>

#define C_est_Un_Caractere (clut >= 65 && clut <= 89 ) || (clut >= 97 && clut <= 122 )
#define C_est_Un_Nombre (clut >= 48 && clut <= 57 )

//mon tableau est statique vous voyez donc que l'on ne peut pas ouvrir de fichier qui ont plus de
//20000 lignes et il coupera les lignes qui ont plus de 150 caractères
char FileDump[20000][150];
char TCommentaireMultiple[20000];
	

int LireNomFichier(char NomFichier[],int pSize);
void Decaler(int Ligne,int DerniereLigne);
void Supprimer(int Linge, int DerniereLigne);

void main(int argc, char* argv[])
{
	char NomFichier[200];
	FILE* FichierAFormater;
	char ChaineTemp[150];
	int compteur =0;
	bool CommentaireMultiple = false;
	int i =0;
	int j =0;
	int NbTab;
	char ChaineTabs[100];
	bool Skip = false;

   LireNomFichier(NomFichier,200);
	FichierAFormater = fopen(NomFichier,"rb+");
	
	while(fgets(FileDump[compteur++],150,FichierAFormater) != NULL && compteur < 20000);
	if(compteur == 20000)
	{
		printf("fuck!!");
	}

	//on retourne au début
	fclose(FichierAFormater);
	FichierAFormater = fopen(NomFichier,"wb");	

	for(i =0;i<=compteur;i++)
	{
		TCommentaireMultiple[i] =0;

		for(j=0;j<150;j++)
		{
			if(CommentaireMultiple)
			{
				//le commentaire multiple les /* */ sont un peu bogué mais ils marhcent en gros
				//et je n'ai pas vraiement le temps de gosser avec ça
				if(FileDump[i][j] == 42 && FileDump[i][j+1] == 47)
				{
					CommentaireMultiple = false;
				}
				else if(FileDump[i][j] == '\n')
				{
					TCommentaireMultiple[i] =1;
					break;
				}
			}
			//ici on traite les tab et les espaces en début de ligne pour tous les enlever
			else if((FileDump[i][j] == ' ' || FileDump[i][j] == 9) && j == 0)
			{
				for(j=0;j<150;j++)
				{
					FileDump[i][j] = FileDump[i][j+1];
					//un break pour pas copié du vide... légère optimisation
					if(FileDump[i][j] == '\n')
					{
						FileDump[i][j+1] = '\0';
						break;
					}
				}
				//pour repasser le j =0
				j=-1;
			}
			//ici on skip les commentaires
			else if(FileDump[i][j] == 47 && FileDump[i][j+1] == 47)
			{
				//avec un commentaire comme celui que vous lisez toute la ligne restante est 
				//forcément des commentaires
				break;
			}//dans le cas de des acolades
			else if((FileDump[i][j] == 123 || FileDump[i][j] == 125) && j > 0)
			{
				//ici c'est assez drôle ce que l'on fait
				//on copie la chaine a partir de où nous sommes
				strcpy(ChaineTemp,&FileDump[i][j]);
				//on coupe la chaine originale
				FileDump[i][j] = '\n';
				FileDump[i][j+1] = '\0';
				//on décale toutes les lignes de 1 ET on change de ligne
				Decaler(++i,++compteur);
				//on recopie à la ligne suivante
				strcpy(FileDump[i],ChaineTemp);
				//on réinitialise la boucle,
				j=-1;
			}
			else if((FileDump[i][j] == 123 || FileDump[i][j] == 125) && j == 0 && (FileDump[i][j+1] != '\n'))
			{
				//on copie la chaine a partir de où nous sommes + 1 (la case après l'accolade)
				strcpy(ChaineTemp,&FileDump[i][j+1]);
				//on coupe la chaine originale
				FileDump[i][j+1] = '\n';
				FileDump[i][j+2] = '\0';
				//on décale toutes les lignes de 1 ET on change de ligne
				Decaler(++i,++compteur);
				//on recopie à la ligne suivante
				strcpy(FileDump[i],ChaineTemp);
				//on réinitialise la boucle,
				j=-1;
			}
			else if(FileDump[i][j] == 47 && FileDump[i][j+1] == 42)
			{
				//on saute l'astérisque
				j++;
				CommentaireMultiple = true;
			}//on break dans les cas ou on arrive a la fin de ligne, et aussi les #
			else if(FileDump[i][j] == '\n' || FileDump[i][j] == '#')
			{
				break;
			}
		}
	}
	sprintf(ChaineTabs,"\0");
	NbTab =0;
			
	for(i=0;i<=compteur;i++)
	{
		//on saut les lignes ayant un # comme premier caractère
		if(FileDump[i][0] != 35 && TCommentaireMultiple[i] == 0)
		{
			if(FileDump[i][0] == 123 )
			{
				Skip = true;
			}
			else if(FileDump[i][0] == 125)
			{
				NbTab--;
			}
			if(NbTab > 0)
			{	
				sprintf(ChaineTabs,"\t\0");
				for(j=0;j<NbTab;j++)
				{
					sprintf(ChaineTabs,"%s\t\0",ChaineTabs);
				}
		
				strcpy(ChaineTemp,ChaineTabs);
				strcat(ChaineTemp,FileDump[i]);
				strcpy(FileDump[i],ChaineTemp);		
			}
			if(Skip)
			{
				NbTab++;
				Skip = false;
			}
		}
	}
	//on supprime les lignes vides et les espaces en fin de lignes
	//on parcourt le tout à l'envers
	for(i =compteur;i>=0;i--)
	{
		for(j=0;j<150;j++) if(FileDump[i][j] == '\n') break;
		
		while(j>0)
		{
			j--;
			if(FileDump[i][j] == 32 || FileDump[i][j] == '\t')
			{
				FileDump[i][j] = '\n';
				FileDump[i][j+1] = '\0';
			}
			else break;
		}
		if(FileDump[i][0] == '\n')
		{
			Supprimer(i,compteur--);
		}

	}
	
	for(i=0;i<=compteur;i++)
	{
		fprintf(FichierAFormater,"%s",FileDump[i]);
	}
	fprintf(FichierAFormater,"\n/***************************************************************\n");
	fprintf(FichierAFormater,"//Fichier Formater avec Format 1.0 Rémi Morin septembre 2001 \n");
	fprintf(FichierAFormater,"//version pour C/C++ \n");
	fprintf(FichierAFormater,"****************************************************************/");
	fclose(FichierAFormater);

	return;
	
}
/****************************************************************************************
//int LireNomFichier(char NomFichier[],int pSize)
//
//Cette fonction sert simplement à saisir un nom de ficher et le path qui s'y rattache
//j'ai eu un élan de pitié et je me suis dit que pour un programme qui devait formatter
//du code je devais au moins le diviser en fonction


                                                                                                                                                                                • /

int LireNomFichier(char NomFichier[],int pSize)
{
	char clut = 0;
	int compteur = 0;
	bool Dot = false;

	printf("Entrez le nom du fichier et son chemin d'accès\n");
		
	while(clut != 13 && compteur < pSize-1)
	{
		clut = _getch();
		if(C_est_Un_Caractere || (C_est_Un_Nombre && compteur > 0) || clut == 58 || clut == 92)
		{
			NomFichier[compteur++] = clut;
			_putch(clut);
		}
		else if(clut == 8)
		{
			if(NomFichier[compteur] == 46)
			{
				Dot = false;
			}
			//recule d'un caratère, met un blank space puis revient
			_putch(8);
			_putch(32);
			_putch(8);
			compteur--;
		}
		else if(clut == 13 && compteur > 0)
		{
			NomFichier[compteur++] = '\0';
		}
		else if(clut == 46 && !Dot)
		{
			NomFichier[compteur++] = clut;
			_putch(clut);
			Dot = true;
		}
	}
	printf("\n%s\n",NomFichier);
	return 0;
}

/****************************************************************************************
//void Decaler(int Ligne,int DerniereLigne)
//
//Cette fonction Crée une ligne blanche elle décale les autres lignes et permet ainsi 
//l'insertion d'une ligne


                                                                                                                                                                                • /

void Decaler(int Ligne,int DerniereLigne)
{
	int i=0;
	//on boucle à l'envers
	for(i=DerniereLigne;i>=Ligne;i--)
	{
		strcpy(FileDump[i+1],FileDump[i]);
	}
}
/****************************************************************************************
//void Supprimer(int Ligne, int DerniereLigne)
//
//Cette fonction fait l'inverse de la précédente elle écrase une ligne et remonte le 
//reste
//


                                                                                                                                                                                • /

void Supprimer(int Ligne, int DerniereLigne)
{
	int i = 0;
	for(i = Ligne+1;i<=DerniereLigne;i++)
	{
		strcpy(FileDump[i-1],FileDump[i]);
	}
}

Conclusion :


bug connu, je crois qu'il ne traite pas tout a fait correctement les commentaires multiples /* blabla */ mais il fait quand même une pas pire job

Notez que la façon dont vous allignez vos affaire vous regarde personnellement j'ai mes standarts et je les aimes comme ça. Si vous voulez le modifier donnez vous en à coeur joie. Ce n'est pas un chef d'oeuvre comme programme mais il fait la job et compte tenu que j'en avais besoin pis qu'après que j'en ai eu fini j'y est presque pas touché je ne l'ai pas vraiement améliorer.
Malgré tout il peut donner des idées (du moins j'imagine) ou un point de départ à qui voudrait en faire un plus exaustif

Note: Il a effectivement été compilé avec visual C++... (C'est l'environnement que j'aie au travail) mais je crois que conio.h est disponible pour c++ builder de borland.

A voir également

S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.

Du même auteur (MeltedMind)