1. Accueil
  2. C / C++ / C++.NET
  3. Sources C / C++ / C++.NET
  4. Sources Application
  5. Coloration syntaxique d'un fichier source en c/c++ (dev-c++)

Coloration syntaxique d'un fichier source en c/c++ (dev-c++)

Soyez le premier à donner votre avis sur cette source.

Vue 4 795 fois - Téléchargée 209 fois

Télécharger le projet
Commenter

Description

Il prend un fichier source en c/c++ et crée un fichier html.
Ce fichier aura pour titre le fichier mis en entrée.

C'est assez bourrin comme méthode, il manque quelques mots clés du langage...
Vous pouvez changer les couleurs en traficotant dans le code...
Sinon ca a juste le but de montrer un exemple de "comment faire", ca pourrait être beaucoup plus modulaire, efficace, optimisé, mais ça a le mérite de marcher sur mes sources ;)

Sinon j'espère que la source ressort bien :)

(surtout avec les balises dedans, je sais pas si ca le fait)
Sinon, récupérez le zip:il y a la source.

Source / Exemple : 


#include <stdio.h>
#include <stdlib.h>

#define COLPREPROC	"#0000FF"	// couleur pour les préprocesseur
#define COLRESERVED	"#4444FF"   // couleur pour les mots clés
#define COLSTRING	"#FF0000"   // "       pour les chaînes
#define COLCHAR		"#888800"   // "                caractères
#define COLNUMBER	"#FF00FF"   //                  nombres
#define COLOTHNUM	"#800080"   //							octaux et hexadécimaux
#define COLCOMM		"#008000"	//					commentaires

//teste si le caractère est un séparateur entre deux mots
inline bool BLANC(char s)
{
	return (s==':' || 
 			s==' ' || 
    		s=='\t'||
   		 	s=='\n'||
       		s=='(' ||
         	s==')' ||
            s=='{' || 
            s=='}' || 
            s=='*' || 
            s==',' || 
            s=='[' || 
            s==']' || 
            s==';' || 
            s=='+' || 
            s=='-' || 
            s=='|' || 
            s=='/' || 
            s=='&' || 
            s=='=' ||
            s=='<' ||
            s=='>' ||
            s=='%');
}

// Cherche la longueur du fichier mis en paramètre (il y a surement plus simple...)
long long CaptFileSize (char* fichier)
{
	unsigned char* machin=(unsigned char*) malloc (100000);
	FILE *f=fopen (fichier,"rb");
	if (!f) return 0;
	long long val=fread (machin,sizeof (unsigned char),100000,f);
	long long c=val;
	while (val==100000)
	{
		val=fread (machin,sizeof (unsigned char),100000,f);
		c+=val;
	}
	fclose (f);
	return c;
}

// Pour écrire un caractère, pour qu'il soit lisible en html...
void WriteChar (char* buf,int* p,FILE* fs)
{
	switch (buf[*p])
	{
		case '\r':// il y en a tjs un avant les \n ==> on s'en fout
			break;
		case '\n':// on passe à la ligne
			fprintf (fs,"\n");
			break;
		case '<':// on code en hexa ce caractère pour qu'il ne le reconnaisse pas comme début de balise
			fprintf (fs,"&#60;");
			break;
		case '>':
			fprintf (fs,"&#62;");
			break;
		case '\\':// si c'est un échappement on écrit le caractère et le suivant 
			fprintf (fs,"%c%c",buf[*p],buf[*p+1]);*p+=1;
			break;
		default:// sinon on écrit simplement le caractère
			fprintf (fs,"%c",buf[*p]);
			break;
	}
}			

