christoph/lecture-operating-system-development
1
Fork 0
Code Activity

move folder

Browse Source
This commit is contained in:
churl
2022-04-16 14:50:17 +02:00
parent 87e482bc7c
commit 4ec2beeda2
25 changed files with 319 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

160
c_os/lib/OutStream.cc Executable file
View File

@ -0,0 +1,160 @@
/*****************************************************************************
* *
* O U T S T R E A M *
* *
*---------------------------------------------------------------------------*
* Beschreibung: Die Klasse OutStream enthaelt die Definition des *
* << Operators fuer die wichtigsten der vordefinierten *
* Datentypen und realisiert somit die bekannte Ausgabe- *
* funktion der C++ iO_Stream Bibliothek. Zur Zeit wird *
* die Darstellung von Zeichen, Zeichenketten und ganzen *
* Zahlen unterstuetzt. Ein weiterer << Operator erlaubt *
* die Verwendung von Manipulatoren. *
* *
* Neben der Klasse OutStream sind hier auch die *
* Manipulatoren hex, dec, oct und bin fuer die Wahl der *
* Basis bei der Zahlendarstellung, sowie endl fuer den *
* Zeilenumbruch definiert. *
* *
* Autor: Olaf Spinczyk, TU Dortmund *
* Aenderungen von Michael Schoettner, HHU, 1.8.16 *
*****************************************************************************/
#include "lib/OutStream.h"
//
// Zeichen und Zeichenketten in Stream ausgeben
//
OutStream& OutStream::operator << (char c) {
put(c);
return *this;
}
OutStream& OutStream::operator << (unsigned char c) {
return *this << (char) c;
}
OutStream& OutStream::operator << (char* string) {
char* pos = string;
while (*pos) {
put (*pos);
pos++;
}
return *this;
}
//
// Ganzer Zahlen im Zahlensystem zur Basis base in Stream ausgeveb
// Alle vorzeichenbehafteten Datentypen werden als long dargestellt,
// Alle vorzeichenlosen als unsigned long.
OutStream& OutStream::operator << (short ival) {
return *this << (long) ival;
}
OutStream& OutStream::operator << (unsigned short ival) {
return *this << (unsigned long) ival;
}
OutStream& OutStream::operator << (int ival) {
return *this << (long) ival;
}
OutStream& OutStream::operator << (unsigned int ival) {
return *this << (unsigned long) ival;
}
// Darstellung eine vorzeichenbehafteten ganzen Zahl.
OutStream& OutStream::operator << (long ival) {
// Bei negativen Werten wird ein Minuszeichen ausgegeben.
if (ival < 0) {
put ('-');
ival = -ival;
}
// Dann wird der Absolutwert als vorzeichenlose Zahl ausgegeben.
return *this << (unsigned long) ival;
}
// Darstellung einer vorzeichenlosen ganzen Zahl.
OutStream& OutStream::operator << (unsigned long ival) {
unsigned long div;
char digit;
if (base == 8)
put ('0'); // oktale Zahlen erhalten eine fuehrende Null
else if (base == 16) {
put ('0'); // hexadezimale Zahlen ein "0x"
put ('x');
}
// Bestimmung der groessten Potenz der gewaehlten Zahlenbasis, die
// noch kleiner als die darzustellende Zahl ist.
for (div = 1; ival/div >= (unsigned long) base; div *= base);
// ziffernweise Ausgabe der Zahl
for (; div > 0; div /= (unsigned long) base) {
digit = ival / div;
if (digit < 10)
put ('0' + digit);
else
put ('a' + digit - 10);
ival %= div;
}
return *this;
}
// Darstellung eines Zeigers als hexadezimale ganze Zahl
OutStream& OutStream::operator << (void* ptr) {
int oldbase = base;
base = 16;
*this << (unsigned long) ptr;
base = oldbase;
return *this;
}
// Aufruf einer Manipulatorfunktion
OutStream& OutStream::operator << (OutStream& (*f) (OutStream&)) {
return f(*this);
}
//
// Manipulatorfunktionen
//
// Die folgenden Funktionen erhalten und liefern jeweils eine Referenz auf
// ein OutStream Objekt. Da die Klasse O_Stream einen Operator << fuer
// derartige Funktionen definiert, koennen sie mit Hilfe dieses Operators
// aufgerufen und sogar in weitere Eingaben eingebettet werden.
// Aufgabe der Manipulatoren ist, die Darstellung der nachfolgenden Ausgaben
// zu beeinflussen, z.B durch die Wahl des Zahlensystems.
// Fuege einen Zeilenumbruch in die Ausgabe ein.
OutStream& endl (OutStream& os) {
os << '\n';
os.flush ();
return os;
}
// Waehlt das binaere Zahlensystem aus.
OutStream& bin (OutStream& os) {
os.base = 2;
return os;
}
// Waehlt das oktale Zahlensystem aus.
OutStream& oct (OutStream& os) {
os.base = 8;
return os;
}
// Waehlt das dezimale Zahlensystem aus.
OutStream& dec (OutStream& os) {
os.base = 10;
return os;
}
// Waehlt das hexadezimale Zahlensystem aus.
OutStream& hex (OutStream& os) {
os.base = 16;
return os;
}

