#include <stdio.h>
#include "escapesequenzen.h"

void printFrame();
short getNumber(int);
void printInputNumber(int, short);
char getOperator(int);
void printInputOperator(int, char);
short calcResult(short, short, char);
void printResultNumber(int, short);
void printBinary(int, short);
void printResultOperator(char);
int askAgain();
void clearBuffer();

int main ()
{
   short Op1, Op2, Erg;    // erste und zweite Operanden fuer Rechner und Ergebnis
   char Operator;          // Bitweise Operator fuer Rechner
   int JaNein;             // Ergebnis der Ja/Nein Frage
   do
   {
      CLEAR;                  // loescht den bildshirm
      HOME;                   // setzt den Cursor nach oben
      printFrame();
      Op1 = getNumber(4);
      printInputNumber(4, Op1);
      printResultNumber(11, Op1);
      printBinary(11, Op1);
      Operator = getOperator(5);
      printInputOperator(5, Operator);
      printResultOperator(Operator);
      Op2 = getNumber(6);
      printInputNumber(6, Op2);
      printResultNumber(13, Op2);
      printBinary(13, Op2);
      Erg = calcResult(Op1, Op2, Operator);
      printResultNumber(15, Erg);
      printBinary(15, Erg);
      JaNein = askAgain();
   } while (JaNein != 0);
   POSITION (21, 1);
   return 0;
}

/*******************************************************************
 * Funktion:       printFrame
 * Beschreibung:   stellt die Maske mit feststehenden Texten dar
 * Parameter:      keine
 * Ergebnis:       keine
 *******************************************************************/
void printFrame()
{
printf("|-----------------------------------------------------------|\n");
printf("| Bitoperatoren-Rechner                                     |\n");
printf("|                                                           |\n");
printf("| Eingabe Zahl 1   :                                        |\n");
printf("| Operator         :                                        |\n");
printf("| Eingabe Zahl 2   :                                        |\n");
printf("|                                                           |\n");
printf("|-----------------------------------------------------------|\n");
printf("|                                                           |\n");
printf("|          | dez.  |  okt.    |  hex.  | Binaerdarstellung  |\n");
printf("| Zahl 1   |       |          |        |                    |\n");
printf("| Operator |       |          |        |                    |\n");
printf("| Zahl 2   |       |          |        |                    |\n");
printf("|-----------------------------------------------------------|\n");
printf("| Ergebnis |       |          |        |                    |\n");
printf("|                                                           |\n");
printf("|-----------------------------------------------------------|\n");
}

/*******************************************************************
 * Funktion:       getNumber
 * Beschreibung:   liest Operanden in der angegebenen Zeile ein
 * Parameter:      Integer, line wo Zahl eingegeben ist
 * Ergebnis:       erste Operanden
 *******************************************************************/
short getNumber(int Line)
{
   short Zahl;
   int Check;

   POSITION (18, 1);
   printf("Bitte geben Sie eine ganze Zahl ein             \n"
          "                                                \n"
          "                                                \n");
   POSITION (Line, 26);
   Check = scanf("%hd", &Zahl);
   clearBuffer();
   while (!Check)
   {
      POSITION (Line, 26);
      printf("                         ");
      POSITION (18, 1);
      printf("Sie haben keine ganze Zahl eingegeben.       \n"
             "Bitte geben Sie eine ganze Zahl ein.         \n"
             "                                               ");
      POSITION (Line, 26);
      Check = scanf("%hd", &Zahl);
      clearBuffer();
      POSITION (Line, 26);
      printf("                               ");
   }
   return Zahl;
}

/*******************************************************************
 * Funktion:       printInputNumber
 * Beschreibung:   gibt eingegebenen Operanden in der angegebener
 *                 Zeile aus
 * Parameter:      Integer, line wo Operanden ausgegeben ist, Short
 *                 Operanden die ausgegeben sein sollte
 * Ergebnis:       keine
 *******************************************************************/
 void printInputNumber(int Line, short Zahl)
 {
    POSITION (Line, 26);
    printf("%hd                    ", Zahl);
 }


/*******************************************************************
 * Funktion:        getOperator
 * Beschreibung:    liest das erste Zeichen des Operators ein
 * Parameter:       int, line eingelesen
 * Ergebnis:        char, Bitweise Operator
 *******************************************************************/
