API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Dec 10th, 2018
67
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 24.74 KB | None | 0 0
raw download clone embed print report
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <math.h>
  4. #include <dirent.h>
  5. #include <string.h>
  6. #define ACCOLADE '{'
  7. #define ACCOLADE_FERMANTE '}'
  8. #define CARRIAGERETURN '\n'
  9. #define SPACE ' '
  10. #define COMMA ','
  11.  
  12. void arrayBracketEol(char*);
  13. void operatorsSpacing(char*);
  14. void commaSpacing(char*);
  15. void indent(char*);
  16. void commentsHeader(char*);
  17. void maxLineNumbers(int n, char*);
  18. void maxFileLineNumbers(int n, char*);
  19. void noMultiDeclaration(char*);
  20. void noTrailingSpaces(char*);
  21. void functionactive(int aBrack, int commaSpace, int pIndent, int commHeadr,int maxLineNbr, int maxFileNbr, int noMultiDec,int noTrail, char* fileName);
  22. int main()
  23. {
  24. int menu;
  25. FILE *fichier;
  26. fichier=NULL;
  27. fichier = fopen("Config.lconf","rb");
  28. int i=0;
  29. int j = 1;
  30. int t=0;
  31. int numLine=1;
  32. int fileSize=0;
  33. int aBrack = 0;
  34. int commaSpace = 0;
  35. int pIndent = 0;
  36. int commHeadr = 0;
  37. int maxLineNbr = 0;
  38. int maxFileNbr = 0;
  39. int noMultiDec =0;
  40. int noTrail =0;
  41. char *confBuffer;
  42. char bufMaxLine[] = {'0','0','0','\0'};
  43. char bufMaxFileNbr[] = {'0','0','0','\0'};
  44.  
  45. if (fichier != NULL)
  46. {
  47. do
  48. {
  49. fgetc(fichier);
  50. fileSize++;
  51. }
  52. while (!feof(fichier));
  53.  
  54. confBuffer = malloc(sizeof(char) * fileSize);
  55. fseek(fichier, 0, SEEK_SET);
  56.  
  57. do
  58. {
  59. confBuffer[i] = fgetc(fichier);
  60. i++;
  61. }
  62. while (!feof(fichier));
  63.  
  64.  
  65. for(int i=0; i< fileSize; i++) //On fait un confBuffer sous forme de chaques caractères pour enregistrer chaques lignes
  66. {
  67.  
  68.  
  69. if(CARRIAGERETURN==confBuffer[i-1] && '-'==confBuffer[i] )
  70. {
  71.  
  72. while (CARRIAGERETURN != confBuffer[i])
  73. {
  74.  
  75. if('-'==confBuffer[i] && 'a'==confBuffer[i+1] && 'r'==confBuffer[i+2] && 'r'==confBuffer[i+3] && 'a'==confBuffer[i+4] && 'y'==confBuffer[i+5] && '-'==confBuffer[i+6] && 'b'==confBuffer[i+7] )
  76. {
  77. printf("array bracket parameters\n");
  78.  
  79. while(CARRIAGERETURN!=confBuffer[i])
  80. {
  81.  
  82. if('1'==confBuffer[i])
  83. {
  84. aBrack = 1;
  85. }
  86. else if('0'==confBuffer[i])
  87. {
  88. aBrack=0;
  89. }
  90. i++;
  91. }
  92. printf("%d\n", aBrack );
  93. }
  94. if('-'==confBuffer[i] && 'c'==confBuffer[i+1] && 'o'==confBuffer[i+2] && 'm'==confBuffer[i+3] && 'm'==confBuffer[i+4] && 'a'==confBuffer[i+5] )
  95. {
  96. printf("Comma parameters\n");
  97. while(CARRIAGERETURN!=confBuffer[i])
  98. {
  99.  
  100. if('1'==confBuffer[i])
  101. {
  102. commaSpace = 1;
  103. }
  104. else if('0'==confBuffer[i])
  105. {
  106. commaSpace=0;
  107. }
  108. i++;
  109. }
  110. printf("%d\n", commaSpace );
  111.  
  112. }
  113. if('-'==confBuffer[i] && 'i'==confBuffer[i+1] && 'n'==confBuffer[i+2] && 'd'==confBuffer[i+3] && 'e'==confBuffer[i+4] && 'n'==confBuffer[i+5] )
  114. {
  115. printf("indent parameters\n");
  116. while(CARRIAGERETURN!=confBuffer[i])
  117. {
  118.  
  119. if('1'==confBuffer[i])
  120. {
  121. pIndent = 1;
  122. }
  123. else if('0'==confBuffer[i])
  124. {
  125. pIndent=0;
  126. }
  127. i++;
  128. }
  129. printf("%d\n", pIndent );
  130.  
  131. }
  132. if('-'==confBuffer[i] && 'c'==confBuffer[i+1] && 'o'==confBuffer[i+2] && 'm'==confBuffer[i+3] && 'm'==confBuffer[i+4] && 'e'==confBuffer[i+5] && 'n'==confBuffer[i+6] && 't'==confBuffer[i+7] )
  133. {
  134. printf("comments parameters\n");
  135. while(CARRIAGERETURN!=confBuffer[i])
  136. {
  137.  
  138. if('1'==confBuffer[i])
  139. {
  140. commHeadr = 1;
  141. }
  142. else if('0'==confBuffer[i])
  143. {
  144. commHeadr=0;
  145. }
  146. i++;
  147. }
  148. printf("%d\n", commHeadr );
  149.  
  150. }
  151. if('-'==confBuffer[i] && 'm'==confBuffer[i+1] && 'a'==confBuffer[i+2] && 'x'==confBuffer[i+3] && '-'==confBuffer[i+4] && 'l'==confBuffer[i+5] && 'i'==confBuffer[i+6] && 'n'==confBuffer[i+7] )
  152. {
  153. printf("maxline parameters\n");
  154.  
  155. while(CARRIAGERETURN!=confBuffer[i])
  156. {
  157. if('='==confBuffer[i])
  158. {
  159. j=1;
  160. t=0;
  161. while(CARRIAGERETURN!=confBuffer[i+j])
  162. {
  163.  
  164. bufMaxLine[t] = confBuffer[i+j];
  165. j++;
  166. t++;
  167. }
  168. }
  169. i++;
  170. }
  171.  
  172. maxLineNbr = atoi(bufMaxLine);
  173. printf("%d\n", maxLineNbr);
  174.  
  175.  
  176. }
  177. if('-'==confBuffer[i] && 'm'==confBuffer[i+1] && 'a'==confBuffer[i+2] && 'x'==confBuffer[i+3] && '-'==confBuffer[i+4] && 'f'==confBuffer[i+5] && 'i'==confBuffer[i+6] && 'l'==confBuffer[i+7] )
  178. {
  179. printf("maxfile parameters\n");
  180. while(CARRIAGERETURN!=confBuffer[i])
  181. {
  182. if('='==confBuffer[i])
  183. {
  184. j=1;
  185. t=0;
  186. while(CARRIAGERETURN!=confBuffer[i+j])
  187. {
  188.  
  189. bufMaxFileNbr[t] = confBuffer[i+j];
  190. j++;
  191. t++;
  192. }
  193. }
  194. i++;
  195. }
  196.  
  197. maxFileNbr = atoi(bufMaxFileNbr);
  198. printf("%d\n", maxFileNbr);
  199.  
  200.  
  201. }
  202. if('-'==confBuffer[i] && 'n'==confBuffer[i+1] && 'o'==confBuffer[i+2] && '-'==confBuffer[i+3] && 't'==confBuffer[i+4] && 'r'==confBuffer[i+5] && 'a'==confBuffer[i+6] && 'i'==confBuffer[i+7])
  203. {
  204. printf("notrailing parameters\n");
  205. while(CARRIAGERETURN!=confBuffer[i])
  206. {
  207.  
  208. if('1'==confBuffer[i])
  209. {
  210. noTrail = 1;
  211. }
  212. else if('0'==confBuffer[i])
  213. {
  214. noTrail=0;
  215. }
  216. i++;
  217. }
  218. printf("%d\n", noTrail );
  219. }
  220. if('-'==confBuffer[i] && 'n'==confBuffer[i+1] && 'o'==confBuffer[i+2] && '-'==confBuffer[i+3] && 'm'==confBuffer[i+4] && 'u'==confBuffer[i+5] && 'l'==confBuffer[i+6] && 't'==confBuffer[i+7])
  221. {
  222. printf("nomultideclarations parameters\n");
  223. while(CARRIAGERETURN!=confBuffer[i])
  224. {
  225.  
  226. if('1'==confBuffer[i])
  227. {
  228. noMultiDec = 1;
  229. }
  230. else if('0'==confBuffer[i])
  231. {
  232. noMultiDec=0;
  233. }
  234. i++;
  235. }
  236. printf("%d\n", noMultiDec );
  237. }
  238. i++;
  239. }
  240. }
  241.  
  242. if(CARRIAGERETURN==confBuffer[i])
  243. {
  244. numLine++;
  245. }
  246.  
  247. fclose(fichier);
  248. }
  249.  
  250. }
  251. free(confBuffer);
  252.  
  253.  
  254.  
  255.  
  256.  
  257.  
  258. //////MENU//////////
  259. do
  260. {
  261. DIR * rep = opendir(".");
  262. printf("\nTaper 1 pour activer le linter !\n");
  263. printf("Taper 0 pour sortir du programme !\n");
  264. scanf("%d",&menu);
  265.  
  266. switch(menu)
  267. {
  268.  
  269. case 1:
  270.  
  271.  
  272. if (rep != NULL)
  273. {
  274. struct dirent * ent;
  275.  
  276. while ((ent = readdir(rep)) != NULL)
  277. {
  278. printf("\n%s\n", ent->d_name);
  279.  
  280. functionactive(aBrack, commaSpace, pIndent, commHeadr, maxLineNbr, maxFileNbr, noMultiDec, noTrail, ent->d_name);
  281. /*
  282. arrayBracketEol(ent->d_name);
  283. operatorsSpacing(ent->d_name);
  284. commaSpacing(ent->d_name);
  285. indent(ent->d_name);
  286. commentsHeader((ent->d_name));
  287. maxLineNumbers(60, ent->d_name);
  288. maxFileLineNumbers(20, ent->d_name);
  289. noMultiDeclaration(ent->d_name);
  290. */
  291. }
  292.  
  293. closedir(rep);
  294. }
  295. break;
  296.  
  297. case 0:
  298. return 0;
  299.  
  300. default:
  301. break;
  302.  
  303. }
  304.  
  305. }
  306. while(menu != 0);
  307.  
  308.  
  309.  
  310.  
  311.  
  312. }
  313.  
  314. void functionactive(int aBrack, int commaSpace, int pIndent, int commHeadr,int maxLineNbr, int maxFileNbr,int noMultiDec, int noTrail, char* fileName)
  315. {
  316. /*
  317. if (aBrack == 1)
  318. {
  319. arrayBracketEol(fileName);
  320. }
  321. else if(aBrack == 0)
  322. {
  323.  
  324. }
  325.  
  326. if (commaSpace == 1)
  327. {
  328. commaSpacing(fileName);
  329. }
  330. else if(commaSpace == 0)
  331. {
  332.  
  333. }
  334.  
  335. if (pIndent == 1)
  336. {
  337. indent(fileName);
  338. }
  339. else if(pIndent == 0)
  340. {
  341.  
  342. }
  343.  
  344. if (commHeadr == 1)
  345. {
  346. commentsHeader(fileName);
  347. }
  348. else if(commHeadr == 0)
  349. {
  350.  
  351. }
  352. */
  353.  
  354. if (noTrail == 1)
  355. {
  356.  
  357. noTrailingSpaces(fileName);
  358.  
  359. }
  360. else if(noTrail == 0)
  361. {
  362.  
  363. }
  364.  
  365. /*
  366. if (maxLineNbr > 0)
  367. {
  368. maxLineNumbers(60, fileName);
  369. }
  370. else
  371. {
  372.  
  373. }
  374.  
  375. if (maxFileNbr > 0)
  376. {
  377. maxFileLineNumbers(20, fileName);
  378. }
  379. else
  380. {
  381.  
  382. }
  383. */
  384. /*
  385. if (Recursive = True){
  386.  
  387. }
  388. */
  389. }
  390.  
  391.  
  392. void arrayBracketEol(char* fileName)
  393. {
  394. FILE *fichier;
  395. fichier=NULL;
  396. fichier = fopen(fileName,"rb");
  397. char caractereActuel;
  398. char caractereBuff;
  399. int numLine=1;
  400. if (fichier != NULL)
  401. {
  402. do
  403. {
  404. caractereActuel = fgetc(fichier); // On lit le caractère
  405. if(CARRIAGERETURN==caractereActuel)
  406. {
  407. numLine++;
  408. }
  409. if(ACCOLADE==caractereActuel)
  410. {
  411. if (CARRIAGERETURN==caractereBuff)
  412. {
  413. printf("array-bracket-eol error line %d\n",numLine);
  414. }
  415. }
  416.  
  417. if(SPACE!=caractereActuel)
  418. {
  419. caractereBuff = caractereActuel;
  420. }
  421. }
  422. while (!feof(fichier));
  423. }
  424. else
  425. {
  426. //printf("\n Impossible d'ouvrir le fichier test.txt \n");
  427.  
  428. }
  429. fclose(fichier);
  430.  
  431. }
  432.  
  433. void operatorsSpacing(char* fileName)
  434. {
  435.  
  436. /* PENSER à GERER LES EXCEPTIONS EX:"* POUR LES DECLARATIONS DE POINTEURS"*/
  437.  
  438. FILE *fichier;
  439. fichier=NULL;
  440. fichier = fopen(fileName,"rb");
  441. char caractereActuel;
  442. char prevChar;
  443. char nextChar;
  444. int numLine=1;
  445.  
  446.  
  447. if (fichier != NULL)
  448. {
  449. do
  450. {
  451. if(CARRIAGERETURN==caractereActuel)
  452. {
  453. numLine++;
  454. }
  455. caractereActuel = fgetc(fichier);
  456.  
  457. if(43==caractereActuel || 42==caractereActuel || 47==caractereActuel || 45==caractereActuel || 61==caractereActuel || 63==caractereActuel || 58==caractereActuel)
  458. {
  459.  
  460. fseek(fichier, -2, SEEK_CUR );
  461. prevChar=fgetc(fichier);
  462. fseek(fichier, 1, SEEK_CUR);
  463. nextChar=fgetc(fichier);
  464.  
  465. if(prevChar!=SPACE || nextChar!=SPACE)
  466. {
  467. printf("operators-spacing error line %d\n",numLine);
  468. }
  469. }
  470.  
  471. }
  472. while (!feof(fichier));
  473. }
  474. else
  475. {
  476. //printf("Impossible d'ouvrir le fichier test.txt");
  477.  
  478. }
  479.  
  480. fclose(fichier);
  481.  
  482.  
  483. }
  484.  
  485. void commaSpacing(char* fileName)
  486. {
  487.  
  488. FILE *fichier;
  489. fichier=NULL;
  490. fichier = fopen(fileName,"rb");
  491. char caractereActuel;
  492. char nextChar;
  493. int numLine=1;
  494.  
  495.  
  496.  
  497. if (fichier != NULL)
  498. {
  499. do
  500. {
  501. if(CARRIAGERETURN==caractereActuel)
  502. {
  503. numLine++;
  504. }
  505. caractereActuel = fgetc(fichier);
  506. if(COMMA==caractereActuel)
  507. {
  508. nextChar=fgetc(fichier);
  509.  
  510. if(nextChar!=SPACE)
  511. {
  512. printf("coma-spacing error line %d\n",numLine);
  513. }
  514. }
  515.  
  516. }
  517. while (!feof(fichier));
  518. }
  519. else
  520. {
  521. //printf("Impossible d'ouvrir le fichier test.txt");
  522.  
  523. }
  524. fclose(fichier);
  525.  
  526. }
  527.  
  528. void indent(char* fileName)
  529. {
  530.  
  531. FILE *fichier;
  532. fichier=NULL;
  533. fichier = fopen(fileName,"rb");
  534. char caractereActuel;
  535. int numLine=1;
  536. int n = 0;
  537. int numberOfSpace = 0;
  538. int counterEndOfLine = 0;
  539.  
  540.  
  541.  
  542. if (fichier != NULL)
  543. {
  544. do
  545. {
  546. if(CARRIAGERETURN==caractereActuel)
  547. {
  548. numLine++;
  549. counterEndOfLine = -1;
  550. }
  551. if(ACCOLADE==caractereActuel) //Trouve une accolade ouvrante
  552. {
  553. n += 4;
  554. //printf("%c", caractereActuel);
  555. //printf("%d \n", numLine);
  556.  
  557. }
  558. if(ACCOLADE_FERMANTE==caractereActuel) //Trouve une accolade fermante
  559. {
  560. n -= 4;
  561. //printf("%c", caractereActuel);
  562. //printf("%d \n", numLine);
  563. }
  564. //printf("%d ", counterEndOfLine);
  565. if(counterEndOfLine == 0) //Si nous sommes en début de ligne
  566. {
  567. while(caractereActuel==SPACE) //Compte les espaces en début de ligne
  568. {
  569.  
  570. numberOfSpace++;
  571. caractereActuel = fgetc(fichier);
  572. }
  573.  
  574. printf("\n %d %d ", n, numberOfSpace);
  575.  
  576. if(numberOfSpace != n && numberOfSpace != 0) //Compare le nombre d'espace en début de ligne au nombre d'espace qu'il devrait y avoir
  577. {
  578. printf("indent error line %d\n",numLine);
  579. }
  580.  
  581. }
  582. numberOfSpace = 0;
  583. caractereActuel = fgetc(fichier);
  584. counterEndOfLine++;
  585.  
  586. }
  587. while (!feof(fichier));
  588. }
  589. else
  590. {
  591. //printf("Impossible d'ouvrir le fichier test.txt");
  592.  
  593. }
  594. fclose(fichier);
  595. }
  596.  
  597. void commentsHeader(char* fileName)
  598. {
  599. FILE *fichier;
  600. fichier=NULL;
  601. fichier = fopen(fileName,"rb");
  602. char caractereActuel;
  603. char caractereBuff;
  604. int numLine=1;
  605. if (fichier != NULL)
  606. {
  607. do
  608. {
  609. caractereActuel = fgetc(fichier); // On lit le caractère
  610. if(CARRIAGERETURN==caractereActuel)
  611. {
  612. numLine++;
  613. }
  614. if(numLine<6)
  615. {
  616.  
  617. if('*'==caractereActuel)
  618. {
  619. if ('/'==caractereBuff)
  620. {
  621. printf("comments header on top line %d\n",numLine);
  622. }
  623. }
  624.  
  625. }
  626.  
  627.  
  628. caractereBuff = caractereActuel;
  629.  
  630. }
  631. while (!feof(fichier));
  632. }
  633. else
  634. {
  635. printf("Impossible d'ouvrir le fichier test.txt");
  636.  
  637. }
  638. fclose(fichier);
  639.  
  640. }
  641.  
  642. void maxLineNumbers(int n, char* fileName)
  643. {
  644. FILE *fichier;
  645. fichier=NULL;
  646. fichier = fopen(fileName,"rb");
  647. char caractereActuel;
  648. int numLine=1;
  649. int nbCarac=0;
  650. int reset=0;
  651. if (fichier != NULL)
  652. {
  653. do
  654. {
  655. caractereActuel = fgetc(fichier); // On lit le caractère
  656. if(CARRIAGERETURN==caractereActuel)
  657. {
  658. numLine++;
  659. reset=0;
  660. }
  661. nbCarac++;
  662. if (CARRIAGERETURN==caractereActuel)
  663. {
  664. nbCarac=0;
  665. }
  666.  
  667. if(nbCarac>n && reset!=1)
  668. {
  669. printf("max-line-numbers error line %d\n",numLine);
  670. reset=1;
  671. }
  672. }
  673. while (!feof(fichier));
  674. }
  675. else
  676. {
  677. printf("Impossible d'ouvrir le fichier test.txt");
  678.  
  679. }
  680. fclose(fichier);
  681.  
  682.  
  683. }
  684.  
  685. void maxFileLineNumbers(int n, char* fileName)
  686. {
  687. FILE *fichier;
  688. fichier=NULL;
  689. fichier = fopen(fileName,"rb");
  690. char caractereActuel;
  691. int numLine=1;
  692. int nbCarac=0;
  693. if (fichier != NULL)
  694. {
  695. do
  696. {
  697. caractereActuel = fgetc(fichier); // On lit le caractère
  698. nbCarac++;
  699. if(CARRIAGERETURN==caractereActuel)
  700. {
  701. numLine++;
  702. }
  703.  
  704. }
  705. while (!feof(fichier));
  706.  
  707.  
  708. if (numLine>n)
  709. {
  710. printf("error maxFileLineNumbers : %d lignes", numLine);
  711. }
  712. }
  713. else
  714. {
  715. printf("Impossible d'ouvrir le fichier test.txt");
  716.  
  717. }
  718. fclose(fichier);
  719.  
  720.  
  721. }
  722. void noTrailingSpaces(char* fileName)
  723. {
  724.  
  725. FILE *fichier;
  726. fichier=NULL;
  727. int cptError = 0;
  728. fichier = fopen(fileName,"rb");
  729. char caractereActuel;
  730. int numLine=1;
  731. if (fichier != NULL)
  732. {
  733. do
  734. {
  735. caractereActuel = fgetc(fichier); // On lit le caractère
  736. if(CARRIAGERETURN==caractereActuel)
  737. {
  738. numLine++;
  739. }
  740.  
  741. if(SPACE == caractereActuel)
  742. {
  743. cptError=1;
  744. }
  745.  
  746. else if(CARRIAGERETURN==caractereActuel)
  747. {
  748.  
  749. if(cptError==1)
  750. {
  751. printf("noTrailingSpaces error line %d\n",numLine);
  752. cptError=0;
  753. }
  754. }
  755.  
  756.  
  757. else if(SPACE!=caractereActuel)
  758. {
  759. cptError =0;
  760. }
  761.  
  762. }
  763. while (!feof(fichier));
  764. }
  765. else
  766. {
  767. //printf("\n Impossible d'ouvrir le fichier test.txt \n");
  768.  
  769. }
  770. fclose(fichier);
  771.  
  772.  
  773. }
  774.  
  775. void noMultiDeclaration(char* fileName)
  776. {
  777.  
  778. FILE *fichier;
  779. fichier=NULL;
  780. fichier = fopen(fileName,"rb");
  781. int i=0;
  782. int numLine=1;
  783. int checkCR=0;
  784. int fileSize=0;
  785. char *buffer;
  786.  
  787. if (fichier != NULL)
  788. {
  789. do
  790. {
  791. fgetc(fichier);
  792. fileSize++;
  793. }
  794. while (!feof(fichier));
  795.  
  796. buffer = malloc(sizeof(char) * fileSize);
  797. fseek(fichier, 0, SEEK_SET);
  798.  
  799. do
  800. {
  801. buffer[i] = fgetc(fichier);
  802. i++;
  803. }
  804. while (!feof(fichier));
  805.  
  806.  
  807. for(int i=0; i< fileSize; i++) //On fait un buffer sous forme de chaques caractères pour enregistrer chaques lignes
  808. {
  809.  
  810. //Debut du process pour trouver les types de variables
  811. if('t'==buffer[i] && 'r'==buffer[i-1] && 'o'==buffer[i-2] && 'h'==buffer[i-3] && 's'==buffer[i-4] && (' '==buffer[i-5] || CARRIAGERETURN==buffer[i-5]))
  812. {
  813. while (CARRIAGERETURN != buffer[i])
  814. {
  815. if(';'==buffer[i] || '('==buffer[i])
  816. {
  817. checkCR=1;
  818.  
  819. }
  820. if (','==buffer[i] && checkCR==0)
  821. {
  822. printf("no-multi-declaration error line %d\n",numLine);
  823. }
  824. i++;
  825. }
  826. checkCR=0;
  827. }
  828.  
  829.  
  830. if('e'==buffer[i] && 'l'==buffer[i-1] && 'b'==buffer[i-2] && 'u'==buffer[i-3] && 'o'==buffer[i] && 'd'==buffer[i-5] && (' '==buffer[i-6] || CARRIAGERETURN==buffer[i-6]))
  831. {
  832.  
  833. while (CARRIAGERETURN != buffer[i])
  834. {
  835. if(';'==buffer[i] || '('==buffer[i])
  836. {
  837. checkCR=1;
  838.  
  839. }
  840. if (','==buffer[i] && checkCR==0)
  841. {
  842. printf("no-multi-declaration error line %d\n",numLine);
  843. }
  844. i++;
  845. }
  846. checkCR=0;
  847. }
  848.  
  849.  
  850. if('t'==buffer[i] && 'n'==buffer[i-1] && 'i'==buffer[i-2] && (' '==buffer[i-3] || CARRIAGERETURN==buffer[i-3]))
  851. {
  852. while (CARRIAGERETURN != buffer[i])
  853. {
  854. if(';'==buffer[i] || '('==buffer[i])
  855. {
  856. checkCR=1;
  857.  
  858. }
  859. if (','==buffer[i] && checkCR==0)
  860. {
  861. printf("no-multi-declaration error line %d\n",numLine);
  862. }
  863. i++;
  864. }
  865. checkCR=0;
  866.  
  867. }
  868.  
  869.  
  870. if('t'==buffer[i] && 'a'==buffer[i-1] && 'o'==buffer[i-2] && 'l'==buffer[i-3] && 'f'==buffer[i-4] && (' '==buffer[i-5] || CARRIAGERETURN==buffer[i-5]))
  871. {
  872. while (CARRIAGERETURN != buffer[i])
  873. {
  874. if(';'==buffer[i] || '('==buffer[i])
  875. {
  876. checkCR=1;
  877.  
  878. }
  879. if (','==buffer[i] && checkCR==0)
  880. {
  881. printf("no-multi-declaration error line %d\n",numLine);
  882. }
  883. i++;
  884. }
  885. checkCR=0;
  886. }
  887.  
  888.  
  889. if('r'==buffer[i] && 'a'==buffer[i-1] && 'h'==buffer[i-2] && 'c'==buffer[i-3] && (' '==buffer[i-4] || CARRIAGERETURN==buffer[i-4]))
  890. {
  891.  
  892. while (CARRIAGERETURN != buffer[i])
  893. {
  894. if(';'==buffer[i] || '('==buffer[i])
  895. {
  896. checkCR=1;
  897.  
  898. }
  899. if (','==buffer[i] && checkCR==0)
  900. {
  901. printf("no-multi-declaration error line %d\n",numLine);
  902. }
  903. i++;
  904. }
  905. checkCR=0;
  906. }
  907.  
  908.  
  909. if('n'==buffer[i] && 'a'==buffer[i-1] && 'e'==buffer[i-2] && 'l'==buffer[i-3] && 'o'==buffer[i-4] && 'o'==buffer[i-5] && 'b'==buffer[i-6] && (' '==buffer[i-7] || CARRIAGERETURN==buffer[i-7]))
  910. {
  911. while (CARRIAGERETURN != buffer[i])
  912. {
  913. if(';'==buffer[i] || '('==buffer[i])
  914. {
  915. checkCR=1;
  916.  
  917. }
  918. if (','==buffer[i] && checkCR==0)
  919. {
  920. printf("no-multi-declaration error line %d\n",numLine);
  921. }
  922. i++;
  923. }
  924. numLine++;
  925. checkCR=0;
  926. }
  927.  
  928. if(CARRIAGERETURN==buffer[i])
  929. {
  930. numLine++;
  931. }
  932.  
  933. }
  934. }
  935. else
  936. {
  937. printf("Impossible d'ouvrir le fichier test.c");
  938.  
  939. }
  940. printf("%d",numLine);
  941. fclose(fichier);
  942. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!