//routine principale
void Trans (FILE* fl,FILE* fs,int nb)
{
	// on fout tout le fichier à lire dans un buffer:
	printf ("%d",nb);
	char* buffer=(char*)malloc(nb);
	fseek (fl,0,SEEK_SET);
	fread (buffer,nb,1,fl);
	//on a tout le fichier dans le buffer : on le parse
	signed int p=0;
	bool macr=false;
	bool entr=false;
	bool doe=true;
	int i=0;

	for (p=0;p<nb;p++)
	{
		switch (buffer[p])
		{
			case '#'://si c'est un # ==>début d'un préproc
				fprintf (fs,"<font color=%s>%c",COLPREPROC,'#');
				while (!BLANC(buffer[p]))
				{
					p++;
					WriteChar (buffer,&p,fs);
				}
				fprintf (fs,"</font>");
				break;
			case '/'://c'est ptet un commentaire...
    			p++;
				if (buffer[p]=='/')// si le caractère suivant est / : commentaire sur une ligne
				{
    				fprintf (fs,"<font color=%s>//",COLCOMM);
    				entr=true;
					while (entr)
					{
						p++;
						WriteChar(buffer,&p,fs);
						if (buffer[p]=='\n')
						entr=false;
					}
					fprintf (fs,"</font>");				
				}
				else if (buffer[p]=='*')// si * commentaire jusqu'à */
				{
    				fprintf (fs,"<font color=%s>/*",COLCOMM);
    				entr=true;
					while (entr)
					{
						p++;
						WriteChar(buffer,&p,fs);
						if (buffer[p-1]=='*' && buffer[p]=='/')
						{
      						entr=false;
						}
					}
					fprintf (fs,"</font>");				
				}	
				else// sinon c'est rien
				{
					fprintf(fs,"/");
					p--;
				}
				break;
				
			case '\"'://guillemets:début d'une chaîne
				fprintf (fs,"<font color=%s>%c",COLSTRING,'\"');
				p++;
    			while(buffer[p]!='\"' && buffer[p]!='\n')
				{
					WriteChar(buffer,&p,fs);
					p++;
				}
				WriteChar(buffer,&p,fs);
				fprintf(fs,"</font>");
				break;
				case '<'://début d'une chaîne ssi il y a un préproc avant
				while (buffer[p-i]!='#' && doe)
				{
					if (buffer[p-i]=='\n') doe=false;
					i++;
				}

				if (doe)
				{
					fprintf (fs,"<font color=%s>",COLSTRING);
					WriteChar(buffer,&p,fs);
					p++;
	    			while(buffer[p]!='>' && buffer[p]!='\n')
					{
						WriteChar(buffer,&p,fs);
						p++;
					}
					WriteChar(buffer,&p,fs);
					fprintf(fs,"</font>");
				}
				else
					WriteChar(buffer,&p,fs);
    			break;

			case '\'':// début de caractère
				fprintf (fs,"<font color=%s>%c",COLCHAR,'\'');
				p++;
    			while(buffer[p]!='\'')
				{
					WriteChar(buffer,&p,fs);
					p++;
				}
				fprintf(fs,"\'</font>");
				break;
			case 'b'://j'aurais dû faire une fonction auxiliaire pour ca...
				if (BLANC(buffer[p-1]) && buffer[p+1]=='o' && buffer[p+2]=='o' && buffer[p+3]=='l' && BLANC(buffer[p+4]))//bool	
       			{
          			fprintf (fs,"<font color=%s>bool</font>",COLRESERVED);
             		p+=3;
                }
                else
  				if (BLANC(buffer[p-1]) && buffer[p+1]=='r' && buffer[p+2]=='e' && buffer[p+3]=='a' && buffer[p+4]=='k' && BLANC(buffer[p+5]))//break	
       			{
          			fprintf (fs,"<font color=%s>break</font>",COLRESERVED);
             		p+=4;
                }
                else
                	WriteChar(buffer,&p,fs);
                break;			
			case 'c':
				if (BLANC(buffer[p-1]) && buffer[p+1]=='h' && buffer[p+2]=='a' && buffer[p+3]=='r' && BLANC(buffer[p+4]))//char	
       			{
          			fprintf (fs,"<font color=%s>char</font>",COLRESERVED);
             		p+=3;
                }
                else
				if (BLANC(buffer[p-1]) && buffer[p+1]=='a' && buffer[p+2]=='s' && buffer[p+3]=='e' && BLANC(buffer[p+4]))//case	
       			{
          			fprintf (fs,"<font color=%s>case</font>",COLRESERVED);
             		p+=3;
                }
                else
   				if (BLANC(buffer[p-1]) && buffer[p+1]=='o' && buffer[p+2]=='n' && buffer[p+3]=='t' && buffer[p+4]=='i' && buffer[p+5]=='n' && buffer[p+6]=='u' && buffer[p+7]=='e' && BLANC(buffer[p+8]))//continue	
       			{
          			fprintf (fs,"<font color=%s>continue</font>",COLRESERVED);
             		p+=7;
                }
                else
  				if (BLANC(buffer[p-1]) && buffer[p+1]=='l' && buffer[p+2]=='a' && buffer[p+3]=='s' && buffer[p+4]=='s' && BLANC(buffer[p+5]))//class	
       			{
          			fprintf (fs,"<font color=%s>class</font>",COLRESERVED);
             		p+=4;
                }
                else
  				if (BLANC(buffer[p-1]) && buffer[p+1]=='o' && buffer[p+2]=='n' && buffer[p+3]=='s' && buffer[p+4]=='t' && BLANC(buffer[p+5]))//const	
       			{
          			fprintf (fs,"<font color=%s>const</font>",COLRESERVED);
             		p+=4;
                }
                else

                	WriteChar(buffer,&p,fs);
                break;				
         	case 'd':
  				if (BLANC(buffer[p-1]) && buffer[p+1]=='e' && buffer[p+2]=='f' && buffer[p+3]=='a' && buffer[p+4]=='u' && buffer[p+5]=='l' && buffer[p+6]=='t' && BLANC(buffer[p+7]))//default	
       			{
          			fprintf (fs,"<font color=%s>default</font>",COLRESERVED);
             		p+=6;
                }
                else
   				if (BLANC(buffer[p-1]) && buffer[p+1]=='O' && BLANC(buffer[p+2]))//do	
       			{
          			fprintf (fs,"<font color=%s>do</font>",COLRESERVED);
             		p+=1;
                }
                else
   				if (BLANC(buffer[p-1]) && buffer[p+1]=='o' && buffer[p+2]=='u' && buffer[p+3]=='b' && buffer[p+4]=='l' && buffer[p+5]=='e' && BLANC(buffer[p+6]))//double
       			{
          			fprintf (fs,"<font color=%s>double</font>",COLRESERVED);
             		p+=5;
                }
                else
                	WriteChar(buffer,&p,fs);
               	break;
         	case 'e':
				if (BLANC(buffer[p-1]) && buffer[p+1]=='l' && buffer[p+2]=='s' && buffer[p+3]=='e' && BLANC(buffer[p+4]))//else	
       			{
          			fprintf (fs,"<font color=%s>else</font>",COLRESERVED);
             		p+=3;
                }
                else
				if (BLANC(buffer[p-1]) && buffer[p+1]=='n' && buffer[p+2]=='u' && buffer[p+3]=='m' && BLANC(buffer[p+4]))//enum	
       			{
          			fprintf (fs,"<font color=%s>enum</font>",COLRESERVED);
             		p+=3;
                }
                else
   				if (BLANC(buffer[p-1]) && buffer[p+1]=='x' && buffer[p+2]=='t' && buffer[p+3]=='e' && buffer[p+4]=='r' && buffer[p+5]=='n' && BLANC(buffer[p+6]))//extern
       			{
          			fprintf (fs,"<font color=%s>extern</font>",COLRESERVED);
             		p+=5;
                }
                else

                	WriteChar(buffer,&p,fs);
               	break;
 			case 'f':
   				if (BLANC(buffer[p-1]) && buffer[p+1]=='o' && buffer[p+2]=='r' && BLANC(buffer[p+3]))//for	
       			{
          			fprintf (fs,"<font color=%s>for</font>",COLRESERVED);
             		p+=2;
                }
                else
  				if (BLANC(buffer[p-1]) && buffer[p+1]=='l' && buffer[p+2]=='o' && buffer[p+3]=='a' && buffer[p+4]=='t' && BLANC(buffer[p+5]))//float	
       			{
          			fprintf (fs,"<font color=%s>float</font>",COLRESERVED);
             		p+=4;
                }
                else
                	WriteChar(buffer,&p,fs);
                break;			
				
			case 'i':
   				if (BLANC(buffer[p-1]) && buffer[p+1]=='n' && buffer[p+2]=='t' && BLANC(buffer[p+3]))//int	
       			{
          			fprintf (fs,"<font color=%s>int</font>",COLRESERVED);
             		p+=2;
                }
                else
  				if (BLANC(buffer[p-1]) && buffer[p+1]=='n' && buffer[p+2]=='l' && buffer[p+3]=='i' && buffer[p+4]=='n' && buffer[p+5]=='e' && BLANC(buffer[p+6]))//inline
       			{
          			fprintf (fs,"<font color=%s>inline</font>",COLRESERVED);
             		p+=5;
                }
                else
                if (BLANC(buffer[p-1]) && buffer[p+1]=='f' && BLANC(buffer[p+2]))//if	
       			{
          			fprintf (fs,"<font color=%s>if</font>",COLRESERVED);
             		p+=1;
                }
                else
 
                	WriteChar(buffer,&p,fs);
                break;
            case 'l':
				if (BLANC(buffer[p-1]) && buffer[p+1]=='o' && buffer[p+2]=='n' && buffer[p+3]=='g' && BLANC(buffer[p+4]))//long	
       			{
          			fprintf (fs,"<font color=%s>long</font>",COLRESERVED);
             		p+=3;
                }
                else
                	WriteChar(buffer,&p,fs);
               	break;
         	case 'r':
  				if (BLANC(buffer[p-1]) && buffer[p+1]=='e' && buffer[p+2]=='t' && buffer[p+3]=='u' && buffer[p+4]=='r' && buffer[p+5]=='n' && BLANC(buffer[p+6]))//return	
       			{
          			fprintf (fs,"<font color=%s>return</font>",COLRESERVED);
             		p+=5;
                }
                else
   				if (BLANC(buffer[p-1]) && buffer[p+1]=='e' && buffer[p+2]=='g' && buffer[p+3]=='i' && buffer[p+4]=='s' && buffer[p+5]=='t' && buffer[p+6]=='e' && buffer[p+7]=='r' && BLANC(buffer[p+8]))//register	
       			{
          			fprintf (fs,"<font color=%s>register</font>",COLRESERVED);
             		p+=7;
                }
                else
 
                	WriteChar(buffer,&p,fs);
               	break;
 				
            case 's':
  				if (BLANC(buffer[p-1]) && buffer[p+1]=='i' && buffer[p+2]=='g' && buffer[p+3]=='n' && buffer[p+4]=='e' && buffer[p+5]=='d' && BLANC(buffer[p+6]))//signed	
       			{
          			fprintf (fs,"<font color=%s>signed</font>",COLRESERVED);
             		p+=5;
                }
                else
  				if (BLANC(buffer[p-1]) && buffer[p+1]=='w' && buffer[p+2]=='i' && buffer[p+3]=='t' && buffer[p+4]=='c' && buffer[p+5]=='h' && BLANC(buffer[p+6]))//switch	
       			{
          			fprintf (fs,"<font color=%s>switch</font>",COLRESERVED);
             		p+=5;
                }
                else
 				if (BLANC(buffer[p-1]) && buffer[p+1]=='i' && buffer[p+2]=='z' && buffer[p+3]=='e' && buffer[p+4]=='o' && buffer[p+5]=='f' && BLANC(buffer[p+6]))//sizeof	
       			{
          			fprintf (fs,"<font color=%s>sizeof</font>",COLRESERVED);
             		p+=5;
                }
                else
 				if (BLANC(buffer[p-1]) && buffer[p+1]=='t' && buffer[p+2]=='a' && buffer[p+3]=='t' && buffer[p+4]=='i' && buffer[p+5]=='c' && BLANC(buffer[p+6]))//static	
       			{
          			fprintf (fs,"<font color=%s>static</font>",COLRESERVED);
             		p+=5;
                }
                else
 				if (BLANC(buffer[p-1]) && buffer[p+1]=='t' && buffer[p+2]=='r' && buffer[p+3]=='u' && buffer[p+4]=='c' && buffer[p+5]=='t' && BLANC(buffer[p+6]))//struct	
       			{
          			fprintf (fs,"<font color=%s>struct</font>",COLRESERVED);
             		p+=5;
                }
                else
 
                	WriteChar(buffer,&p,fs);
               	break;
	        case 't':
  				if (BLANC(buffer[p-1]) && buffer[p+1]=='y' && buffer[p+2]=='p' && buffer[p+3]=='e' && buffer[p+4]=='d' && buffer[p+5]=='e' && buffer[p+6]=='f' && BLANC(buffer[p+7]))//typedef	
       			{
          			fprintf (fs,"<font color=%s>typedef</font>",COLRESERVED);
             		p+=6;
                }
                else
                	WriteChar(buffer,&p,fs);
               	break;
         	case 'u':
  				if (BLANC(buffer[p-1]) && buffer[p+1]=='n' && buffer[p+2]=='s' && buffer[p+3]=='i' && buffer[p+4]=='g' && buffer[p+5]=='n' && buffer[p+6]=='e' && buffer[p+7]=='d' && BLANC(buffer[p+8]))//unsigned	
       			{
          			fprintf (fs,"<font color=%s>unsigned</font>",COLRESERVED);
             		p+=7;
                }
                else
    			if (BLANC(buffer[p-1]) && buffer[p+1]=='n' && buffer[p+2]=='i' && buffer[p+3]=='o' && buffer[p+4]=='n' && BLANC(buffer[p+5]))//union	
       			{
          			fprintf (fs,"<font color=%s>union</font>",COLRESERVED);
             		p+=4;
                }
                else
                   	WriteChar(buffer,&p,fs);
               	break;
            case 'v':
				if (BLANC(buffer[p-1]) && buffer[p+1]=='o' && buffer[p+2]=='i' && buffer[p+3]=='d' && BLANC(buffer[p+4]))//void	
       			{
          			fprintf (fs,"<font color=%s>void</font>",COLRESERVED);
             		p+=3;
                }
                else
                	WriteChar(buffer,&p,fs);
               	break;               	
         	case 'w':
  				if (BLANC(buffer[p-1]) && buffer[p+1]=='h' && buffer[p+2]=='i' && buffer[p+3]=='l' && buffer[p+4]=='e' && BLANC(buffer[p+5]))//while	
       			{
          			fprintf (fs,"<font color=%s>while</font>",COLRESERVED);
             		p+=4;
                }
                else
                	WriteChar(buffer,&p,fs);
                break;			
        	case '1':
        	case '2':// les chiffres : plus compliqué
        	case '3':
        	case '4':
        	case '5':
        	case '6':
        	case '7':
        	case '8':
        	case '9':
        	case '0':
        		// si c'est pas héxa ou octal (c'est du float ou integer)
        		if (buffer[p]!='0' || buffer[p+1]=='.' || buffer[p+1]=='e' || buffer[p+1]=='E' || BLANC(buffer[p+1]))
        		{
	        		if (BLANC(buffer[p-1]))
	        		{
						fprintf (fs,"<font color=%s>",COLNUMBER);
	        			while ((buffer[p]>='0' && buffer[p]<='9') || buffer[p]=='.' || buffer[p]=='e' || buffer[p]=='E')
	        			{
	        				WriteChar (buffer,&p,fs);
	            			p++;
	       				}//on va jusqu'à la fin du nombre
	       				p--;
			       		fprintf(fs,"</font>");
	           		}
          		}
     			else//idem pour les héxa ou octal
 				if (BLANC(buffer[p-1]) && buffer[p]=='0' && ((buffer[p+1]>='0' && buffer[p+1]<='9') || buffer[p+1]=='x' || buffer[p+1]=='X'))
        		{
					fprintf (fs,"<font color=%s>",COLOTHNUM);
        			while ((buffer[p]>='0' && buffer[p]<='9') || buffer[p]=='x' || buffer[p]=='X' || (buffer[p]>='A' && buffer[p]<='F') || (buffer[p]>='a' && buffer[p]<='f'))
        			{
        				WriteChar (buffer,&p,fs);
            			p++;
       				}
       				p--;
		       		fprintf(fs,"</font>");
           		}
    			else//sinon on écrit le chiffre normalement     					
        			WriteChar (buffer,&p,fs);	
        	break;
        	
 			default://c'est rien on l'écrit normalement
				WriteChar(buffer,&p,fs);
    			break;
        }				
	}					
					
}