92
c_os/lib/OutStream.h Executable file
View File

@ -0,0 +1,92 @@
/*****************************************************************************
* *
* O U T S T R E A M *
* *
*---------------------------------------------------------------------------*
* Beschreibung: Die Klasse OutStream enthaelt die Definition des *
* << Operators fuer die wichtigsten der vordefinierten *
* Datentypen und realisiert somit die bekannte Ausgabe- *
* funktion der C++ iO_Stream Bibliothek. Zur Zeit wird *
* die Darstellung von Zeichen, Zeichenketten und ganzen *
* Zahlen unterstuetzt. Ein weiterer << Operator erlaubt *
* die Verwendung von Manipulatoren. *
* *
* Neben der Klasse OutStream sind hier auch die *
* Manipulatoren hex, dec, oct und bin fuer die Wahl der *
* Basis bei der Zahlendarstellung, sowie endl fuer den *
* Zeilenumbruch definiert. *
* *
* Autor: Olaf Spinczyk, TU Dortmund *
* Aenderungen von Michael Schoettner, HHU, 06.04.20 *
*****************************************************************************/
#ifndef __OutStream_include__
#define __OutStream_include__
#include "lib/StringBuffer.h"
class OutStream : public StringBuffer {
private:
OutStream(const OutStream &copy); // Verhindere Kopieren
public:
int base; // Basis des Zahlensystems: z.B. 2, 8, 10 oder 16
OutStream () : StringBuffer () { base = 10; } // initial Dezimalsystem
virtual void flush () = 0; // weiterhin undefiniert
// OPERATOR << : Umwandlung des angegebenen Datentypes in eine
// Zeichenkette.
// Darstellung eines Zeichens (trivial)
OutStream& operator << (char c);
OutStream& operator << (unsigned char c);
// Darstellung einer nullterminierten Zeichenkette
OutStream& operator << (char* string);
// Darstellung ganzer Zahlen im Zahlensystem zur Basis base
OutStream& operator << (short ival);
OutStream& operator << (unsigned short ival);
OutStream& operator << (int ival);
OutStream& operator << (unsigned int ival);
OutStream& operator << (long ival);
OutStream& operator << (unsigned long ival);
// Darstellung eines Zeigers als hexadezimale ganze Zahl
OutStream& operator << (void* ptr);
// Aufruf einer Manipulatorfunktion
OutStream& operator << (OutStream& (*f) (OutStream&));
};
//
// Manipulatorfunktionen
//
// Die folgenden Funktionen erhalten und liefern jeweils eine Referenz auf
// ein OutStream Objekt. Da die Klasse OutStream einen Operator << fuer
// derartige Funktionen definiert, koennen sie mit Hilfe dieses Operators
// aufgerufen und sogar in weitere Eingaben eingebettet werden.
// Aufgabe der Manipulatoren ist, die Darstellung der nachfolgenden Ausgaben
// zu beeinflussen, z.B durch die Wahl des Zahlensystems.
// Zeilenumbruch in Ausgabe einfuegen.
OutStream& endl (OutStream& os);
// Waehle binaeres Zahlensystem aus.
OutStream& bin (OutStream& os);
// Waehle oktales Zahlensystem aus.
OutStream& oct (OutStream& os);
// Waehle dezimales Zahlensystem aus.
OutStream& dec (OutStream& os);
// Waehle hexadezimales Zahlensystem aus.
OutStream& hex (OutStream& os);
#endif

