Forum |  HardWare.fr | News | Articles | PC | S'identifier | S'inscrire | Shop Recherche
1546 connectés 

  FORUM HardWare.fr
  Programmation
  C

  compilateur

 
 


 Mot :   Pseudo :  
 
Bas de page
Auteur Sujet :

compilateur

n°2300944
bjs
Posté le 19-05-2017 à 21:34:39  profilanswer
 

Code :
  1. //<blocvar> ->  VAR<sdecl>FVAR
  2. //<sdecl> -> <decl> | <sdecle>,<decl>
  3. //<decl> -> i<chvar> = <nbrevar>
  4. //<nbrevar> -> <chvar> | <nbrevar><chvar>
  5. //<chvar> -> 0|1|2|3|4|5|6|7|8|9
  8. //<affectation> ? INSTR<sinstruction>SINSTR
  9. //<sinstruction> -> <intruction> | <sinstruction>,<instruction>
  10. //<instruction> -> i<chiffre> =  <oulogique>
  12. //<oulogique> -> <etlogique>| <oulogique> | <etlogique>
  13. //<etlogique> -> <PlusMoins>  | <etlogique> & <PlusMoins>
  14. // <plusmoins> ? <foisdiv> | <plusmoins> + <foisdiv> | <plusmoins> - <foisdiv>
  15. // <foisdiv> ? <opunaire> | <foisdiv> * <opunaire> | <foisdiv> / <opunaire>
  16. //<opunaire> -> <facteur> | - <facteur> | ~ <facteur> | + <facteur>
  17. // <facteur> ? <nombre> | ( <plusmoins> ) |  i<chiffre>
  18. //<nombre>-> <nombredeci> | 0b<nombrebin> | 0x<nombrehexa>
  19. //<nombrehexa> -> <chiffrehexa> | <nombrehexa><chiffrehexa>
  20. //<chiffrehexa> -> 0|1|2|3/4/5/6/7/8/9/A/B/C/D/E/F
  21. // <nombredeci> -> <chiffredeci> | <nombredeci><chiffredeci>
  22. // <Chiffre> -> 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
  23. // <nombrebin> -> <chiffrebin> | <nombrebin><chiffrebin>
  24. //<chiffrebin> -> 0 | 1
  28. #include <stdio.h>
  29. #include <ctype.h>
  30. #include <string.h>
  31. #include <stdlib.h>
  32. #include <stdio.h>
  33. #include <stdlib.h>
  34. //#include <unistd.h>
  35. //#include "SortieErreur.h"  
  36. void PlusMoins();
  37. void FoisDiv();
  38. void Facteur();
  39. void Nombre();
  40. int NombreDeci();
  41. int NombreBin();
  42. int ChiffreBin();
  43. int nombrehexa();
  44. int chiffrehexa();
  45. void CaractereSuivant();
  46. char CaractereCourant();
  47. void etlogique();
  48. void oulogique();
  49. void sinstruction();
  50. void instruction();
  51. void opunaire();
  52. void blocvar();
  53. void decl();
  54. void prog();
  55. int nbrevar();
  56. void sdecl();
  57. void affectation();
  58. char acExpr[500] ;
  59. // "VAR i1=3,i3=8 SVAR INSTR i1=i1*2,i3=i1+i1 SINSTR";//code source dans fichier source
  60.   // expression à compiler
  61. char bCourant = 0; // indice du caractère courant dans l'expression
  62. void main()
  63. {
  64. FILE     *hfF=NULL;
  67. if ((hfF = fopen("F:\\virton\\Bureau\\micro quadri 2\\compilateur\\compilateur\\expression.txt","r+" )) == NULL) 
  68. { printf("(Fichier1) Err. d'ouverture du fichier" ); 
  69. exit(1) ;
  70. }
  71. //fseek(hfF, SEEK_SET, 0);
  72. fread(acExpr,500,1,hfF);/*) != 1)   
  73. { printf("(Fichier14) Err. d'ouverture du fichier" );
  74. exit(1) ;  
  75. }*/
  76. printf("%s\n", &acExpr[0]);
  84. //oulogique(); // démarrer la compilation
  85. //
  86. blocvar();
  87. affectation();
  89. if (CaractereCourant() != 0)
  90.  printf("Le caractere %c a la position %d dans %s est invalide!",
  91.  acExpr[bCourant], bCourant + 1, acExpr);
  92. else
  93.  printf("La compilation s'est tres bien deroulee!" );
  94. fclose(hfF);
  95. }
  98. //<blocvar> VAR<sdecl>FVAR
  99. void blocvar()
  100. {
  101. if (strncmp(&acExpr[bCourant], "VAR",3) == 0)
  102. {
  103. // printf("\nint i%d =\n",CaractereCourant());
  104.  CaractereSuivant();
  105.  CaractereSuivant();
  106.  CaractereSuivant();
  108.  sdecl();
  110.  if (strncmp(&acExpr[bCourant], "SVAR",4) == 0)
  111.     {
  113.   CaractereSuivant();
  114.      CaractereSuivant();
  115.      CaractereSuivant();
  116.   CaractereSuivant();
  119.  }
  120. }
  123. }
  124. //<affectation> ? INSTR<sinstruction>SINSTR
  125. void affectation()
  126. {
  127. if (strncmp(&acExpr[bCourant], "INSTR", 5) == 0)
  128. {
  129.  printf("\nint main()\n{\n\t_asm\n\t{\n" );
  130.  CaractereSuivant();
  131.  CaractereSuivant();
  132.  CaractereSuivant();
  133.  CaractereSuivant();
  134.  CaractereSuivant();
  136.   sinstruction();
  138.  if (strncmp(&acExpr[bCourant], "SINSTR", 6) == 0)
  139.  {
  141.  CaractereSuivant();
  142.  CaractereSuivant();
  143.  CaractereSuivant();
  144.  CaractereSuivant();
  145.  CaractereSuivant();
  146.  CaractereSuivant();
  147.  printf("\n}\n}" );
  148.  }
  149. }
  150. }
  151. //<sinstruction> -> <intruction> | <sinstruction>,<instruction>
  152. void sinstruction()
  153. {
  154. instruction();
  155.  while ( CaractereCourant()== ',' )
  156.     {
  157.      
  158.             CaractereSuivant();
  159.   instruction();
  160.  }
  162. }
  163. //<sdecl> -> <decl> | <sdecl>,<decl>
  164. void sdecl()
  165. {
  166. decl();
  167.  while ( CaractereCourant()== ',' )
  168.     {
  169.      
  170.             CaractereSuivant();
  171.   decl();
  172.  }
  174. }
  175. //<instruction> -> i<chiffre> =  <oulogique>
  176. void instruction()
  177. {
  178. char nbre;
  179. if (CaractereCourant()== 'i')
  180. {
  181.  CaractereSuivant();
  184.  if(isdigit(CaractereCourant()))
  185.  {
  186.   //printf("\t\tpush i%d,eax\n", CaractereCourant());
  187.   nbre=CaractereCourant();
  188.   CaractereSuivant();
  190.   if(CaractereCourant()=='=')
  191.   {
  192.    CaractereSuivant();
  195.     oulogique();
  196.     printf("\t\tpop i%c\n",nbre);
  198.    // printf("\t\tmov i%c,eax\n",nbre);
  199.     //printf("push i1\npush 2\npop  ebx\npop  eax\nimul eax ebx \npush eax\n pop  i1\n" );
  201.         
  202.   }
  203.      }
  204. }
  206. }
  208. //<decl> -> i<chvar> = <nbrevar>
  210. void decl()
  211. {
  212.  char nbre;
  213. if (CaractereCourant()== 'i')
  214. {
  215.  printf("int i" );
  216.  CaractereSuivant();
  218.  if(isdigit(CaractereCourant()))
  219.  {
  220.   //printf("\t\tpush i%d,eax\n", CaractereCourant());
  221.   nbre=CaractereCourant();
  222.   printf("%c ",nbre);
  223.   CaractereSuivant();
  225.   if(CaractereCourant()=='=')
  226.   {
  227.    //printf("=%c\n",CaractereCourant());
  228.    CaractereSuivant();
  230.    printf("= %c;\n",CaractereCourant());
  231.     nbrevar();
  233.         
  234.   }
  235.      }
  236. }
  242. }
  243. // Cette fonction prend en compte les règles de grammaire:
  244. //<opunaire> -> <facteur> | - <facteur> | ~ <facteur> | + <facteur>
  247. void opunaire()
  248. {
  250.  switch(CaractereCourant())
  251.         {
  252.         case '~':
  253.   CaractereSuivant();
  254.            Facteur();
  255.            printf("pop eax\n" );
  256.     printf("not eax\n" );
  257.     printf("push eax\n" );
  258.             break;
  259.         case '-':
  260.   CaractereSuivant();
  261.             Facteur();
  262.            printf("pop eax\n" );
  263.     printf("imul eax,-1\n" );
  264.     printf("push eax\n" );
  265.     break;
  267.  case '+':
  268.   CaractereSuivant();
  269.   Facteur();
  270.   break;
  273.  default:
  274.   Facteur();
  275.   break;
  276. }
  277.    
  280. }
  281. // Cette fonction prend en compte les règles de grammaire:
  282. //<oulogique> -> <oulogique> | <etlogique>
  283. void oulogique()
  284. {
  285.  
  286. etlogique();
  287.     while ( CaractereCourant()== '|' )
  288.     {
  289.      
  290.             CaractereSuivant();
  291.   etlogique();
  292.    printf("\tpop ebx\n" );
  293.              printf("\tpop eax\n" );
  294.              printf("\tor eax, ebx\n" );
  295.              printf("\tpush eax\n" );
  297.         }
  298.    
  299.  
  300. }
  301. // Cette fonction prend en compte les règles de grammaire:
  302. //<etlogique> -> <etlogique> | <PlusMoins> & <PlusMoins>
  303. void etlogique()
  304. {
  305. PlusMoins();
  306. while( CaractereCourant()== '&' )
  307. {
  308.            CaractereSuivant();
  309.   PlusMoins();
  310.    printf("\tpop ebx\n" );
  311.              printf("\tpop eax\n" );
  312.              printf("\tand eax, ebx\n" );
  313.              printf("\tpush eax\n" );
  315. } 
  317. }
  319. // Cette fonction prend en compte les règles de grammaire:
  320. // <plusmoins> ? <foisdiv> | <plusmoins> + <foisdiv> | <plusmoins> - <foisdiv>
  321. void PlusMoins()
  322. {
  323. FoisDiv();
  324. while (CaractereCourant() == '+' || CaractereCourant() == '-')
  325. {
  326.  switch(CaractereCourant())
  327.  {
  328. case '+':
  329. CaractereSuivant();
  330. FoisDiv();
  331. printf("pop ebx\n" );
  332. printf("pop eax\n" );
  333. printf("add eax, ebx\n" );
  334. printf("push eax\n" );
  335. break;
  336. case '-':
  337. CaractereSuivant();
  338. FoisDiv();
  339. printf("pop ebx\n" );
  340. printf("pop eax\n" );
  341. printf("sub eax, ebx\n" );
  342. printf("push eax\n" );
  343.  }
  344. }
  346. }
  347. // Cette fonction prend en compte les règles de grammaire:
  348. // <foisdiv> ? <opunaire> | <foisdiv> * <opunaire> | <foisdiv> / <opunaire>
  349. void FoisDiv()
  350. {
  351. opunaire();
  352. while (CaractereCourant() == '*' || CaractereCourant() == '/')
  353. {
  354.  switch (CaractereCourant())
  355.  {
  356.  case '*':
  357.   CaractereSuivant();
  358.   opunaire();
  359.   printf("pop ebx\n" );
  360.   printf("pop eax\n" );
  361.   printf("imul eax, ebx\n" );
  362.   printf("push eax\n" );
  363.   break;
  364.  case '/':
  365.   CaractereSuivant();
  366.   opunaire();
  367.   printf("pop ebx\n" );
  368.   printf("pop eax\n" );
  369.   printf("cdq\n" );
  370.   printf("idiv ebx\n" );
  371.   printf("push eax\n" );
  372.  }
  373. }
  374. }
  377. // Cette fonction prend en compte les règles de grammaire:
  378. // <facteur> ? ( <plusmoins> ) | <nombre> | <nbrevar>
  379. void Facteur()
  380. {
  381. if (CaractereCourant() == '(')
  382. {
  383.  CaractereSuivant();
  384.  oulogique();
  385.  if (CaractereCourant() == ')')
  386.   CaractereSuivant();
  387. }
  388. else
  389. {
  391.  if (CaractereCourant()== 'i')
  392.  {
  394.   CaractereSuivant();
  396.   if(isdigit(CaractereCourant()))
  397.   {
  398.    printf("\t\tpush i%c\n", CaractereCourant());
  400.    CaractereSuivant();
  401.   }
  402.      }
  404. else
  405.  Nombre();
  406. }
  407. }
  408. // Cette fonction prend en compte les règles de grammaire:
  409. // <nombre> -> <nombredeci> | 0b<nombrebin>
  410. void Nombre()
  411. {
  412. if(strncmp(&acExpr[bCourant], "0b", 2) == 0)
  413. {
  414.  CaractereSuivant();
  415.  CaractereSuivant();
  416.  NombreBin();
  417. }
  418. if(strncmp(&acExpr[bCourant], "0x", 2) == 0)
  419. {
  420.  CaractereSuivant();
  421.  CaractereSuivant();
  422.  nombrehexa();
  424. } else
  425. {
  426.  NombreDeci();
  427. }
  428. }
  429. // Cette fonction prend en compte les règles de grammaire:
  430. // <nombredeci> -> <chiffredeci> | <nombredeci><chiffredeci>
  431. // <Chiffre> -> 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
  432. int NombreDeci()
  433. {
  434. int iVal = 0;
  435. if (isdigit(CaractereCourant()) != 0)
  436. {
  437.  while (isdigit(CaractereCourant()) != 0)
  438.   {
  439.   iVal = (iVal * 10) + (CaractereCourant() - 0x30);
  440.   CaractereSuivant();
  441.  }
  442.  printf("push %d\n", iVal);
  443. }
  444. return iVal;
  445. }
  446. //<nbrevar> -> <chvar> | <nbrevar><chvar>
  447. int nbrevar()
  448. {
  449. int iVal = 0;
  450. if (isdigit(CaractereCourant()) != 0)
  451. {
  452.  while (isdigit(CaractereCourant()) != 0)
  453.   {
  454.   iVal = (iVal * 10) + (CaractereCourant() - 0x30);
  455.   CaractereSuivant();
  456.  }
  457.  //printf("push %d\n", iVal);
  458. }
  459. return iVal;
  460. }
  461. // Cette fonction prend en compte les règles de grammaire:
  462. // <nombrebin> -> <chiffrebin> | <nombrebin><chiffrebin>
  463. int NombreBin()
  464. {
  465. int iVal = 0;
  466. if (ChiffreBin() != 0)
  467. {
  468.  while (ChiffreBin() != 0)
  469.  {
  470.   iVal = (iVal * 2) + (CaractereCourant() - 0x30);
  471.   CaractereSuivant();
  472.  }
  473.  printf("push %d\n", iVal);
  474. }
  475. return iVal;
  476. }
  477. // Cette fonction prend en compte les règles de grammaire:
  478. // <chiffrebin> -> 0 | 1
  479. int ChiffreBin()
  480. {
  481. if (CaractereCourant() == '0' || CaractereCourant() == '1')
  482.  return 1;
  483. else return 0;
  484. }
  485. // Cette fonction prend en compte les règles de grammaire:
  486. //<chiffrehexa> -> 0|1|2|3/4/5/6/7/8/9/A/B/C/D/E/F
  488. int chiffrehexa()
  489. {
  491. if((CaractereCourant() >= '0' && CaractereCourant() <= '9')|| (CaractereCourant() >= 'A' && CaractereCourant() <= 'F'))
  492.  return 1;
  493. else return 0;
  495. }
  496. // cette fonction prend en compte les règles de grammaire:
  497. //<nombre>-> <nombredeci> | 0b<nombrebin> | 0x<nombrehexa>
  498. //<nombrehexa> -> <chiffrehexa> | <nombrehexa><chiffrehexa>
  499. //<chiffrehexa> -> 0|1|2|3/4/5/6/7/8/9/A/B/C/D/E/F
  500. int nombrehexa()
  501. {
  502. int iVal=0;
  504. if(chiffrehexa() != 0)
  505. {
  506.  while(chiffrehexa() != 0)
  507.  {
  508. if(isdigit(CaractereCourant()))
  509. {
  510.  iVal=(iVal*16)+(CaractereCourant()-0x30);
  511.  CaractereSuivant();
  512. }
  514. else
  515. {
  516.  iVal=(iVal*16)+(CaractereCourant()-55);
  517.  CaractereSuivant();
  518. }
  519.  }
  522. printf("push %d\n", iVal);
  523. }
  524. return iVal;
  526. }
  527. // Cette fonction passe au caractère suivant dans l'expression
  528. void CaractereSuivant()
  529. {
  530. do
  531.  bCourant++;
  532. while (acExpr[bCourant] == ' '); // éliminer les espaces
  533. }
  534. // Cette fonction retourne le caractère courant de l'expression
  535. char CaractereCourant()
  536. {
  537. return acExpr[bCourant];
  538. }
  539. //mettre à jour hexa et chiffre héxa  >>>0x