//point d'entrée
int main(int argc, char *argv[])
{
	char fich[200];//je ne pense pas que des commentaires soient nécessaires ici ;)
 	char fichhtml[200];	
    printf("Fichier d'entrée:");scanf ("%s",fich);
    printf("fichier de sortie:");scanf ("%s",fichhtml);
    fich[strlen(fich)]=0;
    fichhtml[strlen(fichhtml)]=0;
    FILE *fl=fopen(fich,"rb");
    FILE *fs=fopen(fichhtml,"w");
    fprintf (fs,"<html>\n"
    			"<head>\n"
    			"<title>%s</title>\n"
    			"</head>\n"
       			"<body bgcolor=""FFFFFF"" text=""000000"">\n<pre><code>",fich);
    
    Trans (fl,fs,CaptFileSize (fich));    			

    fprintf (fs,"</pre>
</body>\n</html>");
system("PAUSE");
return 0;
}
</code>

Conclusion :


Je ne trouve pas ca très compliqué, c'est pour ça que je l'ai mise en débutant...
Si vous trouvez cette source compliquée, dites le moi je monterai son niveau (si c'est possible bien sûr) :)
Et je ne sais pas quelle catégorie mettre pour ce truc...
Télécharger le projet

Codes Sources

A voir également

Ajouter un commentaire

Commentaires

Signaler
Cyberboy2054
Messages postés
173
Date d'inscription
jeudi 20 décembre 2001
Statut
Membre
Dernière intervention
22 août 2008
Tu devrais utiliser un fichier css pour permettre a celui qui convertit de pouvoir modifier les couleurs ... sinon c est sympa comme source :)
Signaler
magic_Nono
Messages postés
1878
Date d'inscription
jeudi 16 octobre 2003
Statut
Membre
Dernière intervention
16 mars 2011
 1
parfaitement, d'accord,

Bien bourain mais ça marche...

L'idée est bonne,

à propos, qqn aurait la capacité (et le tps) de développer ce trucs pour d'autres formats?
je pense principalement à chm, Word et LaTeX.
C a priori simple à faire (sauf pr word, a paremment) mais juste 1 peu lg...

Magicalement, Bonne Prog...
Nono.
Signaler
Bub325
Messages postés
42
Date d'inscription
dimanche 9 février 2003
Statut
Membre
Dernière intervention
28 avril 2010
Je confirme, le code est vraiment très bourain. Et je pense qu'il a effectivement plus sa place en niveau 1 que 2, car il faut encore l'optimiser.
Mais il a tout de même le mérite de montrer qu'en prog, on peut faire beaucoup de chose même en étant débutant, le reste se retrouve dans l'optimisation et le guain de temps.

Bonne continuation,

Bub325
Signaler
theneoiceman
Messages postés
78
Date d'inscription
lundi 14 avril 2003
Statut
Membre
Dernière intervention
23 avril 2010
pour calculer la longueur de ton fichier essaye ta fonction que j'ai modifié :

long CaptFileSize (char* fichier)
{
long c;
FILE *f=fopen (fichier,"rb");
if (!f) return 0;
fseek(f,0L,SEEK_END);
c=ftell(f);

fclose (f);
return c;
}


Voila voila
Signaler
cs_Chouchou182
Messages postés
252
Date d'inscription
vendredi 13 juin 2003
Statut
Membre
Dernière intervention
25 avril 2011
Salut

C'est sympa comme source

Je pense que tu aurais pu programmer une routine de comparaison du mot en cours avec un tableau contenant tous les mots-clés. Parce que là c'est plutôt long ce gros switch suivi de pas mal de if...

En utilisant strncmp ce serait également allé plus vite (à programmer)

Sinon il manquait effectivement string.h (et pas strings.h) mais ce n'est pas dramatique

A++

Chouchou
Afficher les 8 commentaires
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 (lolquivole)