Aquädukt V2

Finale Version mit Beachtung der Subtraktionsregel.

/****************************************************************     
*     Aquaedukt - Roemische Zahlen durch Pipe uebersetzen       *     
*   (c) 2009 Manuel Krischer fuer das Betriebssystempraktikum   *     
****************************************************************/     
 
#include <stdlib.h>
#include <stdio.h> 
#include <string.h>
#include <ctype.h> 
#include <unistd.h>
#include <fcntl.h> 
#include <sys/types.h>
#include <sys/stat.h> 
 
/* Pipe Name und Berechtigung festlegen */
#define PIPEFILE        "aquaedukt"       
#define PIPEPERM        0777              
 
/*Wieviele Eingaben erlauben*/            
#define EINGABEN        5                 
 
/*zuordnung roemische/arabische ziffern festlegen*/
#define M       1000                               
#define D       500                                
#define C       100                                
#define L       50                                 
#define X       10                                 
#define V       5                                  
#define I       1                                  
 
/*anzahl roemische zahlzeichen*/                   
#define zeichen  7                                 
 
int roman[zeichen]      = { M, 0, C, 0, X, 0, I }; 
char show_roman[zeichen]= { 'M', 'D', 'C', 'L', 'X', 'V', 'I' };
int count[zeichen]      = { 0, 0, 0, 0, 0, 0, 0};               
 
/* Named Pipe loeschen und neu erstellen */                     
int make_pipe() {                                               
          unlink(PIPEFILE);                                     
          if(0 != mkfifo(PIPEFILE, PIPEPERM)) {                 
            printf("Pipe anlegen fehlgeschlagen!");             
          }                                                     
}                                                               
 
int max = EINGABEN; /*wieviel eingaben erlauben*/               
 
/* Funktion fuer den Eingabe, wird im Sohnprozess 1 ausgefuehrt*/
int araber() {                                                   
    int i=0, h=1;                                                
    int wert;                                                    
        /* Named Pipe zum schreiben oeffnen und Betraege einlesen*/
        FILE *input = fopen(PIPEFILE, "w");                        
            do {                                                   
              printf("Betrag %i: ",h++);                           
              scanf("%i",&wert);                                   
              /*in pipe schreiben*/                                
 
              if ( wert > 0 && wert < 4000 ) {                     
                  fprintf(input, "%i\n", wert);                    
                  }                                                
              else if ( wert < 0 || wert >= 4000) {                
                  printf("Nur Werte zwischen 1-3999 erlaubt!\n");  
                  h--;                                             
                  i--;                                             
                  }                                                
              else {                                               
                  printf("ok\n");                                  
                  }                                                
              i++;                                                 
              /*Wenn EINGABEN erreicht oder 0, dann eingabevorgang abbrechen*/
              } while (i != max && wert != 0 );                               
            fflush(input);                                                    
            fclose(input);                                                    
return;                                                                       
}                                                                             
 
/* Funktion fuer den Roemer, wird im zweiten Kindprozess ausgefuehrt*/        
int roemer() {                                                                
      int werte[max], auslesen, o=0, e=0, i=0, j=0, k=0, tmp_zahl;            
      char worte[max][128], tmp_wort[128];                                    
      FILE *input;                                                            
      /* Datei/Named Pipe oeffnen */                                          
            if ((input = fopen(PIPEFILE, "r")) != NULL) {                     
               while (!feof(input))                                           
                 {                                                            
                  /*arabische zahlen aus pipe lesen*/                         
                  fscanf(input, "%i", &tmp_zahl);                             
                  /*aktuelle arabische zahl in einem array sichern*/          
                  werte[j] = tmp_zahl;                                        
                  /*anzahl der roemischen zahlwerte ermitteln, achtung nicht durch die 0-werte teilen, deswegen +2*/
                   for (o=0; o<zeichen; o=o+2) {                                                                    
                         if (tmp_zahl >= roman[o]) {                                                                
                                count[o]        = tmp_zahl / roman[o];                                              
                                tmp_zahl        = tmp_zahl - roman[o] * count[o];                                   
                         }                                                                                          
                         else {                                                                                     
                           count[o] = 0;                                                                            
                         }                                                                                          
                   }                                                                                                
                   /*in dem array count steckt jetzt die anzahl der jeweiligen buchstaben, die benoetigt werden*/   
                   /*ermittelte roemische werte als buchstaben in chararray schreiben*/                             
                   for (k=0; k<zeichen; k++) {                                                                      
                   /*solange noch zeichen da sind, pruefen*/                                                        
                         while (count[k] != 0 ) {                                                                   
                               /*bei einer anzahl von 9, darf 1, 10 und 100 von der jeweils 2 stellen groesseren einheit abgezogen werden*/
                                if (count[k] == 9 ) {                                                                                      
                                  tmp_wort[e++] = show_roman[k];                                                                           
                                  tmp_wort[e++] = show_roman[k-2];                                                                         
                                  count[k] = 0;                                                                                            
                                }                                                                                                          
                                /*bei 4 gilt das ganze fuer die naechstgroessere*/                                                         
                                else if (count[k] == 4 ) {                                                                                 
                                  tmp_wort[e++] = show_roman[k];                                                                           
                                  tmp_wort[e++] = show_roman[k-1];                                                                         
                                  count[k] = 0;                                                                                            
                                }                                                                                                          
                                /*wenn 5 gezahelt wurden, wird durch die naechstgroessere einheit ersetzt*/                                
                                else if (count[k] > 4 && count[k] < 9) {                                                                   
                                  tmp_wort[e++] = show_roman[k-1];                                                                         
                                  count[k] -= 5;                                                                                           
                                }                                                                                                          
                                else {                                                                                                     
                                /*ansonsten ein zeichen hinzufuegen und weiterprobieren*/                                                  
                                 tmp_wort[e++] = show_roman[k];                                                                            
                                 count[k] -= 1;                                                                                            
                                }                                                                                                          
                        }                                                                                                                  
                   }                                                                                                                       
                  /*nullbyte anhaengen*/                                                                                                   
                  tmp_wort[e] = '\0';                                                                                                      
                  e=0;                                                                                                                     
                  /*aktuelles wort in wortarray kopieren*/                                                                                 
                  strcpy(worte[j], tmp_wort);                                                                                              
                  j++;                                                                                                                     
                  }
                  fclose(input);
/*ausgabe des wert und wortarrays als gegenueberstellung*/
      printf("\nUmrechnungstabelle\n");
      printf("*******************************************\n");
      for (i=0; i<=j; i++) {
               if (werte[i] == 0) break;
            printf("Arabisch: %i\t\t | Roemisch: %s\n", werte[i], worte[i]);
      }
      printf("*******************************************\n");
      }
return;
}
/*Hauptprogramm*/
int main(int argc,char *argv[]) {
make_pipe();
  if (fork() == 0) {
    araber();
  }
  else if (fork() == 0) {
    roemer();
  }
  else {
    wait(0);
    wait(0);
  }
unlink(PIPEFILE);
return;
}