char getOperator(int Line)
{
   char Operator;

   POSITION (18, 1);
   printf("Bitte geben Sie eine gueltige Operater ein.             \n");
   printf("Gueltige Operator sind: |, &, >, <, ^, +, -, * und /.   \n");
   POSITION (Line, 26);
   scanf("%c", &Operator);
   clearBuffer();
   while (Operator!='|' && Operator!='&' && Operator!='>' && Operator!='<' && Operator !='^'
         && Operator!='+' && Operator!='-' && Operator!='*' && Operator!='/')
   {
      POSITION (Line, 26);
      printf("                      ");
      POSITION (18, 1);
      printf("Sie haben keine gueltige Operator eingegeben.        \n");
      printf("Bitte geben Sie eine gueltige Operater ein.          \n");
      printf("Gueltige Operator sind: |, &, >, <, ^, +, -, * und /  \n");
      POSITION (Line, 26);
      scanf("%c", &Operator);
      clearBuffer();
   }

   return Operator;
}
/*******************************************************************
 * Funktion:        printInputOperator
 * Beschreibung:    gibt Operator aus
 * Parameter:       Bitweise Operator
 * Ergebnis:        keine
 *******************************************************************/
void printInputOperator(int Line, char Operator)
{
   POSITION (Line, 26);
   printf("%c                  ", Operator);
}
/*******************************************************************
 * Funktion:        calcResult
 * Beschreibung:    berechnet Ergebnis
 * Parameter:       Zwei Operanden(short) und ein Operator(char)
 * Ergebnis:        Ergebnis von die Rechnung
 *******************************************************************/
short calcResult(short Op1, short Op2, char Operator)
{
   short Erg;

   switch (Operator)
   {
      case '|': Erg = Op1 | Op2;    break;
      case '&': Erg = Op1 & Op2;    break;
      case '>': Erg = Op1 >> Op2;   break;
      case '<': Erg = Op1 << Op2;   break;
      case '^': Erg = Op1 ^ Op2;    break;
      case '+': Erg = Op1 + Op2;    break;
      case '-': Erg = Op1 - Op2;    break;
      case '*': Erg = Op1 * Op2;    break;
      case '/': Erg = Op1 / Op2;    break;
   }

   return Erg;
}
/*******************************************************************
 * Funktion:        printResultNumber
 * Beschreibung:    gibt die Ergebnisse (dez., okt. und hex.) aus
 * Parameter:       Line Nummer wo die Ergebnis ausgegeben sollten
 *                  und Ergebnis von funktion calcResult
 * Ergebnis:        keine
 *******************************************************************/
void printResultNumber(int Line, short Zahl)
{
   POSITION (Line, 13);
   printf("%7hd", Zahl);
   POSITION (Line, 23);
   printf("%8ho", Zahl);
   POSITION (Line, 36);
   printf("%4hx", Zahl);
}
/*******************************************************************
 * Funktion:        printBinary
 * Beschreibung:    Gibt ein Zahl als Binar aus
 * Parameter:       Line wo die Zahl ausgegeben sollte und Zahl
 * Ergebnis:        keine
 *******************************************************************/
void printBinary(int Line, short Zahl)
{
   int i;
   POSITION (Line, 42);
   for (i = 15; i >= 0; i--)
   {
      if ((Zahl &(1<<i)) != 0)
         printf("1");
      else
         printf("0");
   }
}

/*******************************************************************
 * Funktion:        printResultOperator
 * Beschreibung:    gibt Operator im Ergebnisbereich aus
 * Parameter:       char, Operator
 * Ergebnis:        keine
 *******************************************************************/
void printResultOperator (char Operator)
{
   POSITION (12, 19);
   printf("%c", Operator);
   POSITION (12, 30);
   printf("%c", Operator);
   POSITION (12, 39);
   printf("%c", Operator);
   POSITION (12, 57);
   printf("%c", Operator);
}
/*******************************************************************
 * Funktion:        askAgain
 * Beschreibung:    Ja/Nein Abfrage
 * Parameter:       keine
 * Ergebnis:        int, Ja=1, Nein=0
 *******************************************************************/
int askAgain()
{
   char jn;
   int JaNein;
   POSITION (18, 1);
   printf("Moechten Sie diesen Rechner nochmal benutzen         \n "
          "                                                     \n "
          "(J)a/(N)ein: ");
   do
   {
      scanf("%c", &jn);
      clearBuffer();
      if (jn != ('j'||'J'||'n'||'N'))
      {
         POSITION (18, 1);
         printf("                                                \n "
                "                                                \n "
                "                                                  ");
         POSITION (18, 1);
         printf("Sie haben keine (J)a oder (N)ein eingegeben.   \n"
                "Moechten Sie diesen Rechner nochmal benutzen   \n"
                "(J)a/(N)ein: ");
      }
   } while (jn!='j' && jn!='J' && jn!='n' && jn!='N');
   if (jn == 'j' || jn == 'J')
      JaNein = 1;
   else
      JaNein = 0;
   return JaNein;
}

/*******************************************************************
 * Funktion:        clearBuffer
 * Beschreibung:    Tastaturpuffer leeren
 * Parameter:       keine
 * Ergebnis:        keine
 *******************************************************************/
void clearBuffer()
{
   char Dummy;
   do
   {
      scanf("%c", &Dummy);
   } while (Dummy != '\n');
}