38
c_os/lib/StringBuffer.cc Executable file
View File

@ -0,0 +1,38 @@
/*****************************************************************************
* *
* S T R I N G B U F F E R *
* *
*---------------------------------------------------------------------------*
* Beschreibung: Die Klasse StringBuffer stellt einen Puffer fuer die *
* Sammlung von Zeichen zur Darstellung auf dem Bildschirm *
* oder anderen Ausgabegeraeten bereit. Die Ausgabe der *
* Zeichen erfolgt, sobald der Puffer voll ist oder wenn *
* explizit die Methode flush() aufgerufen wird. *
* Da StringBuffer geraeteunabhaengig sein soll, ist *
* flush() eine virtuelle Methode, die von den abgeleiteten *
* Klassen definiert werden muss. *
* *
* Autor: Olaf Spinczyk, TU Dortmund *
* Aenderungen von Michael Schoettner, HHU, 1.8.16 *
*****************************************************************************/
#include "lib/StringBuffer.h"
/*****************************************************************************
* Methode: StringBuffer::put *
*---------------------------------------------------------------------------*
* Beschreibung: Fuegt ein Zeichen in den Puffer ein. Wenn der Puffer *
* daraufhin voll ist, wird er durch Aufruf der Methode *
* flush geleert. *
* *
* Parameter: *
* c: Einzufuegendes Zeichen. *
*****************************************************************************/
void StringBuffer::put (char c) {
buffer[pos] = c;
pos++;
if (pos == sizeof (buffer))
flush ();
}

47
c_os/lib/StringBuffer.h Executable file
View File

@ -0,0 +1,47 @@
/*****************************************************************************
* *
* S T R I N G B U F F E R *
* *
*---------------------------------------------------------------------------*
* Beschreibung: Die Klasse StringBuffer stellt einen Puffer fuer die *
* Sammlung von Zeichen zur Darstellung auf dem Bildschirm *
* oder anderen Ausgabegeraeten bereit. Die Ausgabe der *
* Zeichen erfolgt, sobald der Puffer voll ist oder wenn *
* explizit die Methode flush() aufgerufen wird. *
* Da StringBuffer geraeteunabhaengig sein soll, ist *
* flush() eine virtuelle Methode, die von den abgeleiteten *
* Klassen definiert werden muss. *
* *
* Autor: Olaf Spinczyk, TU Dortmund *
* Aenderungen von Michael Schoettner, HHU, 06.04.20 *
*****************************************************************************/
#ifndef __StringBuffer_include__
#define __StringBuffer_include__
class StringBuffer {
private:
StringBuffer(const StringBuffer &copy); // Verhindere Kopieren
// Alle Variablen und Methoden dieser Klasse sind "protected",
// da die abgeleiteten Klassen einen direkten Zugriff auf den
// Puffer, den Konstruktor, den Destruktor und die Methode put
// benoetigen. Die Methode flush() muss sowieso neu definiert
// werden und kann dann auch public werden.
protected:
char buffer[80];
int pos;
// StringBuffer: Im Konstruktor wird der Puffer als leer markiert.
StringBuffer () : pos(0) {}
// Fuegt ein Zeichen in den Puffer ein. Wenn der Puffer
void put (char c);
// Methode zur Ausgabe des Pufferinhalts
virtual void flush () = 0;
};
#endif