Message cité 1 fois
Message édité par bjs le 20-05-2017 à 00:20:30
mood
Publicité
Posté le 19-05-2017 à 21:34:39  profilanswer
 

n°2300946
rat de com​bat
attention rongeur méchant!
Posté le 19-05-2017 à 22:20:48  profilanswer
 

bjs a écrit :

avec les fichier j'ai un souci

C'est à dire? "un soucis" c'est une très mauvaise description, il faut être précis. :o  
 
Il vient faire quoi ce fflush() ligne 66? :??:  
 
Ton appel de fread() + le if() c'est douteux, tu demandes 500*1 octets alors que d'après le commentaire ligne 59 le fichier en contient beaucoup moins, du coup ton code indique une erreur (avec le mauvais texte d'ailleurs).
Citation du K&R:

Citation :

size_t fread(void *ptr, size_t size, size_t nobj, FILE *stream)
fread reads from stream into the array ptr at most nobj objects of size size.
fread returns the number of objects read; this may be less than the number requested. feof and ferror must be used to determine status.


 
Aussi tu devrais activer les warnings de ton compilateur (ou les prendre en compte :o ):
(Attention les n° de lignes ne correspondent pas forcément à ton code!)

Citation :

> "gcc" "t2.c" -Wall -O3 -std=c99 -o "t2.exe"
t2.c:56:6: warning: return type of 'main' is not 'int' [-Wmain]
t2.c: In function 'main':
t2.c:83:16: warning: array subscript has type 'char' [-Wchar-subscripts]
t2.c: In function 'blocvar':
t2.c:95:5: warning: array subscript has type 'char' [-Wchar-subscripts]
t2.c:102:9: warning: array subscript has type 'char' [-Wchar-subscripts]
t2.c: In function 'affectation':
t2.c:114:5: warning: array subscript has type 'char' [-Wchar-subscripts]
t2.c:123:9: warning: array subscript has type 'char' [-Wchar-subscripts]
t2.c: In function 'Nombre':
t2.c:355:5: warning: array subscript has type 'char' [-Wchar-subscripts]
t2.c:361:5: warning: array subscript has type 'char' [-Wchar-subscripts]
t2.c: In function 'CaractereSuivant':
t2.c:467:5: warning: array subscript has type 'char' [-Wchar-subscripts]
t2.c: In function 'CaractereCourant':
t2.c:472:5: warning: array subscript has type 'char' [-Wchar-subscripts]

n°2300951
bjs
Posté le 20-05-2017 à 00:13:15  profilanswer
 

j'ai réedité le code ça marche maintenant

Message cité 1 fois
n°2300952
bjs
Posté le 20-05-2017 à 00:18:43  profilanswer
 

j'ai un seul warning dans mon visual c++ 2010 et on nous a dit d'ignorer ça et je pensais que fread retourne le nombre d'octets lus ??
1>f:\virton\bureau\micro quadri 2\ex1\ex1\exercice1.c(66): warning C4996: 'fopen': This function or variable may be unsafe. Consider using fopen_s instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. See online help for details.
1>          c:\program files (x86)\microsoft visual studio 10.0\vc\include\stdio.h(234) : voir la déclaration de 'fopen'


Message édité par bjs le 20-05-2017 à 00:20:01
n°2300985
rat de com​bat
attention rongeur méchant!
Posté le 20-05-2017 à 16:59:26  profilanswer
 

bjs a écrit :

j'ai réedité le code ça marche maintenant

C'est pas forcément une bonne idée de modifier ton message initial après-coup, ça peut prêter à confusion...
 
Aussi ta solution

Citation :

Code :
  1. //fseek(hfF, SEEK_SET, 0);
  2. fread(acExpr,500,1,hfF);/*) != 1)   
  3. { printf("(Fichier14) Err. d'ouverture du fichier" );
  4. exit(1) ;   
  5. }*/


c'est moche, tu as complètement viré le test plutôt que de le corriger et de faire quelque chose de propre (voir citation du K&R).

Citation :

j'ai un seul warning dans mon visual c++ 2010

alors ton compilateur est mal configuré! Les warnings ne sont pas là pour rien, il faut les activer et les prendre en compte!  
 
Par ailleurs attention aux "magic numbers": Ta taille de buffer (500) apparaît à deux endroits différents, si tu veux changer la valeur et tu oublies de modifier partout bonjour les ennuis. Utiliser des #define!
 
Je viens aussi de penser à un truc: Tu utilises fread() pour lire une chaîne de caractère, sauf que fread() c'est une fonction générique qui ne connaît pas cette notion et va donc pas terminer la chaîne lue par un '\0', ça peut créer des gros problèmes ça aussi. Si tu as un fichier texte qui remplit le buffer jusqu'à la derniere place je dirais que les appels strncmp() risquent de lire en dehors de la mémoire allouée sous certaines conditions, mais j'ai pas la tête suffisamment reposée à vrai dire pour y voir clair... À regarder de près.

Citation :

et on nous a dit d'ignorer ça

On vous a expliqué pourquoi aussi? (Non je ne sais pas, d'où ma question). Il ne faut jamais ignorer un warning à moins de savoir exactement ce qu'on fait.

Citation :

et je pensais que fread retourne le nombre d'octets lus ??

Voir citation du K&R. Ca retourne le nombre d'objets (pas forcément octets!!) lus. Regarde bien ton if() et la taille de ton fichier expression.txt, tu ne remarques rien?

n°2300989
bjs
Posté le 20-05-2017 à 18:15:17  profilanswer
 

je vais essayer de corriger une erreur à la fois  
je voudrais savoir si ce test de fread est juste ou pas ? ça marche chez moi et ça met pas le message d'erreur mais bon je suis pas sur du test ==-1
je pense que fread retourne le nombre d'enregistrements lus et pas le nombre d'octets lus  et comme mon enregistrement fait moins de 500 alors il retourne 0 ??????? si mon fichier faisait 500 octets alors le test se deroulerait bien ?  
 
if(fread(acExpr,500,1,hfF) != 1)  
{ printf("(Fichier14t) Err. d'ouverture du fichier" );
exit(1) ;  
}
// j'ai essayé comme ça et je vois que fread retourne 0 je comprends pas pourquoi pourtant j'ai modifié mon fichier texte et je vois que il est bien lu et il est mis dans le vecteur acExpr donc je comprends pas pourquoi ça marche sans test du fread et quand je mets un test ça marche plus
nbrad= fread(acExpr,500,1,hfF);
printf("%d\n",nbrad);
if (nbrad != 1)
{ printf("(Fichier14t) Err. d'ouverture du fichier" );
exit(1) ;  
}


Message édité par bjs le 20-05-2017 à 19:09:00
n°2300990
bjs
Posté le 20-05-2017 à 19:12:05  profilanswer
 

J'ai été voir la taille réelle du fichier et ça fait 40 octets maintenant. Le test fonctionne mais si j'avais fait une allocation dynamique ça aurait marché je pense??
 
nbrad= fread(acExpr,40,1,hfF);  
printf("%d\n",nbrad);  
if (nbrad != 1)  
{ printf("(Fichier14t) Err. d'ouverture du fichier" );  
exit(1) ;  
}

Message cité 1 fois
Message édité par bjs le 20-05-2017 à 20:36:50
n°2300991
rat de com​bat
attention rongeur méchant!
Posté le 20-05-2017 à 19:12:26  profilanswer
 

Merci de faire un effort au niveau lisibilité: Mettre le code entre balises et faire des phrases qui commencent avec une majuscule et se terminent par un point (ou un point d'interrogation).
 
Oui fread() retourne le nombre d'enregistrements (si on veut appeller ça comme ça) lus, je l'ai dit et c'est très clair dans la citation du K&R. Après ton code montre que tu n'as pas encore bien compris. Juste pour lever un doute, tu comprends l'anglais?
 
Refléchis tranquillement: Quelle est la taille de ton fichier? Que retourne donc fread()? Quel sera donc le résultat du test fread(...)!=1 ? Avant de modifier ton test, pense au fait que ton fichier peut avoir une autre taille. C'est vraiment pas bien compliqué cette histoire. Si on veut vraiment bien faire il faut regarder feof() et ferror(), sinon un simple if(fread(...) ...) avec la bonne condition (que je ne te donnes pas car c'est toi qui doit apprendre) peut suffir.
 
Par ailleurs ton message d'erreur est toujours faux, fread() n'ouvre pas le fichier mais lit le contenu.
 
>vecteur acExpr
Ce n'est pas un vecteur mais un tableau. Il est très important d'utiliser les bon termes (dés le début quand on apprend encore histoire de ne pas créer de mauvaises habitudes) pour éviter les malentendus!
 
EDIT:

bjs a écrit :

j'ai été voir la taille du fichier et ça fait 40 octets maintenant le test fonctionne

Modifie donc ton ficher, p.ex. en changeant le "code" à l'intérieur ou en rajoutant un simple espace et relance ton programme...


Message édité par rat de combat le 20-05-2017 à 19:13:57
n°2300994
bjs
Posté le 20-05-2017 à 19:24:14  profilanswer
 

Je devrais faire une allocation dynamique ? pour que ça marche quelque soit la taille ? et je mets sizeof?


Message édité par bjs le 20-05-2017 à 20:26:05
n°2300995
bjs
Posté le 20-05-2017 à 20:13:47  profilanswer
 

Je voudrais faire une allocation dynamique, comme ça quelque soit la taille du fichier, ça sera ecrit dans acExpr. J'ai modifié le code mais ça ne marche pas et je dois surement avoir une petite erreur. Le ftell me retourne une bonne valeur pour la taille du fichier.  
 

Code :
  1. char *acExpr ;
  2. int nbenreg=0;
  3. // "VAR i1=3,i3=8 SVAR INSTR i1=i1*2,i3=i1+i1 SINSTR";//code source dans fichier source
  4.   // expression à compiler
  5. char bCourant = 0;
  6. int nbrad=0;
  7. // indice du caractère courant dans l'expression
  8. void main()
  9. {
  10. FILE*hfF=NULL;
  12. if ((hfF = fopen("F:\\virton\\Bureau\\micro quadri 2\\compilateur\\compilateur\\expression.txt","r+" )) == NULL) 
  13. {
  14. printf("(Fichier1) Err. d'ouverture du fichier" ); 
  15.     exit(1) ;
  16. }
  17. /*je test avec ftell la taille du fichier.
  18. Je declare un maloc de la taille, ensuit je passe
  19. l'adr du maloc a fread et je lis tout le fichier en un fois
  20. et je passe l adr a acexpr */
  21. fseek(hfF,0,SEEK_END);
  22. nbenreg= ftell(hfF)/sizeof(char);
  23. printf("nbenre=%d\n",nbenreg);
  24. acExpr=(char*) malloc(nbenreg);
  26. nbrad= fread(acExpr,nbenreg,1,hfF);
  27. printf("nbrad = %d\n",nbrad);
  28. if (nbrad != 1)
  29. { printf("(Fichier14t) Err. de lecture du fichier" );
  30. exit(1) ; 
  31. }
  32. printf("%s\n", &acExpr[0]);


Message édité par bjs le 20-05-2017 à 20:43:55
mood
Publicité
Posté le 20-05-2017 à 20:13:47  profilanswer
 

n°2300996
rat de com​bat
attention rongeur méchant!
Posté le 20-05-2017 à 20:15:38  profilanswer
 

Citation :

Merci de faire un effort au niveau lisibilité: Mettre le code entre balises et faire des phrases qui commencent avec une majuscule et se terminent par un point (ou un point d'interrogation).

(éditer ta réponse précédente)

n°2300998
rat de com​bat
attention rongeur méchant!
Posté le 20-05-2017 à 20:49:04  profilanswer
 

>fseek(hfF,0,SEEK_END)
Il faut revenir au début du fichier ensuite si tu veux lire quelque chose...
 
Il y a plusieurs d'autres trucs dans ton code qu'on peut critiquer, mais je ne veux pas faire ton boulot. Juste une chose, ton commentaire "je test avec ftell ..." c'est n'importe quoi. ftell() ne teste rien du tout, la fonction malloc qui prend deux 'L' par ailleurs est déclarée dans je ne sais quel header standard, toi tu l'utilises, tu ne passes pas l'adresse de malloc à fread ni à acExpr qui en plus est une variable alors qu'on passe des arguments (p.ex. des adresses) à des fonctions.  
Non, ce n'est pas de la méchanceté de ma part, il est très important de s'exprimer correctement pour éviter les malentendus et surtout pour un débutant histoire de ne pas prendre de mauvaises habitudes et bien comprendre les bases.

n°2301000
bjs
Posté le 20-05-2017 à 20:59:11  profilanswer
 

Merci pour ton aide, tu es un pro. Le programme se compile bien et ça fait les bonnes instructions en assembleur mais j'ai des caractères qui se sont "introduits" à la fin de mon fichier... Je ne comprends pas d'où viennent ces caractères ; ç'est un exposant deux, quatre fois de suite, à la fin du fichier que j'ai crée et pourtant ils sont invisibles. Est ce que je dois rajouter un caractère 0 ? et comment ou bien à quel endroit du code je dois rajouter ce caractère 0 ?

Message cité 1 fois
n°2301002
rat de com​bat
attention rongeur méchant!
Posté le 20-05-2017 à 21:06:51  profilanswer
 

bjs a écrit :

Merci pour ton aide, tu es un pro.

Oh non, loin de là!

Citation :

Le programme se compile bien

Tu as activé les warnings et corrigé ces derniers aussi?

Citation :

j'ai des caractères qui se sont "introduits" à la fin de mon fichier... Je ne comprends pas d'où viennent ces caractères ; ç'est un exposant deux, quatre fois de suite, à la fin du fichier que j'ai crée et pourtant ils sont invisibles. Est ce que je dois rajouter un caractère 0 ? et comment ou bien à quel endroit du code je dois rajouter ce caractère 0 ?

Où est-ce que tu vois ces caractères exactement?
Laisse moi deviner: C'est sur l'écran au moment du printf("%s\n", &acExpr[0]); c'est ça? Qu'est ce que je disais plus haut concernant fread() et les chaînes de caractères? Le '\0' c'est la bonne piste.

n°2301003
bjs
Posté le 20-05-2017 à 21:30:10  profilanswer
 

J'ai essayé plusieurs fois de rajouter un caractère '\0' de fin mais je ne sais pas en fait où je dois faire ça. Mon programme bug quand je rajoute un caractère zéro et je sais pas comment le faire ni où le faire.


Message édité par bjs le 20-05-2017 à 21:38:15
n°2301004
rat de com​bat
attention rongeur méchant!
Posté le 20-05-2017 à 21:40:25  profilanswer
 

Essayer au pif c'est pas la bonne solution.
Qu'est-ce que c'est qu'une chaîne de caractère en C? Exact, un tableau avec des codes ASCII et '\0' en dernière position.
Donc si j'ai char str[]="hardware"; en mémoire je vais avoir (quelque part, peu importe l'adresse) une suite d'octets: 104 97 114 100 119 97 114 101 0 (en supposant '\0' == 0). Dans ton code c'est fread qui s'occupe de remplir ton tableau quelque part en mémoire.
 
Donc il faut mettre le '\0' où dans le code et où en mémoire?

n°2301005
bjs
Posté le 20-05-2017 à 21:50:52  profilanswer
 

Je ne sais pas; là je vois pas.

n°2301006
bjs
Posté le 20-05-2017 à 22:25:45  profilanswer
 

Est ce que ça marcherait si je modifie cette fonction ? je rajoute le caractère zéro après INSTR.
//<affectation> ? INSTR<sinstruction>SINSTR

Code :
  1. void affectation()
  2. {
  3. if (strncmp(&acExpr[bCourant], "INSTR", 5) == 0)
  4. {
  5.  printf("\nint main()\n{\n\t_asm\n\t{\n" );
  6.  CaractereSuivant();
  7.  CaractereSuivant();
  8.  CaractereSuivant();
  9.  CaractereSuivant();
  10.  CaractereSuivant();
  12.   sinstruction();
  14.  if (strncmp(&acExpr[bCourant], "SINSTR", 6) == 0)
  15.  {
  17.  CaractereSuivant();
  18.  CaractereSuivant();
  19.  CaractereSuivant();
  20.  CaractereSuivant();
  21.  CaractereSuivant();
  22.  CaractereSuivant();
  23.  acExpr[bCourant]=0;
  26.  printf("\n}\n}" );
  27.  }
  28. }
  29. }


Message édité par bjs le 20-05-2017 à 22:28:25
n°2301008
rat de com​bat
attention rongeur méchant!
Posté le 20-05-2017 à 22:48:26  profilanswer
 

Mais non, c'est pourtant evident, il faut rajouter le '\0' à la fin de acExpr (attention, il faut la place pour!) après le fread()!

n°2301009
bjs
Posté le 20-05-2017 à 23:06:52  profilanswer
 

Comme ça ?

Code :
  1. fseek(hfF,0,SEEK_END);
  2. nbenreg= ftell(hfF)/sizeof(char);
  3. printf("nbenre=%d\n",nbenreg);
  5. acExpr= (char*) malloc (nbenreg+1);
  7. fseek(hfF,0,SEEK_SET);
  10. nbrad= fread(acExpr,nbenreg,1,hfF);
  11. acExpr[nbenreg]=0;
  13. printf("nbrad = %d\n",nbrad);


Message édité par bjs le 20-05-2017 à 23:11:14
n°2301011
rat de com​bat
attention rongeur méchant!
Posté le 20-05-2017 à 23:26:52  profilanswer
 

à première vue c'est bon.

n°2301012
bjs
Posté le 20-05-2017 à 23:35:02  profilanswer
 

Mettre à jour le compilateur pour qu'il puisse lire le programme source depuis un fichier et écrire le programme en assembleur dans un autre fichier dont l'extension est .c  
 
ah ok j'ai compris je dois mettre des fprintf comme ça ça copie mes instructions assembleur dans un fichier que je declare en global ???
J'ai aussi rajouté des lignes pour fermer le fichier et libérer la mémoire à la fin du main.
fclose(hfF);
free(acExpr);
acExpr=NULL;


Message édité par bjs le 21-05-2017 à 00:07:54
n°2301014
bjs
Posté le 21-05-2017 à 01:12:33  profilanswer
 

J'ai modifié juste les printf en fprintf pour copier mon code assembleur généré dans un fichier que j'ai crée en .c et j'ai déclaré un pointeur de fichier en global.
Si tu as le temps tu peux jeter un coup d'oeil, mais je pense que ça marche car j'ai compilé, puis j'ai vu que ça chargeait bien le code assembleur dans le fichier.c que j'ai crée et puis j'ai recompilé et regardé en debogeur pour voir si ça mettait les bon calculs et ç'était ok.
Quelques messages avant celui ci tu m'a écrit : "Il y a plusieurs d'autres trucs dans ton code qu'on peut critiquer, mais je ne veux pas faire ton boulot."
Je voudrais savoir quelles choses sont pas bien dans mon code. Merci de me dire quoi. Je voudrais savoir aussi comment activer les warnings sur visual c++ 2010. J'ai déjà des warnings mais peut être qu'il y a un level supérieur en warnings ??
J'ai mis enable all warnings et ça me rien de spécial en warnings à par ce même warning pour toutes mes fonctions=>
1>f:\virton\bureau\micro quadri 2\ex1\ex1\exercice1.c(453): warning C4255: 'Nombre' : aucun prototype de fonction fourni : conversion de '()' en '(void)'
 

Code :
  1. //<blocvar> ->  VAR<sdecl>FVAR
  2. //<sdecl> -> <decl> | <sdecle>,<decl>
  3. //<decl> -> i<chvar> = <nbrevar>
  4. //<nbrevar> -> <chvar> | <nbrevar><chvar>
  5. //<chvar> -> 0|1|2|3|4|5|6|7|8|9
  8. //<affectation> ? INSTR<sinstruction>SINSTR
  9. //<sinstruction> -> <intruction> | <sinstruction>,<instruction>
  10. //<instruction> -> i<chiffre> =  <oulogique>
  12. //<oulogique> -> <etlogique>| <oulogique> | <etlogique>
  13. //<etlogique> -> <PlusMoins>  | <etlogique> & <PlusMoins>
  14. // <plusmoins> ? <foisdiv> | <plusmoins> + <foisdiv> | <plusmoins> - <foisdiv>
  15. // <foisdiv> ? <opunaire> | <foisdiv> * <opunaire> | <foisdiv> / <opunaire>
  16. //<opunaire> -> <facteur> | - <facteur> | ~ <facteur> | + <facteur>
  17. // <facteur> ? <nombre> | ( <plusmoins> ) |  i<chiffre>
  18. //<nombre>-> <nombredeci> | 0b<nombrebin> | 0x<nombrehexa>
  19. //<nombrehexa> -> <chiffrehexa> | <nombrehexa><chiffrehexa>
  20. //<chiffrehexa> -> 0|1|2|3/4/5/6/7/8/9/A/B/C/D/E/F
  21. // <nombredeci> -> <chiffredeci> | <nombredeci><chiffredeci>
  22. // <Chiffre> -> 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
  23. // <nombrebin> -> <chiffrebin> | <nombrebin><chiffrebin>
  24. //<chiffrebin> -> 0 | 1
  28. #include <stdio.h>
  29. #include <ctype.h>
  30. #include <string.h>
  31. #include <stdlib.h>
  32. #include <stdio.h>
  33. #include <stdlib.h>
  34. //#include <unistd.h>
  35. //#include "SortieErreur.h"  
  36. void PlusMoins();
  37. void FoisDiv();
  38. void Facteur();
  39. void Nombre();
  40. int NombreDeci();
  41. int NombreBin();
  42. int ChiffreBin();
  43. int nombrehexa();
  44. int chiffrehexa();
  45. void CaractereSuivant();
  46. char CaractereCourant();
  47. void etlogique();
  48. void oulogique();
  49. void sinstruction();
  50. void instruction();
  51. void opunaire();
  52. void blocvar();
  53. void decl();
  54. void prog();
  55. int nbrevar();
  56. void sdecl();
  57. void affectation();
  58. char *acExpr ;
  59. int taillefichier=0;
  60. FILE* hfich=NULL;
  61. // "VAR i1=3,i3=8 SVAR INSTR i1=i1*2,i3=i1+i1 SINSTR";//code source dans fichier source
  62.   // expression à compiler
  63. char bCourant = 0;
  64. int nbretourread=0;
  65. // indice du caractère courant dans l'expression
  66. void main()
  67. {
  68. FILE*hfF=NULL;
  70. if ((hfF = fopen("F:\\virton\\Bureau\\micro quadri 2\\ex1\\expression.txt","r+" )) == NULL)  //"F:\\virton\\Bureau\\micro quadri 2\\compilateur\\compilateur\\expression.txt","r+" )) == NULL)   
  71. {
  72. printf("(Fichier1) Err. d'ouverture du fichier" ); 
  73.     exit(1) ;
  74. }
  76. fseek(hfF,0,SEEK_END);
  77. taillefichier= ftell(hfF)/sizeof(char);
  78. printf("//taillefichier=%d\n",taillefichier);
  80. acExpr= (char*) malloc (taillefichier+1);
  81. if(acExpr==NULL)
  82. {
  83. printf("Erreur d'allocation dynamique" );
  85. }
  87. fseek(hfF,0,SEEK_SET);
  90. nbretourread= fread(acExpr,taillefichier,1,hfF);
  91. acExpr[taillefichier]='\0';
  93. printf("//nbrretourread = %d\n",nbretourread);  
  94. if (nbretourread != 1)
  95. { printf("(Fichier14t) Err. de lecture du fichier" );
  96. exit(1) ; 
  97. }
  98. printf("//%s\n", &acExpr[0]);
  99. // démarrer la compilation
  100. //
  101. if ((hfich = fopen("F:\\virton\\Bureau\\micro quadri 2\\ex1\\fichier.c","w" )) == NULL)  //"F:\\virton\\Bureau\\micro quadri 2\\compilateur\\compilateur\\expression.txt","r+" )) == NULL)   
  102. {
  103. printf("(Fichier1) Err. d'ouverture du fichier" ); 
  104.     exit(1) ;
  105. }
  106. blocvar();
  107. affectation();
  109. if (CaractereCourant() != 0)
  110.  printf("Le caractere %c a la position %d dans %s est invalide!",
  111.  acExpr[bCourant], bCourant + 1, acExpr);
  112. else
  113.  printf("La compilation s'est bien deroulee!" );
  115. fclose(hfF);
  116. free(acExpr);
  117. acExpr=NULL;
  118. }
  121. //<blocvar> VAR<sdecl>FVAR
  122. void blocvar()
  123. {
  124. if (strncmp(&acExpr[bCourant], "VAR",3) == 0)
  125. {
  127.  CaractereSuivant();
  128.  CaractereSuivant();
  129.  CaractereSuivant();
  131.  sdecl();
  133.  if (strncmp(&acExpr[bCourant], "SVAR",4) == 0)
  134.     {
  136.   CaractereSuivant();
  137.      CaractereSuivant();
  138.      CaractereSuivant();
  139.   CaractereSuivant();
  142.  }
  143. }
  146. }
  147. //<affectation> ? INSTR<sinstruction>SINSTR
  148. void affectation()
  149. {
  150. if (strncmp(&acExpr[bCourant], "INSTR", 5) == 0)
  151. {
  152.  //printf("\nint main()\n{\n\t_asm\n\t{\n" );
  153.  fprintf(hfich,"\nint main()\n{\n\t_asm\n\t{\n" );
  154.  CaractereSuivant();
  155.  CaractereSuivant();
  156.  CaractereSuivant();
  157.  CaractereSuivant();
  158.  CaractereSuivant();
  160.   sinstruction();
  162.  if (strncmp(&acExpr[bCourant], "SINSTR", 6) == 0)
  163.  {
  165.  CaractereSuivant();
  166.  CaractereSuivant();
  167.  CaractereSuivant();
  168.  CaractereSuivant();
  169.  CaractereSuivant();
  170.  CaractereSuivant();
  173.  //printf("\n}\n}" );
  174.  fprintf(hfich,"\n}\n}" );
  175.  }
  176. }
  177. }
  178. //<sinstruction> -> <intruction> | <sinstruction>,<instruction>
  179. void sinstruction()
  180. {
  181. instruction();
  182.  while ( CaractereCourant()== ',' )
  183.     {
  184.      
  185.             CaractereSuivant();
  186.   instruction();
  187.  }
  189. }
  190. //<sdecl> -> <decl> | <sdecl>,<decl>
  191. void sdecl()
  192. {
  193. decl();
  194.  while ( CaractereCourant()== ',' )
  195.     {
  196.      
  197.             CaractereSuivant();
  198.   decl();
  199.  }
  201. }
  202. //<instruction> -> i<chiffre> =  <oulogique>
  203. void instruction()
  204. {
  205. char nbre;
  206. if (CaractereCourant()== 'i')
  207. {
  208.  CaractereSuivant();
  211.  if(isdigit(CaractereCourant()))
  212.  {
  213.   //printf("\t\tpush i%d,eax\n", CaractereCourant());
  214.   nbre=CaractereCourant();
  215.   CaractereSuivant();
  217.   if(CaractereCourant()=='=')
  218.   {
  219.    CaractereSuivant();
  222.     oulogique();
  223.     fprintf(hfich,"\t\tpop i%c\n",nbre);
  224.     //printf("\t\tpop i%c\n",nbre);
  226.    // printf("\t\tmov i%c,eax\n",nbre);
  227.     //printf("push i1\npush 2\npop  ebx\npop  eax\nimul eax ebx \npush eax\n pop  i1\n" );
  229.         
  230.   }
  231.      }
  232. }
  234. }
  236. //<decl> -> i<chvar> = <nbrevar>
  238. void decl()
  239. {
  240.  char nbre;
  241. if (CaractereCourant()== 'i')
  242. {
  243.  //printf("int i" );
  244.  fprintf(hfich,"int i" );
  245.  CaractereSuivant();
  247.  if(isdigit(CaractereCourant()))
  248.  {
  250.   nbre=CaractereCourant();
  251.   //printf("%c ",nbre);
  252.   fprintf(hfich,"%c ",nbre);
  253.   CaractereSuivant();
  255.   if(CaractereCourant()=='=')
  256.   {
  258.    CaractereSuivant();
  260.    //printf("= %c;\n",CaractereCourant());
  261.    fprintf(hfich,"= %c;\n",CaractereCourant());
  262.     nbrevar();
  264.         
  265.   }
  266.      }
  267. }
  273. }
  274. // Cette fonction prend en compte les règles de grammaire:
  275. //<opunaire> -> <facteur> | - <facteur> | ~ <facteur> | + <facteur>
  278. void opunaire()
  279. {
  281.  switch(CaractereCourant())
  282.         {
  283.         case '~':
  284.   CaractereSuivant();
  285.            Facteur();
  286.           // printf("pop eax\n" );
  287.    // printf("not eax\n" );
  288.    // printf("push eax\n" );
  289.     fprintf(hfich,"pop eax\nnot eax\npush eax\n" );
  290.             break;
  291.         case '-':
  292.   CaractereSuivant();
  293.             Facteur();
  294.            //printf("pop eax\n" );
  295.   //  printf("imul eax,-1\n" );
  296.    // printf("push eax\n" );
  297.     fprintf(hfich,"pop eax\nimul eax,-1\npush eax\n" );
  298.     break;
  300.  case '+':
  301.   CaractereSuivant();
  302.   Facteur();
  303.   break;
  306.  default:
  307.   Facteur();
  308.   break;
  309. }
  310.    
  313. }
  314. // Cette fonction prend en compte les règles de grammaire:
  315. //<oulogique> -> <oulogique> | <etlogique>
  316. void oulogique()
  317. {
  318.  
  319. etlogique();
  320.     while ( CaractereCourant()== '|' )
  321.     {
  322.      
  323.             CaractereSuivant();
  324.   etlogique();
  325.   // printf("pop ebx\n" );
  326.             // printf("pop eax\n" );
  327.            //  printf("or eax, ebx\n" );
  328.             // printf("push eax\n" );
  329.   fprintf(hfich,"pop ebx\npop eax\nor eax, ebx\npush eax\n" );
  331.         }
  332.    
  333.  
  334. }
  335. // Cette fonction prend en compte les règles de grammaire:
  336. //<etlogique> -> <etlogique> | <PlusMoins> & <PlusMoins>
  337. void etlogique()
  338. {
  339. PlusMoins();
  340. while( CaractereCourant()== '&' )
  341. {
  342.            CaractereSuivant();
  343.   PlusMoins();
  344.   // printf("\tpop ebx\n" );
  345.             // printf("\tpop eax\n" );
  346.            //  printf("\tand eax, ebx\n" );
  347.             // printf("\tpush eax\n" );
  348.    fprintf(hfich,"pop ebx\npop eax\and eax, ebx\npush eax\n" );
  349. } 
  351. }
  353. // Cette fonction prend en compte les règles de grammaire:
  354. // <plusmoins> ? <foisdiv> | <plusmoins> + <foisdiv> | <plusmoins> - <foisdiv>
  355. void PlusMoins()
  356. {
  357. FoisDiv();
  358. while (CaractereCourant() == '+' || CaractereCourant() == '-')
  359. {
  360.  switch(CaractereCourant())
  361.  {
  362. case '+':
  363. CaractereSuivant();
  364. FoisDiv();
  365. // printf("pop ebx\n" );
  366. // printf("pop eax\n" );
  367. // printf("add eax, ebx\n" );
  368. // printf("push eax\n" );
  369. fprintf(hfich,"pop ebx\npop eax\nadd eax, ebx\npush eax\n" );
  370. break;
  371. case '-':
  372. CaractereSuivant();
  373. FoisDiv();
  374. // printf("pop ebx\n" );
  375. // printf("pop eax\n" );
  376. // printf("sub eax, ebx\n" );
  377. // printf("push eax\n" );
  378. fprintf(hfich,"pop ebx\npop eax\nsub eax, ebx\npush eax\n" );
  379.  }
  380. }
  382. }
  383. // Cette fonction prend en compte les règles de grammaire:
  384. // <foisdiv> ? <opunaire> | <foisdiv> * <opunaire> | <foisdiv> / <opunaire>
  385. void FoisDiv()
  386. {
  387. opunaire();
  388. while (CaractereCourant() == '*' || CaractereCourant() == '/')
  389. {
  390.  switch (CaractereCourant())
  391.  {
  392.  case '*':
  393.   CaractereSuivant();
  394.   opunaire();
  395. //  printf("pop ebx\n" );
  396. //  printf("pop eax\n" );
  397. //  printf("imul eax, ebx\n" );
  398. //  printf("push eax\n" );
  399.   fprintf(hfich,"pop ebx\npop eax\nimul eax, ebx\npush eax\n" );
  400.   break;
  401.  case '/':
  402.   CaractereSuivant();
  403.   opunaire();
  404.  // printf("pop ebx\n" );
  405.  // printf("pop eax\n" );
  406.  // printf("cdq\n" );
  407.  // printf("idiv ebx\n" );
  408.  // printf("push eax\n" );
  409.   fprintf(hfich,"pop ebx\npop eax\ncdq\nidiv ebx\npush eax\n" );
  410.  }
  411. }
  412. }
  415. // Cette fonction prend en compte les règles de grammaire:
  416. // <facteur> ? ( <plusmoins> ) | <nombre> | <nbrevar>
  417. void Facteur()
  418. {
  419. if (CaractereCourant() == '(')
  420. {
  421.  CaractereSuivant();
  422.  oulogique();
  423.  if (CaractereCourant() == ')')
  424.   CaractereSuivant();
  425. }
  426. else
  427. {
  429.  if (CaractereCourant()== 'i')
  430.  {
  432.   CaractereSuivant();
  434.   if(isdigit(CaractereCourant()))
  435.   {
  436.    //printf("push i%c\n", CaractereCourant());
  437.    fprintf(hfich,"push i%c\n", CaractereCourant());
  439.    CaractereSuivant();
  440.   }
  441.      }
  443. else
  444.  Nombre();
  445. }
  446. }
  447. // Cette fonction prend en compte les règles de grammaire:
  448. // <nombre> -> <nombredeci> | 0b<nombrebin>
  449. void Nombre()
  450. {
  451. if(strncmp(&acExpr[bCourant], "0b", 2) == 0)
  452. {
  453.  CaractereSuivant();
  454.  CaractereSuivant();
  455.  NombreBin();
  456. }
  457. if(strncmp(&acExpr[bCourant], "0x", 2) == 0)
  458. {
  459.  CaractereSuivant();
  460.  CaractereSuivant();
  461.  nombrehexa();
  463. } else
  464. {
  465.  NombreDeci();
  466. }
  467. }
  468. // Cette fonction prend en compte les règles de grammaire:
  469. // <nombredeci> -> <chiffredeci> | <nombredeci><chiffredeci>
  470. // <Chiffre> -> 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
  471. int NombreDeci()
  472. {
  473. int iVal = 0;
  474. if (isdigit(CaractereCourant()) != 0)
  475. {
  476.  while (isdigit(CaractereCourant()) != 0)
  477.   {
  478.   iVal = (iVal * 10) + (CaractereCourant() - 0x30);
  479.   CaractereSuivant();
  480.  }
  481.  //printf("push %d\n", iVal);
  482. // fprintf(hfich,"push %d\n", iVal);
  483. }
  484. return iVal;
  485. }
  486. //<nbrevar> -> <chvar> | <nbrevar><chvar>
  487. int nbrevar()
  488. {
  489. int iVal = 0;
  490. if (isdigit(CaractereCourant()) != 0)
  491. {
  492.  while (isdigit(CaractereCourant()) != 0)
  493.   {
  494.   iVal = (iVal * 10) + (CaractereCourant() - 0x30);
  495.   CaractereSuivant();
  496.  }
  497.  //printf("push %d\n", iVal);
  498.  //fprintf(hfich,"push %d\n", iVal);
  499. }
  500. return iVal;
  501. }
  502. // Cette fonction prend en compte les règles de grammaire:
  503. // <nombrebin> -> <chiffrebin> | <nombrebin><chiffrebin>
  504. int NombreBin()
  505. {
  506. int iVal = 0;
  507. if (ChiffreBin() != 0)
  508. {
  509.  while (ChiffreBin() != 0)
  510.  {
  511.   iVal = (iVal * 2) + (CaractereCourant() - 0x30);
  512.   CaractereSuivant();
  513.  }
  514.  //printf("push %d\n", iVal);
  515.  fprintf(hfich,"push %d\n", iVal);
  516. }
  517. return iVal;
  518. }
  519. // Cette fonction prend en compte les règles de grammaire:
  520. // <chiffrebin> -> 0 | 1
  521. int ChiffreBin()
  522. {
  523. if (CaractereCourant() == '0' || CaractereCourant() == '1')
  524.  return 1;
  525. else return 0;
  526. }
  527. // Cette fonction prend en compte les règles de grammaire:
  528. //<chiffrehexa> -> 0|1|2|3/4/5/6/7/8/9/A/B/C/D/E/F
  530. int chiffrehexa()
  531. {
  533. if((CaractereCourant() >= '0' && CaractereCourant() <= '9')|| (CaractereCourant() >= 'A' && CaractereCourant() <= 'F'))
  534.  return 1;
  535. else return 0;
  537. }
  538. // cette fonction prend en compte les règles de grammaire:
  539. //<nombre>-> <nombredeci> | 0b<nombrebin> | 0x<nombrehexa>
  540. //<nombrehexa> -> <chiffrehexa> | <nombrehexa><chiffrehexa>
  541. //<chiffrehexa> -> 0|1|2|3/4/5/6/7/8/9/A/B/C/D/E/F
  542. int nombrehexa()
  543. {
  544. int iVal=0;
  546. if(chiffrehexa() != 0)
  547. {
  548.  while(chiffrehexa() != 0)
  549.  {
  550. if(isdigit(CaractereCourant()))
  551. {
  552.  iVal=(iVal*16)+(CaractereCourant()-0x30);
  553.  CaractereSuivant();
  554. }
  556. else
  557. {
  558.  iVal=(iVal*16)+(CaractereCourant()-55);
  559.  CaractereSuivant();
  560. }
  561.  }
  564. //printf("push %d\n", iVal);
  565.  fprintf(hfich,"push %d\n", iVal);
  566. }
  567. return iVal;
  569. }
  570. // Cette fonction passe au caractère suivant dans l'expression
  571. void CaractereSuivant()
  572. {
  573. do
  574.  bCourant++;
  575. while (acExpr[bCourant] == ' '); // éliminer les espaces
  576. }
  577. // Cette fonction retourne le caractère courant de l'expression
  578. char CaractereCourant()
  579. {
  580. return acExpr[bCourant];
  581. }

Message cité 1 fois
Message édité par bjs le 21-05-2017 à 11:51:32
n°2301020
rat de com​bat
attention rongeur méchant!
Posté le 21-05-2017 à 15:31:48  profilanswer
 

bjs a écrit :

Si tu as le temps tu peux jeter un coup d'oeil, mais je pense que ça marche car j'ai compilé, puis j'ai vu que ça chargeait bien le code assembleur dans le fichier.c que j'ai crée et puis j'ai recompilé et regardé en debogeur pour voir si ça mettait les bon calculs et ç'était ok.

J'ai pas les connaissances pour vérifier le code asm généré mais ton programme fonctionne oui.

Citation :

Quelques messages avant celui ci tu m'a écrit : "Il y a plusieurs d'autres trucs dans ton code qu'on peut critiquer, mais je ne veux pas faire ton boulot." Je voudrais savoir quelles choses sont pas bien dans mon code. Merci de me dire quoi.

Désolé. La note que tu vas avoir pour ce travail est censé représenter/évaluer tes compétences/..., pas les miennes. Si je commence à corriger ton code (en t'indiquant ce qui ne va pas) ça va falsifier le truc et puis j'ai pas trop le temps ni l'envie non plus. Il faut aussi dire que bien des choses au niveau code sont subjectives, ton prof ne pense peut-être pas du tout comme moi et je ne connais pas le cahier des charges. Je t'ai aidé à faire fonctionner ton code globalement, je vais m'arrêter là.

Citation :

Je voudrais savoir aussi comment activer les warnings sur visual c++ 2010.

Je ne sais pas et je ne vais pas lire la doc (ou utiliser un moteur de recherche, en anglais c'est mieux) à ta place. Vu le "C++" dans le nom de ce logiciel (que je ne connais pas), ton code est bien dans un fichier .c (et non .cpp) et compilé avec un compilateur C et non C++?

Citation :

J'ai déjà des warnings mais peut être qu'il y a un level supérieur en warnings ??
J'ai mis enable all warnings et ça me rien de spécial en warnings à par ce même warning pour toutes mes fonctions=>
1>f:\virton\bureau\micro quadri 2\ex1\ex1\exercice1.c(453): warning C4255: 'Nombre' : aucun prototype de fonction fourni : conversion de '()' en '(void)'

Il doit y avoir un autre niveau, le compilateur doit au moins te dire que main() doit retourner int. GCC (que j'utilises) avec -Wall parle aussi d'autres trucs, voir en haut, j'ai pas regardé. Concernant le warning C4255, tu as bien des prototypes dans ton code, je pense que le compilateur essaye de te dire que si une fonction ne prend pas d'arguments il faut indiquer (void) et non ().

mood
Publicité
Posté le   profilanswer
 


Aller à :
Ajouter une réponse
  FORUM HardWare.fr
  Programmation
  C

  compilateur

 

Sujets relatifs
Le Compilateur[Résolu]Bug du compilateur Gnat ?
programmation avec compilateur mikroCproblème installation compilateur FLEX sur AIX 7.1
Inclure un compilateur dans un programme[TI-BASIC] Compilateur pour TI 89 titanium
Problème de compilateurCompilateur C++ en java
Compilateur et simulateuroption compilateur CC
Plus de sujets relatifs à : compilateur

Forum MesDiscussions.Net, Version 2010.2
(c) 2000-2011 Doctissimo
Page générée en 0.298 secondes

Copyright © 1997-2022 Hardware.fr SARL (Signaler un contenu illicite / Données personnelles) / Groupe LDLC / Shop HFR