debianforum.de

bc als Rechner in C Programm verwenden

SNIPPET_TEXT:

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. PASTEBIN_DOWNLOAD_SNIPPET_EXPLAIN