Aufgabe:

Schreiben Sie eine Funktion getFPnum(), welche die Eingabe eines Strings von der Tastatur aus ermöglicht. Der String soll nullterminiert werden, auf eine bestimmte Anzahl von Zeichen begrenzbar sein und nur Zeichen enthalten, die in einer Fliesskommazahl vorkommen. Hierbei ist auf deren mögliche Positionierung zu achten. Ein eingegebenes Komma soll in einen Punkt gewandelt werden.

Die Eingabe zur Funktion soll durch die Escape- oder Return-Taste abgebrochen werden können. Wird die Escape-Taste zum Abbruch benutzt, gibt die Funktion getFPnum() den Wert 0 zurück und der eingegebene String besitzt die Länge 0 (leerer String). Bei Return wird der bis dahin eingegebene String mit Null terminiert und die Funktion gibt 1 zurück.

Mit der Taste [<--] sollen Fehleingaben in den String korrigiert werden können.

Geben Sie ein Testprogramm für die Funktion an, das einen Eingabebuffer für 30 Eingabezeichen bereitstellt. Das Testprogramm soll die Eingabe anzeigen, es soll den eingegebenen String zur Kontrolle ausgeben und seine Wandlung in eine Fliesskommazahl von Typ double dokumentieren.

// getfpstrg.cpp
// -------------  Version 20.05.2002
//                Model: small
//                Fliesskommaemulation ein (bei SC12)
//                Schwarzer, BBS WiLu


// Holt einen nullterminierten String, der eine Fliess-
// komma zahl enthält.

// Deklaration von Bibliotheksfunktionen
#include <stdio.h>     // für printf(), putc()
#include <conio.h>     // für getch()
#include <math.h>      // für atoi()

// Deklaration eigener Funktionen
void setStdio(char);   // nur bei SC12
int  getFPnum( char* Buffer, int StringLang);

// Definition von Kurzbezeichnungen
#define CR    0x0D     // Carriage Return (Enter Taste)
#define ESC   0x1B     // Escape (Esc-Taste)
#define BS    0x08     // Backspace (<-- Taste)
#define SPACE 0x20     // Leerzeichen (Space Bar)

// main()
// Testprogramm zum Test der Eingabefunktion getFPum()
void main(void)
{
 const char len=30;
 char   buf[len+1]="";
 double x;

 setStdio(2);
 printf("\r\n Eingabe: ");
 getFPnum(buf, 15);
 printf("\r\n Der String in buf lautet %s",buf);
 x =atof(buf);
 printf("\r\n Die Zahl in x lautet: x=%f",x);
 setStdio(3);
}


// getFPnum()
// Holt einen String von der Tastatur, der nur Zeichen für
// eine Fliesskommazahl enthalten kann. Das bedeutet, er
// kann genau ein Komma oder einen Punkt besitzen und
// auf der ersten Position die Zeichen + oder -. Die
// Stringlänge beträgt 'len', der eingegebene String wird
// in den Buffer 'buf' zurückgegeben, den das aufrufende
// Programm bereitstellt. Das Zeichen ',' wird in das
// Zeichen '.' verändert.
// Mit der Taste [<--] kann die Eingabe editiert werden
// Rückgabe 0, Funktion wurde mit <cr> beendet, im Buffer
// der nullterminierte Fliesskommastring,
// Rückgabe 1, Funktion wurde mit <esc> beendet, im Buffer
// ein leerer String
int getFPnum (char *buf, int len)
{
 int n=0, c;
 int pktflg = 0;

 while (1){
   c= getch();                        // Zeichen holen
   switch (c){
    case CR : buf[n]= 0; return(1);   // wenn <cr>
    case ESC: buf[0]= 0; return(0);   // wenn <esc>
    case BS : if (n>0){               // wenn <bs>
                putc(c, stdout);
                putc(' ', stdout);
                putc(c, stdout);
                n--;
                if(buf[n]=='.'||buf[n]==';')
                pktflg=0;
                continue;
               }
  }
  if(n >len-1) continue;              // wenn Länge zu groß
   switch (c){
    case ',':                         // Komma oder Punkt
    case '.': if (pktflg) continue;   // und nur eines
                  buf[n]='.';
                  pktflg=1;  break;
    case '+':                         // wenn Vorz. und
    case '-': if (n != 0) continue;   // erste Position
                  buf[n]= (char)c;
                  break;
    default : if(c<'0' || c>'9')      // Zeichen 0-9 
               continue;
               buf[n]= (char)c;
    }

    n++;
    putc(c,stdout);                   // Bildschirmausgabe
 } // while
} // Funktion




// setStdio()
// Besonderheit des SC12, die Funktion kann bei normalen
// PCs weggelassen werden. Diese Funktion richtet den Ein-
// gabestrom auf das Benutzerprogramm kanal=2 oder auf das
// Betriebssystem kanal=3
// Wird später im Kapitel über den SC12 erklärt.
#include <dos.h>
static union  REGS  inregs;
static union  REGS  outregs;

void setStdio (char kanal)
{
  inregs.h.ah = 0x11;
  inregs.h.al = kanal;
  int86(0xA0, &inregs, &outregs);
}

Zur Funktion: hole eine Fliesskommazahl von Stdin

Soll die obige Funktion auf einem SC12 IPC@CHIP WebServer laufen, so muß ihr ein zusätzliches Unterprogramm mitgegeben werden. Dieses richtet die Standardeingabe des SC12 auf das Benutzerprogramm. Der Grund für dieses Unterprogramm wird später bei der Besprechung des SC12 erläutert. Hier wurde es angefügt und am Anfang, sowie am Ende von main() aufgerufen.

Deklarationen

int getFPnum (char*, int);

Übergabeparameter 1:

Der Zeiger char* zeigt auf einen Zeichenbuffer (CharArray), der den nullterminierten Eingabestring in der gewünschten Länge aufnehmen können muß.

Übergabeparameter 2:

Die Länge des Stringbuffers muß getstrg() auch mitgeteilt werden, was im zweiten Übergabeparameter in Form einer Integervariablen geschieht. Der Buffer muss wegen der den String abschliessenden 0 ein Zeichen mehr aufnehmen können als Eingabezeichen gewünscht werden.

Rückgabeparameter:

Wird die Eingabe durch die Taste [ENTER] abgebrochen, dann gibt die Funktion 1 zurück. Der Stringbuffer der aufrufenden Funktion ist mit dem bis dahin eingegebenen String gefüllt. Dieser ist nullterminiert.

Wird die Eingabe durch die Taste [ESC] abgebrochen, dann gibt die Funktion 0 zurück. Der Stringbuffer der aufrufenden Funktion ist leer. Das bedeutet, es befindet sich nur die den String abschließende 0 in ihm.