NoPaste

bc als Rechenr aus C-Programm heraus verwenden

von heinz

Dein Code:
  1. #include <unistd.h>
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <sys/wait.h>
  5. #include <string.h>
  6.  
  7.  
  8. const int PIPE_LESEN=0;
  9. const int PIPE_SCHREIBEN=1;
  10. int pipesE[2]; /* Eltern-Pipes */
  11. int pipesK[2]; /* Kind-Pipes */
  12. int kind_pid=0; /* Prozess-Pid */
  13.  
  14.  
  15. bool Pipe_verbinden(char*);/* (externes_programm) */
  16.  
  17.  
  18.  
  19.  
  20. int main()
  21. {
  22. /* Programmname */
  23.         char bc_programm[]={"bc"};
  24.  
  25. /* Pipes erzeugen und bc starten */
  26.         if(!Pipe_verbinden(bc_programm))/* (externes_programm) */
  27.         {
  28.                 exit(1);
  29.         }
  30.  
  31.  
  32. /* Schreib und lese-speicher */
  33.         char bufs[BUFSIZ]={""};
  34.         char bufl[BUFSIZ]={""};
  35.  
  36. /* File-Pointer auf stdin erzeugen */
  37.         FILE* fp=fdopen(PIPE_LESEN,"r");
  38. /* Mehrere testformeln verschicken */
  39.         for(int z=10;z<2000;z+=10)
  40.         {
  41. /* Formel erstellen */
  42. /*              sprintf(bufs,"%i+%i\n",z,z);*/
  43.                 sprintf(bufs,"scale=6;(%i+%i)/3\n",z,z);
  44. /* Formel senden */
  45.                 printf("%s",bufs);
  46.                 fflush(NULL);
  47.  
  48.  
  49.  
  50. /* Lesen */
  51.                 fgets(bufl,BUFSIZ,fp);
  52. /* Ausgeben */
  53.                 if(strstr(bufl,"error")==NULL)
  54.                 {
  55. /* Ergebnis berechnet */
  56.                         fprintf(stderr,">%i>\033[0;33;40m%s\033[0m=\033[0;32;40m%f\033[0m<\n",z,bufs,atof(bufl));
  57.                 }
  58.                 else
  59.                 {
  60. /* Fehler in Formel */
  61.                         fprintf(stderr,">%i>\033[0;33;40m%s\033[0m=\033[0;31;40m%s\033[0m<\n",z,bufs,bufl);
  62.                 }
  63.         }
  64.  
  65. /* bc beenden */
  66.         write(PIPE_SCHREIBEN,"quit\n",10);
  67.  
  68. /* Auf ende des Kind-Prozesses warten */
  69.         wait(&kind_pid);
  70.  
  71. /* Pipes schliessen */
  72.         close(PIPE_LESEN);
  73.         close(PIPE_SCHREIBEN);
  74. }
  75.  
  76.  
  77.  
  78.  
  79.  
  80.  
  81.  
  82.  
  83.  
  84. bool Pipe_verbinden(char* EP)// (externes_programm)
  85. {
  86. /* Pipes erzeugen */
  87.         if(pipe(pipesE)<0)
  88.         {
  89.                 return(false);
  90.         }
  91.         if(pipe(pipesK)<0)
  92.         {
  93.                 return(false);
  94.         }
  95.         fflush(NULL);
  96.  
  97. /* Prozess forken */
  98.         kind_pid=fork();
  99. fprintf(stderr,"kind_pid=%i\n",kind_pid);
  100. /* Bei Fehler */
  101.         if(kind_pid<0)
  102.         {
  103.                 close(pipesE[PIPE_LESEN]);
  104.                 close(pipesE[PIPE_SCHREIBEN]);
  105.                 close(pipesK[PIPE_LESEN]);
  106.                 close(pipesK[PIPE_SCHREIBEN]);
  107.                 return(false);
  108.         }
  109.  
  110.  
  111. /* Kind Prozess */
  112.         if(kind_pid==0)
  113.         {
  114. fprintf(stderr,"bc-start\n");
  115.  
  116. /* Pipes bearbeiten */
  117.                 dup2(pipesE[PIPE_LESEN],PIPE_LESEN);
  118.                 close(pipesE[PIPE_LESEN]);
  119.                 close(pipesE[PIPE_SCHREIBEN]);
  120.  
  121.                 dup2(pipesK[PIPE_SCHREIBEN],PIPE_SCHREIBEN);
  122.                 dup2(PIPE_SCHREIBEN,2);/* Fehlerkanal auf stdout legen*/
  123.                 close(pipesK[PIPE_SCHREIBEN]);
  124.                 close(pipesK[PIPE_LESEN]);
  125.  
  126. /* bc Starten */
  127.                 execlp(EP,EP,"-q","-l",NULL);
  128.  
  129. /* Fehler-Exit bc konnte nicht gestartet werden */
  130. fprintf(stderr,"\abc-start fehlgeschlagen!\n");
  131.                 exit(255);
  132.         }
  133.  
  134.  
  135. /* Eltern Prozess */
  136.         if(kind_pid>0)
  137.         {
  138. /* Pipes bearbeiten */
  139.                 dup2(pipesK[PIPE_LESEN],PIPE_LESEN);
  140.                 close(pipesK[PIPE_LESEN]);
  141.                 close(pipesK[PIPE_SCHREIBEN]);
  142.  
  143.                 dup2(pipesE[PIPE_SCHREIBEN],PIPE_SCHREIBEN);
  144.                 close(pipesE[PIPE_SCHREIBEN]);
  145.                 close(pipesE[PIPE_LESEN]);
  146.         }
  147.  
  148.  
  149.         return(true);
  150. }
  151.  
  152.  

Quellcode

Hier kannst du den Code kopieren und ihn in deinen bevorzugten Editor einfügen. Alternativ kannst du den gesamten Eintrag auch als Datei herunterladen.