Mkd (Extracteur de documents)/Exercices/cpp.c pour exercices
- Copiez le contenu du cadre ci-dessous dans votre éditeur de texte et faites une sauvegarde dans un fichier nommé cpp.c:
- Surlignez le contenu du cadre ci-dessous.
- Appuyez simultanément sur les touches CTRL et C,
- Ensuite faites la même chose avec CTRL et V dans votre éditeur afin d'y coller ce texte.
- Enfin sauvegardez votre fichier avec le nom cpp.c
- Remarques:
- Dans ce fichier les tabulation habituelles ont été remplacées par 3 espaces pour faciliter la lecture.
- Les tabulations peuvent jouer de mauvais tours à l'édition.
- Prendre connaissance des bugs.
Fichiers de la fonction cpp_()
modifier- Testé: (4 mai 2013)
- cpp.c pour Konsole
- Non testé:
- cpp.cc pour version c++ indépendante
- cpp.inc.c pour inclusion dans le source avec gtkmm pour mkdcppw
cpp.c, cpp.cc, cpp.inc.cc
// Entête de documentation au format html pour les exercices
// html header, début de page html:
/*h <!-- header -->
<!Doctype html public "-//w3c//dtd html 4.0 Transitional//en">
<HTML>
<HEAD>
<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=UTF-8" />
<TITLE>Exercices avec mkd</TITLE>
</HEAD>
<BODY>
<i>Exercices avec la commande mkd.</i>
*/
// corps du document avec balises html:
/*p <!-- main -->
<p>
<b><u>Fonction cpp_(); Fichier cpp.c</u></b>
<br>
<b>Documentation simplifiée.</b>
<br>
La fonction doit décoder des commentaires, pré-codés avec un caractère ASCII qui suit le début de commentaire.
<br>
Exemple: //A ou /*A
<br>
... et bla bla bla ...(raccourci pour les exercices)
</p>
<p>
<b>Tests unitaires:</b>
<br>
Vérifiez les options n, s et t séparément:
<br>
Vérifiez que la numérotation des lignes est correcte dans tous les cas de décodage (lignes et blocs). n, ns. nt, nst.
<br>
Vérifiez que le texte reste à la bonne place dans tous les cas de décodage: toute la ligne (dans la cas de la directive de compilation FULL_LINE), ou texte seul.
<br>
-- Vérifiez que les tabulations sont bien prises en charge dans tous les cas, décodage des lignes et des blocs.
<br>
-- Vérifiez de même pour les espaces.
<br>
La fonction doit être éprouvée de telle sorte qu'un commentaire qui se termine par le caractère de fin de fichier soit entièrement copié dans le fichier cible.
<br>
La fonction cpp_() doit être éprouvée de telle sorte qu'un commentaire qui se termine par le caractère de fin de fichier soit entièrement copié dans le fichier cible.
<br>
Le caractère de fin de fichier décodé avant le(les) caractère(s) de fin de commentaire doit être remplacé par un caractère de fin de ligne.
<br>
<br>
Le caractère de fin de fichier <b>(EOF) ne doit jamais apparaître dans le texte du fichier cible</b>.
<br>
<i>Ceci provoquait un bug dans la version Alpha de l'application fenêtrée mkdcppw; à l'étape du test d'intégration.</i>
</p>
*/
// fin de page html:
/*f <!-- footer -->
</BODY>
</HTML>
*/
// Documentation en texte classique:
/*P
FILE NAME: cpp.c for konsole cpp.cc for individual compilation in c++ or
cpp.inc.cc to include file in sources files with gtkmm
PROJECT: mkd
mkd is a UNIX command to extract pre-encoded comments lines to generate the
software documentation according to ISO standards.
mkd is the abbreviation of make documentation. This command was originally
known under the name mkdoc (make documentation).
This command is not integrated into the standard distributions of Unix / Linux
INITIAL PROJECT:
mkdoc 1989 for MS-DOS and UNIX now obsolete. CEM - University of Montpellier II
ADMINISTRATIVE RECORD:
extractdoc 04/12/2009
FILE UPDATE:
Date: ../../1986 by JPL Initial programming for MSDOS and UNIX on SUN
Date: ../../1991 by JPL mkdoc 3.12 for PC and UNIX
Date: ../../1995 by JPL mkdoc 3.22 for RED-HAT on LINUX
Date: ../../2004 by JPL mkdoc 4.00 for LINUX ubuntu
Date: 11/02/2010 by JPL Update for MS Visual C10 beta 2.
Date: ../../.... by JPL Transformation into independant function for mkdcpp.
Date: ../03/2012 by CLARA Update to UTF-8 format (C++)
Date: 02/05/2012 by CLARA Special adaptation for mkdcppw with gtkmm
Date: 10/03/2013 by JPL Rewrite in english (en) to facilitate the translations
Date: 30/04/2013 by GC Rewrite to correct End Of File control
Date: 03/05/2013 by JPL Resolve the EOF problem if the last block is open.
*/
// Date: ../../.... by ... purpose of the modification ....
/*T
FILE NAME: cpp.c for konsole cpp.cc for individual compilation in c++ or
cpp.inc.cc to include file in sources files with gtkmm
Directives de tests unitaires version alpha 2013:
-------------------------------------------------
Vérifiez les options n, s et t séparément:
Vérifiez que la numérotation des lignes est correcte dans tous les cas de
décodage (lignes et blocs). n, ns. nt, nst.
Vérifiez que le texte reste à la bonne place dans tous les cas de décodage:
toute la ligne (dans la cas de la directive de compilation FULL_LINE), ou
texte seul.
-- Vérifiez que les tabulations sont bien prises en charge dans tous les
cas, décodage des lignes et des blocs.
-- Vérifiez de même pour les espaces.
La fonction doit être éprouvé©e de telle sorte qu'un commentaire qui se
termine par le caractère de fin de fichier soit entièrement copié dans le
fichier cible.
Le caractère de fin de fichier décodé avant le(les) caractère(s) de fin de
commentaire doit être remplacé par un caractère de fin de ligne.
Le caractère de fin de fichier (EOF) NE DOIT JAMAIS APPARAÎTRE DANS LE
TEXTE DU FICHIER CIBLE.
Ceci provoquait un bug dans la version Alpha de l'application fenêtrée
mkdcppw à l'étape du test d'intégration.
Ajouté le 18 avril 2013:
Vérifiez que l'extraction de tous les commentaires avec pour code de
décodage '**' soient copiés et que ceux-ci soient à la bonne place.
*/
/*D
function cpp_
-----------------------------------------------------------------------------
FILE NAME: cpp.c for konsole cpp.cc for individual compilation in c++ or
cpp.inc.cc to include file in sources files with gtkmm
FUNTION NAME:
cpp_
SYNOPSIS, SYNTAX:
#include "/usr/include/mkd/version.h" // IMPORTANT: Compilation directives
#include "/usr/include/mkd/cpp.h" // or mkd.h
int cpp_(FILE * pfdoc, FILE * pnfile);
FILE * pfdoc: pointer of the target file opened by the calling function
FILE * pnfile: pointer of the source file opened by the calling function In UNIX / LINUX
ACTION, DESCRIPTION:
The cpp_ function reads the source file (pnfile) transmitted from the
calling function, and decodes the comments pre-encoded in lines or
blocks of style c++. and then writing this comments in a target file
(pfdoc).
Pre-coded characters are defined in a external global table 'Codes';
The golbal variables are 'Codes' and 'Options'.
The 'Codes': table of 5 characters:
extern char codes[];
They must be défined in the calling function:
char codes[5] = {0,0,0,0,0};
The 'Options': n,s,t,v:
extern unsigned char n,s,t;
They must be dEfined in the calling function:
unsigned char n=0,s=0,t=0;
With the options:
-n: The transcript is preceded by line number. This allows to easily
reach the commented line.
-s: Add the comment to the screen to use shell redirections > , >> ,
or ||.
-t: With the t option only the commented text is copied.
Without the t option the entire line or block is copied.
The t option permit to generate directly exploitable and publishable
documents.
Remarks:
if the decoded comment begins with the characters / and *, the comment
is copied until find the characters * and /, whatever included any
comment-line starting with "//".
if the decoded comment begins with the characters "//", the line is
copied until find the end-of-line or new-line 'NL' character or
end-of-file 'EOF'.
This provisions facilitate the automatic generation of header files
(file.h ; .hpp ; etc.) and documentation of functions.
CONFORMING TO:
POSIX, ANSI C, BSD, ISO/IEC 9899:2011; gcc, MS-Vc10; UTF-8.
PORTABILITY,
LINUX-Debian-systems, LINUX-Red-Hat, UNIX, gcc.
Microsoft Visual studio under Windows : x86(Win32) x64(Win32 and WIN64)
RETURN VALUE:
Return 0 in case of success in konsole version, nothing with gtkmm.
COPYRIGHT:
© EELL, Éditeurs Européens de Logiciels Libres, EUPL 2007
Association À but non lucratif selon l'Article 11 de la convention
européenne des droits de l'homme.
Vous êtes libre de copier reproduire et distribuer l’application selon les
termes de la Licence EUPL totalement compatible avec la licence GNU.
AUTHORS:
© Contact: http://edeulo.free.fr/contacts/formmail.php
Designer: intial JP Louyot (JPL)
Updates : JPL and Clara Jimenez
Traducteurs: Clara
RESSOURCES:
gtkmm 3 to compile mkdcppw with cpp.cc
gtkmm with mkdw future widowed version.
NOTES:
Update April 2013 the Coded comment begin also in 3rd colomn
BUGS:
See bugs reports http://edeulo.free.fr/phpBB3
SEE ALSO MANUAL:
Man(3) attached in English.
Command line : man 3 cpp_
*/
/*H
// File: cpp.c++ (Comments for UTF-8 text editor)
extern int cpp_ (FILE * pfdoc, FILE * pnfile);
*/
</pre>
<pre>
#ifndef GTKMM
// if GTKMM is not defined then it is a Konsole version
// when GTKMM is defined the file is included to the compilation
// *pfdoc and *pnfile are open by the calling function
#include "version.h"
#include "cpp.h"
int cpp_ (FILE* pfdoc, FILE* pnfile)
{ //S Function begin for Konsole version
/*
The following statements are made in the calling function in
windowed version, and then not "extern" in windowed version.
n, s, t, and codes, are always defined in calling function.
*/
extern unsigned char n,s,t; //w Konsole version
extern char codes[]; //w Konsole version
#else
{ //S Function begin for gtkmm
#endif
unsigned int i,tab;
unsigned num = 0;
long ll,nl;
int c1 = STX; /* STX : Start Text */
int c2 = STX;
int c3 = STX;
/*O while next character is not End Of File */
while ( c1 != EOF && c2 != EOF && c3 != EOF )
{ /*Sw1 Col 7 while !EOF */
bool ligne = 0;
/*O if it is the first char then c1=LF */
if (c1==STX) c1='\n'; // STX is defined in version.h
/*O else c1 is the next char */
else c1=getc(pnfile);
if (c1==EOF) break;
/*O if the char is New Line
-- then mark the followed position in memory (long int 'nl') */
if(c1=='\n')
{ /*S NL */
nl=ftell(pnfile);
tab=0;
num++;
} /*S NL */
else
{ /*S !NL */
/*O if the char is '\t' tabulation, then tab++ */
if (c1=='\t')tab++;
/*O else if the char is '/' */
else if(c1=='/')
/*O then: */
{ /*S char = '/' */
c2=getc(pnfile); //P is not necessary to break here
c3=getc(pnfile);
/*O if the char is followed by c2 = '*' or '/' and if options[0]=0
-- or if it is followed by user char 'code[]' */
if( (c2=='*'||c2=='/') &&
( !codes[0]|| // all comments
c3 == codes[0] ||
c3 == codes[1] ||
c3 == codes[2] ||
c3 == codes[3] ||
c3 == codes[4]
)
)
//O
/*O then: treat the inline or block comment */
{ /*S Treat the inline or block comment */
/*O if c2 = '/' set the Boolean 'ligne' to true (=1) */
if(c2=='/') ligne=1;
/*O recognise the comment position */
//Pw appearance of codes in lines if codes[] flags are false
// if(!codes[0])ungetc(c3,pnfile); //Pw depends of codes[]
ll=ftell(pnfile);
/*O if option n is true then insert the line number */
if(n)
{ /*S*/
fprintf( pfdoc, "%5d ", num );
if(s) printf( "%5d ", num );
} /*S*/
/*O if option t is not true,
then: */
if(!t)
{ /*S option t false */
/*O positioning at the beginning line */
fseek(pnfile,nl,0);
/*w or: fseek(pnfile,(nl-ftell(pnfile)),1); */
/*O copy the beginning line in the target file */
for(i=(int)(ll-nl);i>0;i--)
{ /*S*/
c1=getc(pnfile); //P in this case c1 ≠ EOF
putc(c1,pfdoc);
if(s)putch(c1);
} /*S*/
} /*S option t false */
/*O else: (option t) */
else
{ /*S option t true */
/*O copy the tabulations as much as there is in the source file */
for(i=0;i<tab;i++) //w warning to copy tab first
{ /*S*/
putc('\t',pfdoc);
if(s)putch('\t');
} /*S*/
/*O copy space up to comment */
for(i=(int)(ll-nl-tab);i>0;i--) //w warning to copy spaces after tabs
{ /*S*/
putc(' ',pfdoc);
if(s)putch(' ');
} /*S*/
} /*S option t true and */
//O
/*O if the line boolean 'ligne' is true (=1) */
if(ligne)
/*O then:
copy the inline comment to End Of Line (EOL) or (EOF) */
{ /*S Copy the inline last comment */
while ( (c1=getc(pnfile)) != '\n' && c1 !=EOF)
{ /*Sw2 Col 22 Copy the comment */
putc(c1,pfdoc);
if(s)putch(c1);
} /*Sw2 Col 22 Copy the comment */
if(c1==EOF) break; // exit from w1 while
ungetc(c1,pnfile); /* pour la recopie fin de ligne */
} /*S Copy the inline last comment */
/*O else while does not find the char * followed by / : */
//O
/*O copy the comment */
else
{ /*S else !(line) copy the comment to end of block */
while ( !(c1=='*' && c2=='/') && c1!=EOF && c2!=EOF )
{ /*Sw3 Col 22 */
c1=getc(pnfile); // get next char in source buffer
/*O if next char (c2) is NL and the followed char is EOF
then break the while w3
else rewind C2 in the source buffer */
if (c1 == 0x0A)
{
if ( (c2=getc(pnfile) ) == EOF) break; //P break while w3
else ungetc(c2,pnfile); // rewind if it is not EOF
}
/*O if next char is '*' put c the char to stdout and target buffer */
if( c1 != '*' )
{ /*S*/
/*www if(c1=='\n') fprintf(pfdoc, "%s", NL );*/
/*www /*P CR/LF under DOS */
/*www else */
putc(c1,pfdoc);
if(s)putch(c1);
/*O if option n is true and char c1=NL
then:
insert the line number following NL */
if( n && c1=='\n' )
{ /*S*/
num++;
fprintf( pfdoc,"%5d ", num );
if(s) printf("%5d ", num );
} /*S*/
} /*S*/
/*O if next char (c1) is '*' getc and see next char (c2) */
if (c1=='*') //P c1='*' c2=?
{ /*S c1=* c2=? */
c2=getc(pnfile);
/*O if c2 is '/' then rewind c2 and c1 */
if(c2=='/')
{ /*S c2=/ */
ungetc(c2,pnfile); // to rewind the '/' from end of block
ungetc(c1,pnfile); // to rewind the '*' from end of block
} /*S c2=/ */
/*O else c1 = always '*' and c2 ≠ '/'
rewind c2 in source buffer
put c1 to target buffer and to stdout if n is true */
else /*P c1 = always '*' and c2 ≠ '/' */
{ /*S not end of comment */
//T fprintf(pfdoc, "\nc1 = %c c2 = %c\n", c1, c2); //T
ungetc(c2,pnfile); // to rewind the char in file buffer
putc(c1,pfdoc); // copy the '*' to target file
if(s)putch(c1); // copy the '*' to stdout (and go to get next char)
} /*S not end of comment */
} /*S c1=* c2=? */
} /*Sw3 Col 22 */
//T if (c1==EOF) break;
} /*S else !(line) copy the comment to end of block */
//O
#ifdef FULL_LINE
/*O BEGIN FULL_LINE */
/*O *** Compilation option to copy last of line to target file */
/*O if t option is false,
then: */
if(!t)
{ /*S Option t false */
/*O Copy the comment to End Of Line or EOF */
//P -- including '\r' (CR/LF) under DOS */
while ( (c1=getc(pnfile)) != '\n' && c1!=EOF )
{ /*Sw4 Col 22 */
putc(c1,pfdoc);
if(s)putch(c1);
} /*Sw4 Col 22 */
} /*S Option t false */
/*O else (option t true) */
else
/*O END FULL_LINE *** Compil. option */
#endif
//O
/*O t is true by default if FULL_LINE is not denined at the
compilation */
{ /*S (t is true) */
/*O Go to EOL without copying, except the carriage return */
while ( (c1=getc(pnfile)) != '\n' && c1!=EOF )
{ /*Sw5 Col 22 */
if (c1=='\r')
{ /*S*/
putc( c1, pfdoc );
if(s) putch( c1 );
} /*S*/
} //*Sw5 Col 22 */
if (c1==EOF) break; //P exit from while w1
} /*S (t is true) */
/*P and next, copy New Lines under this form: CR/LF under DOS */
//T fprintf(pfdoc, "%s", NL ); //P obsolete ?
//T if(s) puts("");
putc(c1,pfdoc);
if(s)putch(c1);
/*O and backward to NL */
ungetc(c1,pnfile);
} /*S Treat the inline or block comment */
/*O else: (it is not a comment) */
else
{ /*S Not a comment */
/*O Back behind two characters */
ungetc(c3,pnfile);
ungetc(c2,pnfile);
} /*S Not a comment */
} /*S endif char = '/' */
} /*S endif!NL */
} /*Sw1 Col 7 while !EOF */
/*O return of a character back to avoid the End Of File EOF ! */
/*w verify in tests this « character back » with EOF and EOL at end of file */
nl=ftell(pfdoc);
nl--;
fseek(pfdoc,nl,0);
#ifndef GTKMM
return 0;
#else
//return;
#endif
} /*S End funtion cpp_ konsole, or windowed version with gtkmm */
Fichier de commande des tests Konsole
modifierMAKE_Tets_U, CLEAN_Tests_U
- Fichier MAKE_Tests_U:
#!/bin/bash
#O ../../mkd tests under Linux.
#O Epreuve de vérification de la fonction cpp_() avec ../../mkd
#O Copy Test_cpp_U.cc in target created file
cat Test_cpp_U.cc > Test_cpp_U.tstcpp
#O Test options -nstv with source "Test_cpp_U.cc" and target "*.tstcpp"
#O - and screen redirection to tstcpp.screen
#O 1: Test de l'option -s append target
echo "------------------------------------------------------------------" >> Test_cpp_U.tstcpp
echo "1: Test de l'option -s append target" >> Test_cpp_U.tstcpp
../../mkd -savC T Test_cpp_U.cc *.tstcpp > tstcpp.screen
#O 1: Test option -t
echo "------------------------------------------------------------------" >> Test_cpp_U.tstcpp
echo "1: Test option -t" >> Test_cpp_U.tstcpp
../../mkd -tavC T Test_cpp_U.cc *.tstcpp # >> tstcpp.screen
#O 1: Test option -n, with append files target and screen
echo "------------------------------------------------------------------" >> Test_cpp_U.tstcpp
echo "1: Test option -n, with append files target and screen" >> Test_cpp_U.tstcpp
../../mkd -navC T Test_cpp_U.cc *.tstcpp # >> tstcpp.screen
#O 2: Test options -ns, with append files target and screen
echo "------------------------------------------------------------------" >> Test_cpp_U.tstcpp
echo "------------------------------------------------------------------" >> Test_cpp_U.tstcpp
echo "------------------------------------------------------------------" >> Test_cpp_U.tstcpp
echo "2: Test options -ns, with append files target and screen" >> Test_cpp_U.tstcpp
../../mkd -nsavC T Test_cpp_U.cc *.tstcpp >> tstcpp.screen
#O 2: Test options -nt, with append files target and screen
echo "------------------------------------------------------------------" >> Test_cpp_U.tstcpp
echo "2: Test options -nt, with append files target and screen" >> Test_cpp_U.tstcpp
../../mkd -ntavC T Test_cpp_U.cc *.tstcpp >> tstcpp.screen
#O 2: Test options -nst, with append files target and screen
echo "------------------------------------------------------------------" >> Test_cpp_U.tstcpp
echo "2: Test options -nst, with append files target and screen" >> Test_cpp_U.tstcpp
../../mkd -nstavC T Test_cpp_U.cc *.tstcpp >> tstcpp.screen
#O 5: Independant test with -nstv "Test_cpp_U.cc" and target "*.tstcpplastline1"
../../mkd -nstvwC S Test_cpp_U.cc *.tstcpplastline1 > tstcpplastline.screen1
#O 5: Independant test with -nstv "Test_cpp_U.c2" and target file "*.tstcpplastline2"
../../mkd -nstvwC T Test_cpp_U.c2 *.tstcpplastblock > tstcpplastblock.screen2 #w bug ?
#O 5: Independant test with -nstv "Test_cpp_U.c3" and target file "*.tstcpplastline2"
../../mkd -nstvaC T Test_cpp_U.c3 *.tstcpplastblock >> tstcpplastblock.screen2 #w bug ?
#O 5: Independant test with -nstv "Test_cpp_U.c4" and target file "*.tstcpplastline2"
../../mkd -nstvaC T Test_cpp_U.c4 *.tstcpplastblock >> tstcpplastblock.screen2 #w bug ?
#O Break with gedit "Test_cpp_U.tstcpp", "tstcpp.screen"
gedit Test_cpp_U.tstcpp tstcpp.screen Test_cpp_U.tstcpplastline1 tstcpplastline.screen1 Test_cpp_U.tstcpplastblock tstcpplastblock.screen2
#w bug gedit Test_cpp_U.cc.tstcpplastline2 #bug in version < 2012
#O Erase Test_cpp_U.tstcpp
- Fichier CLEAN_Tests_U:
#!/bin/bash
#O File Tests_Clean
#O Force delete files created with mkd "tests" under Linux.
rm -f Test_cpp_U.tstcpp
rm -f tstcpp.screen
rm -f Test_cpp_U.tstcpplastline1
rm -f tstcpplastline.screen1
rm -f Test_cpp_U.tstcpplastblock
rm -f tstcpplastblock.screen2
rm -f *.doc
Analyse du test Konsole
modifierRésultat des tests; analyse 4 Mai 2013
Fichier Analysis texte UTF-8
Analyse du : 4 mai 2013 par Clara pour le retour à la conception détaillée.
-------------------------------------------------------------------------------
Résultats du test unitaire de la fonction cpp_() du fichier cpp.c intégrée à
la commande mkd 2012: mkd_120508
.
Ce test est effectué avec la version mkd 2012 pour évaluer les modifications
à effectuer dans la version alpha 2013.
.
Note : Nous n'avons pas effectué ce test avec les commandes mkdcpp et mkdcppw
qui aboutiraient aux mêmes résultats.
.
D'après les directives et les fichiers d'analyse Test_cpp_U.tstcpp et
tstcpp.screen
.
Directives de tests unitaires version alpha 2013:
-------------------------------------------------
1: Vérifiez les options n, s et t séparément:
- les essais séparés fonctionnent correctement et sont conformes
.
2: Vérifiez que la numérotation des lignes est correcte dans tous les cas de
décodage (lignes et blocs). n, ns. nt, nst.
- Les essais réalisés ont été conformes
.
3: Vérifiez que le texte reste à la bonne place dans tous les cas de décodage:
toute la ligne (dans la cas de la directive de compilation FULL_LINE), ou
texte seul.
- Le résultat est conforme (Sans de numérotation des lignes)
.
4: -- Vérifiez que les tabulations sont bien prises en charge dans tous les
cas, décodage des lignes et des blocs.
-- Vérifiez de même pour les espaces.
- Les résultas sont conformes. Il est à noter que les tabulations créent un
décalage du texte avec l'option -n numéroation
.
5: La fonction doit être éprouvée de telle sorte qu'un commentaire qui se
termine par le caractère de fin de fichier soit entièrement copié dans le
fichier cible.
Le caractère de fin de fichier décodé avant le(les) caractère(s) de fin de
commentaire doit être remplacé par un caractère de fin de ligne 0xOA.
- Le fichier Test_cpp_U.tstcpplastline1 commentaire ligne; fait apparaître
une fin de fichier conforme.
- Le fichier Test_cpp_U.tstcpplastblock test des blocs, fait apparaîre des
tests réalisés avec succès après plusieurs modifications du fichier
source en raison du caractère 0x0A (NL) qui provoquait un retour à la
ligne avant la fin du fichier et ne donnait pas les résultats attendus.
.
6: Le caractère de fin de fichier (EOF) NE DOIT JAMAIS APPARAÎTRE DANS LE
TEXTE DU FICHIER CIBLE.
Ceci provoquait un bug dans la version Alpha de l'application fenêtrée
mkdcppw à l'étape du test d'intégration.
- La réponse est incluse dans les tests 5:
- Nous avons constaté que EOF est précédé du caractère OxOA (New Line)
- Tous les caractères sont recopiés octets par octets. La commande mkd
ignore le format du texte recopié. Il n'en est pas de même pour mkdcppw
qui ne reconnaît que les caractères UTF-8 nécessaires à l'impression.
Fichiers sources des tests
modifierTest_cpp_U.c*
- Fichier Test_cpp_U.cc
//T File Test_cpp_U.cc to test function cpp_()
/*P
Fonction cpp_(); Fichier cpp.c
Directives de tests unitaires version alpha 2013:
-------------------------------------------------
Vérifiez les options n, s et t séparément:
Vérifiez que la numérotation des lignes est correcte dans tous les cas de
décodage (lignes et blocs). n, ns. nt, nst.
Vérifiez que le texte reste à la bonne place dans tous les cas de décodage:
toute la ligne (dans la cas de la directive de compilation FULL_LINE), ou
texte seul.
-- Vérifiez que les tabulations sont bien prises en charge dans tous les
cas, décodage des lignes et des blocs.
-- Vérifiez de même pour les espaces.
La fonction doit être éprouvée de telle sorte qu'un commentaire qui se
termine par le caractère de fin de fichier soit entièrement copié dans le
fichier cible.
Le caractère de fin de fichier décodé avant le(les) caractère(s) de fin de
commentaire doit être remplacé par un caractère de fin de ligne.
Le caractère de fin de fichier (EOF) NE DOIT JAMAIS APPARAÎTRE DANS LE
TEXTE DU FICHIER CIBLE.
Ceci provoquait un bug dans la version Alpha de l'application fenêtrée
mkdcppw à l'étape du test d'intégration.
*/
/*T* *** 3 stars ***
12345678901234567890123456789012345678901234567890123456789012345678901234567890 **/
#define TEST //T The macro becomes active
#ifdef TEST //T Do something (Faire quelque chose)
#undef test //T The macro becomes inactive
/*T
12345678901234567890123456789012345678901234567890123456789012345678901234567890 */
//T test in ligne with 2 tabulations
//T test in ligne with 5 spaces
/*T test bloc in first line end bloc*/
/*T test bloc in first line
with 2 tabs
with 5 spaces end bloc */ //T and full line test
/*T
12345678901234567890123456789012345678901234567890123456789012345678901234567890 */
/*T test bloc in line with 2 tabs end bloc*/
/*T test bloc in line
2 tabs
with 5 spaces
end bloc */
//T see also "/*T" with out end of block comment and EOL in file Test_cpp_U.c
//S test inline with out end of line (EOL)(NL)(CR/LF)
- Fichier Test_cpp_U.c2
//T File Test_cpp_U.c
/*T with out end of block comment and EOL (NL) in file Test_cpp_U.c2 /
- Fichier Test_cpp_U.c3
//T File Test_cpp_U.c3
/*T with out end of block comment and EOL (NL) in file Test_cpp_U.c3 *
- Fichier Test_cpp_U.c4
//T File Test_cpp_U.c4
/*T with out end of block comment and EOL (NL) in file Test_cpp_U.c4 */