NoPaste

bc als Rechner in C Programm 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. /* Mehrere testformeln verschicken */
  37.         for(int z=10;z<200;z+=10)
  38.         {
  39. /* Formel erstellen */
  40. /*              sprintf(bufs,"%i+%i\n",z,z);*/
  41.                 sprintf(bufs,"scale=6;(%i+%i)/3\n",z,z);
  42. /* Formel senden */
  43. /*              write(PIPE_SCHREIBEN,bufs,strlen(bufs));*/
  44.                 printf("%s",bufs);
  45.                 fflush(NULL);
  46. /* Lesespeicher leeren */
  47. /*              memset(bufl,0,sizeof(bufl));*/
  48.  
  49.  
  50. /* Lesen */
  51. /*              read(PIPE_LESEN,bufl,sizeof(bufl)-1);*/
  52.                 gets(bufl);
  53. /* Ausgeben */
  54.                 if(strstr(bufl,"error")==NULL)
  55.                 {
  56. /* Ergebnis berechnet */
  57.                         fprintf(stderr,">%i>\033[0;33;40m%s\033[0m=\033[0;32;40m%f\033[0m<\n",z,bufs,atof(bufl));
  58.                 }
  59.                 else
  60.                 {
  61. /* Fehler in Formel */
  62.                         fprintf(stderr,">%i>\033[0;33;40m%s\033[0m=\033[0;31;40m%s\033[0m<\n",z,bufs,bufl);
  63.                 }
  64.         }
  65.  
  66. /* bc beenden */
  67.         write(PIPE_SCHREIBEN,"quit\n",10);
  68.  
  69. /* Auf ende des Kind-Prozesses warten */
  70.         wait(&kind_pid);
  71.  
  72. /* Pipes schliessen */
  73.         close(PIPE_LESEN);
  74.         close(PIPE_SCHREIBEN);
  75. }
  76.  
  77.  
  78.  
  79.  
  80.  
  81.  
  82.  
  83.  
  84.  
  85. bool Pipe_verbinden(char* EP)// (externes_programm)
  86. {
  87. /* Pipes erzeugen */
  88.         if(pipe(pipesE)<0)
  89.         {
  90.                 return(false);
  91.         }
  92.         if(pipe(pipesK)<0)
  93.         {
  94.                 return(false);
  95.         }
  96.         fflush(NULL);
  97.  
  98. /* Prozess forken */
  99.         kind_pid=fork();
  100. fprintf(stderr,"kind_pid=%i\n",kind_pid);
  101. /* Bei Fehler */
  102.         if(kind_pid<0)
  103.         {
  104.                 close(pipesE[PIPE_LESEN]);
  105.                 close(pipesE[PIPE_SCHREIBEN]);
  106.                 close(pipesK[PIPE_LESEN]);
  107.                 close(pipesK[PIPE_SCHREIBEN]);
  108.                 return(false);
  109.         }
  110.  
  111.  
  112. /* Kind Prozess */
  113.         if(kind_pid==0)
  114.         {
  115. fprintf(stderr,"bc-start\n");
  116.  
  117. /* Pipes bearbeiten */
  118.                 dup2(pipesE[PIPE_LESEN],PIPE_LESEN);
  119.                 close(pipesE[PIPE_LESEN]);
  120.                 close(pipesE[PIPE_SCHREIBEN]);
  121.  
  122.                 dup2(pipesK[PIPE_SCHREIBEN],PIPE_SCHREIBEN);
  123.                 dup2(PIPE_SCHREIBEN,2);/* Fehlerkanal auf stdout legen*/
  124.                 close(pipesK[PIPE_SCHREIBEN]);
  125.                 close(pipesK[PIPE_LESEN]);
  126.  
  127. /* bc Starten */
  128.                 execlp(EP,EP,"-q","-l",NULL);
  129.  
  130. /* Fehler-Exit bc konnte nicht gestartet werden */
  131. fprintf(stderr,"\abc-start fehlgeschlagen!\n");
  132.                 exit(255);
  133.         }
  134.  
  135.  
  136. /* Eltern Prozess */
  137.         if(kind_pid>0)
  138.         {
  139. /* Pipes bearbeiten */
  140.                 dup2(pipesK[PIPE_LESEN],PIPE_LESEN);
  141.                 close(pipesK[PIPE_LESEN]);
  142.                 close(pipesK[PIPE_SCHREIBEN]);
  143.  
  144.                 dup2(pipesE[PIPE_SCHREIBEN],PIPE_SCHREIBEN);
  145.                 close(pipesE[PIPE_SCHREIBEN]);
  146.                 close(pipesE[PIPE_LESEN]);
  147.         }
  148.  
  149.  
  150.         return(true);
  151. }
  152.  
  153.  

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.