Skeleton

.gitignore

@@ -0,0 +1,2 @@
+.build*
+.solution

.gitlab-ci.yml

@@ -0,0 +1,32 @@
+# This is a configuration file for GitLab Continuous Integration (CI).
+#
+# At each "push", GitLab will use this file (named '.gitlab-ci.yml') to start
+# a docker container with the image of a Linux distribution (in this case
+# Ubuntu Focal) with an already installed build tool chain and compile the
+# source in the git repository.
+# The status (indicated by the exit code of 'make') is clearly visible on the
+# project page of your repository in GitLab:
+# If a commit contains an invalid (untranslatable) state, an error (red 'x')
+# is displayed and the author is notified by mail.
+#
+# Please note: This will only test the build of your operating system,
+# but not the [correct] functionality!
+#
+#Further information: https://docs.gitlab.com/ee/ci/
+
+GCC-Build:
+  image: inf4/stubs:gcc-x64
+  script:
+    - if [ -f Makefile ] ; then make clean ; make ; fi
+
+# Optional: Use Clang 11
+#Clang-Build:
+#  image: inf4/stubs:clang-x64
+#  script:
+#    - make clean ; make CXX=clang++-11
+
+# Check style guide using cpplint
+linter:
+  image: inf4/stubs:cpplint
+  script:
+    - if [ -f Makefile ] ; then make clean ; make lint ; fi

CPPLINT.cfg

@@ -0,0 +1,16 @@
+# StuBS Coding Style Checker
+#
+# Wir orientieren uns grob an den Google C++ Style Guide ( http://google.github.io/styleguide/cppguide.html )
+# mit primär folgenden Änderungen/Anpassungen:
+#
+#   - Tabs statt Leerzeichen. Spart Bytes ;)
+#   - Zeilenlänge ist 120
+#   - Keine Angaben zum Copyright
+#   - Aufgrund des Aufgabenbuildsystems sind neue / leere Zeilen leider nicht immer vermeidbar
+#
+# Zum Prüfen empfiehlt sich beispielsweise das Pythonscript CPPLINT.py ( https://github.com/cpplint/cpplint )
+# welches mit dieser Konfigurationsdatei arbeiten kann.
+#
+set noparent
+filter=-whitespace/tab,-legal/copyright,-runtime/int,-runtime/threadsafe_fn,-readability/todo,-build/include_subdir,-runtime/references,-build/include_what_you_use,-whitespace/blank_line
+linelength=120

LICENSE

@@ -0,0 +1,10 @@
+Copyright 1998-2002  Institut für Verteilte Systeme (IVS), Otto-von-Guericke-Universität Magdeburg
+Copyright 2002-2022  Lehrstuhl für Informatik 4, Friedrich-Alexander-Universität Erlangen-Nürnberg
+
+Diese Vorlage dient als Grundlage für Lehrveranstaltungen und darf nicht ohne vorherige, schriftliche Erlaubnis der Urheberrechtsinhaber veröffentlicht oder weitergegeben werden.
+Es ist erlaubt und wünschenswert, diese Vorlage als Inspiration für eigene Projekte zu verwenden, es wird allerdings erbeten, dass die Vorgabe nicht mit deiner Lösung veröffentlicht wird.
+Wir, als Lehrende, möchten alle teilnehmenden Studierenden dazu ermutigen eine eigene Lösung zu erstellen; eine veröffentlichte Lösung ist ein Anreiz zum Abschreiben, den wir gerne vermeiden möchten.
+
+This skeleton is provided as a foundation for educational purposes and therefore MUST NOT BE DISTRIBUTED OR PUBLISHED without prior, written consent of the copyright holders.
+You are free to use this skeleton as inspiration for your projects, but, please, do not publish it along with your solution.
+We, as lecturers, want to encourage every participating student to write a solution themself; a public solution is an allurement to copying we want to avoid.

README.md

@@ -0,0 +1,42 @@
+MPStuBS - Multiprozessor Studenten Betriebssystem
+=================================================
+
+Coding Guidelines
+-----------------
+
+Similar to [Google C++ Style Guide](https://google.github.io/styleguide/cppguide.html) but with following exceptions:
+ - No license boilerplate
+ - *Tabs* instead of *Spaces*
+ - Line length of 120 characters
+ - `#pragma once` instead of `#include` guards
+
+The code should be *self-documenting*, don't state the obvious!
+However, this does not make comments superfluous:
+Since good naming is sometimes not enough, more advanced parts need to be documented,
+so any operating system developer should be able to easily understand your code.
+
+### Naming Convention
+
+ - **Variables**: lowercase with underscore
+
+       char* variable_name;
+
+ - **Constants** (and **enum** values): uppercase with underscore
+
+       const int CONST_VALUE = 42;
+
+ - **Type Names** (`class`/`struct`/`namespace`/`enum`): Capital letter, camel case
+
+       class SomeClassName;
+
+ - **Methods/Functions** (C++): start with lowercase letter, then camel case
+
+       void someFunctionName();
+
+ - **extern "C" Functions**: lowercase with underscore (like variables).
+
+       void interrupt_handler(int vector);
+
+ - **File Names**: lowercase, main type name, underscores only if is a sub type
+
+       folder/classname.cc

object/outputstream.cc

@@ -0,0 +1 @@
+#include "outputstream.h"

object/outputstream.h

@@ -0,0 +1,237 @@
+/*! \file
+ *  \brief This file contains the \ref OutputStream
+ *
+ *  Along with the class OutputStream itself, this file contains definitions for the
+ *  manipulators \ref hex, \ref dec, \ref oct, and \ref bin, which are used for
+ *  changing the radix, and \ref endl for signaling the end of the current line.
+ *  \ingroup io
+ *
+ *  \par Manipulators
+ *  To simplify formatting text and numbers using the class OutputStream, we define
+ *  so-called manipulators.
+ *  For example, the expression
+ *  <tt>kout << "a = " << dec << a << " is hexadecimal " << hex << a << endl;</tt>
+ *  should, at first, print the value stored in decimal and then in hexadecimal
+ *  form, followed by a line break.
+ *  The intended properties can be realized by implementing \ref hex, \ref dec, \ref oct, \ref bin,
+ *  and \ref endl as functions (i.e., they are, in particular, not methods of \ref OutputStream)
+ *  that take (as first parameter) and return a reference to an OutputStream object.
+ *  When compiling the expression show above, the method
+ *  <tt>OutputStream& OutputStream::operator<< ((*f*) (OutputStream&))</tt>
+ *  is chosen when one of the functions \ref hex, \ref dec, \ref oct, \ref bin, or \ref endl
+ *  is streamed an \ref OutputStream, which finally will execute the passed function.
+ *
+ *  \note The term manipulator originates from the book
+ *        [The C++ Programming Language](http://www.stroustrup.com/4th.html)
+ *        by Bjarne Stroustrup. Refer to this book for further explanations.
+ */
+
+#pragma once
+
+#include "stringbuffer.h"
+
+/*! \brief The class OutputStream corresponds, essentially, to the class ostream
+ *  from the C++ IO-Stream library.
+ *
+ *  As relying on the method \ref Stringbuffer::put() is quite cumbersome when
+ *  not only printing single characters, but numbers and whole strings, the
+ *  class OutputStream provides a convenient way of composing output of variables of
+ *  varying data types.
+ *  Therefore, OutputStream implements shift operators `operator<<`` for various
+ *  data types (similar to those known from the C++ IO-Stream library)
+ *
+ *  For further convenience, OutputStream also allows printing integral numbers in
+ *  decimal, binary, octal, and hexadecimal format.
+ *  Remember that, for negative numbers, the sign is only printed when using the
+ *  decimal number system; for binary, octal, and hex, the number is printed as
+ *  stored in the machine word without interpreting the sign.
+ *  For Intel CPUs, two's complement is used for storing negative values, `-1`,
+ *  for example, will print hex `FFFFFFFF` and octal `37777777777`.
+ *
+ *  OutputStream's public methods/operators all return a reference to the object
+ *  they are called on (i.e. `*this`). Returning `*this` allows chaining those
+ *  stream operators in a single expression, such as
+ *  <tt>kout << "a = " << a</tt>;
+ *
+ *  At this point in time, OutputStream implements `operator<<` for chars, strings
+ *  and whole numbers. An additional `operator<<` allows using manipulators
+ *  whose detailed description is given below.
+ */
+
+class OutputStream {
+	OutputStream(const OutputStream&)            = delete;
+	OutputStream& operator=(const OutputStream&) = delete;
+
+ public:
+	/*! \brief Number system used for printing integral numbers (one of 2,
+	 *  8, 10, or 16)
+	 */
+	int base;
+
+	/*! \brief Default constructor. Initial number system is decimal.
+	 *
+	 *  \todo Implement Constructor
+	 *
+	 */
+	OutputStream() {}
+
+	/*! \brief Destructor
+	 */
+	virtual ~OutputStream() {}
+
+	/*! \brief Clears the buffer.
+	 *
+	 *  Pure virtual method that must be implemented by derived
+	 *  (non-abstract) classes.
+	 *  Formatting of the buffer contents can be implemented differently by
+	 *  different derived classes
+	 */
+	virtual void flush() = 0;
+
+	/*! \brief Print a single character
+	 *
+	 *  \todo Implement Operator
+	 *
+	 *  \param c Character to be printed
+	 *  \return Reference to OutputStream os; allows operator chaining.
+	 */
+	OutputStream& operator << (char c);
+
+	/*! \brief Print a single character
+	 *  \note In C, there are no "characters" in that sense, but only
+	 *  integers. A `char`, therefore, is a 8 bit number with the most
+	 *  significant bit (optionally) representing a sign.
+	 *  Depending on whether signed or not, the value ranges are [-128, 127]
+	 *  or [0; 255]. For GCC, a `char` is a `signed char`.
+	 *
+	 *  \todo Implement Operator
+	 *
+	 *  \param c Character to be printed
+	 *  \return Reference to OutputStream os; allows operator chaining.
+	 */
+	OutputStream& operator << (unsigned char c);
+
+	/*! \brief Printing a null-terminated string
+	 *
+	 *  \todo Implement Operator
+	 *
+	 *  \param string String to be printed
+	 *  \return Reference to OutputStream os; allows operator chaining.
+	 */
+	OutputStream& operator << (const char* string);
+
+	/*! \brief Print a boolean value
+	 *
+	 *  \todo Implement Operator
+	 *
+	 *  \param b Boolean to be printed
+	 *  \return Reference to OutputStream os; allows operator chaining.
+	 */
+	OutputStream& operator << (bool b);
+
+	/*! \brief Print an integral number in radix `base`
+	 *
+	 *  \todo Implement Operator
+	 *
+	 *  \param ival Number to be printed
+	 *  \return Reference to OutputStream os; allows operator chaining.
+	 */
+	OutputStream& operator << (short ival);
+
+	/// \copydoc OutputStream::operator<<(short)
+	OutputStream& operator << (unsigned short ival);
+
+	/// \copydoc OutputStream::operator<<(short)
+	OutputStream& operator << (int ival);
+
+	/// \copydoc OutputStream::operator<<(short)
+	OutputStream& operator << (unsigned int ival);
+
+	/// \copydoc OutputStream::operator<<(short)
+	OutputStream& operator << (long ival);
+
+	/// \copydoc OutputStream::operator<<(short)
+	OutputStream& operator << (unsigned long ival);
+
+	/// \copydoc OutputStream::operator<<(short)
+	OutputStream& operator << (long long ival);
+
+	/// \copydoc OutputStream::operator<<(short)
+	OutputStream& operator << (unsigned long long ival);
+
+	/*! \brief Print a pointer as hexadecimal number
+	 *
+	 *  \todo Implement Operator
+	 *
+	 *  \param ptr Pointer to be printed
+	 *  \return Reference to OutputStream os; allows operator chaining.
+	 */
+	OutputStream& operator << (const void* ptr);
+
+	/*! \brief Calls one of the manipulator functions.
+	 *
+	 *  Method that calls the manipulator functions defined below, which
+	 *  allow modifying the stream's behavior by, for instance, changing the
+	 *  number system.
+	 *
+	 *  \todo Implement Operator
+	 *
+	 *  \param f Manipulator function to be called
+	 *  \return Reference to OutputStream os; allows operator chaining.
+	 */
+	OutputStream& operator << (OutputStream& (*f) (OutputStream&));
+};
+
+/*! \brief Enforces a buffer flush.
+ *
+ *  \todo Implement Manipulator
+ *
+ *  \param os Reference to stream to be flushed.
+ *  \return Reference to OutputStream os; allows operator chaining.
+ */
+OutputStream& flush(OutputStream& os);
+
+/*! \brief Prints a newline character to the stream and issues a buffer flush.
+ *
+ *  \todo Implement Manipulator
+ *
+ *  \param os Reference to stream to be modified.
+ *  \return Reference to OutputStream os; allows operator chaining.
+ */
+OutputStream& endl(OutputStream& os);
+
+/*! \brief Print subsequent numbers in binary form.
+ *
+ *  \todo Implement Manipulator
+ *
+ *  \param os Reference to stream to be modified.
+ *  \return Reference to OutputStream os; allows operator chaining.
+ */
+OutputStream& bin(OutputStream& os);
+
+/*! \brief Print subsequent numbers in octal form.
+ *
+ *  \todo Implement Manipulator
+ *
+ *  \param os Reference to stream to be modified.
+ *  \return Reference to OutputStream os; allows operator chaining.
+ */
+OutputStream& oct(OutputStream& os);
+
+/*! \brief Print subsequent numbers in decimal form.
+ *
+ *  \todo Implement Manipulator
+ *
+ *  \param os Reference to stream to be modified.
+ *  \return Reference to OutputStream os; allows operator chaining.
+ */
+OutputStream& dec(OutputStream& os);
+
+/*! \brief Print subsequent numbers in hex form.
+ *
+ *  \todo Implement Manipulator
+ *
+ *  \param os Reference to stream to be modified.
+ *  \return Reference to OutputStream os; allows operator chaining.
+ */
+OutputStream& hex(OutputStream& os);

object/stringbuffer.cc

@@ -0,0 +1,2 @@
+#include "stringbuffer.h"
+

object/stringbuffer.h

@@ -0,0 +1,76 @@
+/*! \file
+ *  \brief \ref Stringbuffer composes single characters into a buffer
+ */
+
+#pragma once
+
+/*! \brief The class Stringbuffer composes single characters into a longer text that can be processed on block.
+ *
+ *  To make Stringbuffer as versatile as possible, the class does make
+ *  assumptions about neither the underlying hardware, nor the meaning of
+ *  "processing". When flush() is called (i.e., either on explicit request or
+ *  once the buffer is full). To be hardware independent, flush() is to be
+ *  implemented by the derived classes.
+ *
+ *  \par Hints for Implementation
+ *  Use a buffer of fixed size for caching characters, which should be
+ *  accessible by derived classes.
+ *  Keep in mind that the derived implementation of flush() will need to know
+ *  about numbers of characters in the buffer.
+ *
+ *  \par Notes
+ *  Reason for the existence of this class is that generating longer texts is
+ *  often implemented by assembly of small fragments (such as single characters
+ *  or numbers).
+ *  However, writing such small fragments directly to (for example) screen is
+ *  quite inefficient (e.g., due to the use of IO ports, syscalls, or locks) and
+ *  can be improved drastically by delaying the output step until the assembly
+ *  is finished (or the buffer runs full).
+ */
+class Stringbuffer {
+	// Prevent copies and assignments
+	Stringbuffer(const Stringbuffer&)            = delete;
+	Stringbuffer& operator=(const Stringbuffer&) = delete;
+
+	// All variables and methods are protected in this class,
+	// as the derived classes need direct access to be buffer,
+	// the constructor, the destructor, and the method put.
+	// flush() is to be implemented either way and may be redefined
+	// as public.
+
+ protected:
+	/// buffer containing characters that will be printed upon flush()
+	char buffer[80];
+	/// current position in the buffer
+	long unsigned pos;
+
+	/*! \brief Constructor; Marks the buffer as empty
+	 *
+	 *  \todo Complete Constructor
+	 */
+	Stringbuffer() { }
+
+	/*! \brief Inserts a character into the buffer.
+	 *
+	 *  Once the buffer is full, a call to flush() will be issued and
+	 *  thereby clearing the buffer.
+	 *
+	 *  \todo Implement Method
+	 *
+	 *  \param c Char to be added
+	 */
+	void put(char c);
+
+	/*! \brief Flush the buffer contents
+	 *
+	 *  This method is to be defined in derived classes, as only those know
+	 *  how to print characters.
+	 *  flush() is required to reset the position pos.
+	 */
+	virtual void flush() = 0;
+
+ public:
+	/*! \brief Destructor (nothing to do here)
+	 */
+	virtual ~Stringbuffer() { }
+};

test-stream/Makefile

@@ -0,0 +1,22 @@
+VERBOSE = @
+OBJDIR = build
+CXX = g++
+MKDIR = mkdir
+CC_SOURCES = ../test-stream/console_out.cc ../test-stream/test.cc ../test-stream/file_out.cc ../object/outputstream.cc ../object/stringbuffer.cc
+CXXFLAGS = -std=c++11 -m64 -I../object -I.
+TARGET = $(OBJDIR)/test
+
+all: run
+
+run: $(TARGET)
+	@./$<
+
+$(TARGET): $(CC_SOURCES)
+	$(VERBOSE) $(MKDIR) -p $(OBJDIR)
+	$(VERBOSE) $(CXX) -o $@ $(CXXFLAGS) $^
+
+clean:
+	@echo "RM		$(OBJDIR)"
+	$(VERBOSE) rm -rf $(OBJDIR)
+
+.PHONY: all run clean

test-stream/console_out.cc

@@ -0,0 +1,2 @@
+#include "console_out.h"
+

test-stream/console_out.h

@@ -0,0 +1,33 @@
+/*! \file
+ *  \brief \ref ConsoleOut "Console" \ref OutputStream "output" (for the voluntary C++ exercise only)
+ */
+
+#pragma once
+
+#include "outputstream.h"
+
+/*! \brief Write text on console (`STDOUT`)
+ *
+ * This class allows writing to the console similar to `std::cout` from the standard C++ library.
+ * The class is derived from \ref OutputStream.
+ */
+class ConsoleOut : public OutputStream {
+	// Prevent copies and assignments
+	ConsoleOut(const ConsoleOut&)            = delete;
+	ConsoleOut& operator=(const ConsoleOut&) = delete;
+
+ public:
+	/*! \brief Constructor
+	 *
+	 *  \todo Implement constructor
+	 */
+	ConsoleOut();
+
+	/*! \brief Output the string on the screen.
+	 *
+	 * The implementation should solely use `putchar()`
+	 *
+	 *  \todo Implement virtual method
+	 */
+	virtual void flush() override;  //NOLINT
+};

test-stream/file_out.cc

@@ -0,0 +1,2 @@
+#include "file_out.h"
+

test-stream/file_out.h

@@ -0,0 +1,59 @@
+/*! \file
+ *  \brief \ref FileOut "File" \ref OutputStream "output" (for the voluntary C++ exercise only)
+ */
+
+#pragma once
+
+#include "outputstream.h"
+
+/*! \brief Write text into file
+ *
+ * This class allows a comfortable output to a file only by using the elementary
+ * system calls `open()` / `write()` / `close()` and (optional) `fsync()`.
+ * The class is derived from \ref OutputStream.
+ */
+class FileOut : public OutputStream {
+    // TODO: Add (private) attributes, if required
+
+ public:
+	/*! \brief Constructor
+	 *
+	 * Opens the file for writing using the system call `open()`.
+	 * \param path Path to the output file
+	 *
+	 *  \todo Implement constructor
+	 */
+	explicit FileOut(const char * path);
+
+	/*! \brief Destructor
+	 *
+	 * Close the output file (using the system call `close()`)
+	 *
+	 *  \todo Implement destructor
+	 */
+	virtual ~FileOut();
+
+	/*! \brief Get path of the output file
+	 *
+	 *  \return Path to output file (as defined in constructor)
+	 *
+	 *  \todo Implement Method
+	 */
+	const char * getPath();
+
+	/*! \brief Number of output files which are currently opened (with this class)
+	 *
+	 *  \return Number of active files
+	 *
+	 *  \todo Implement Method
+	 */
+	static int count();
+
+	/*! \brief Write the string to the open file.
+	 *
+	 * The implementation should only use the system calls `write()` and `fsync()`.
+	 *
+	 *  \todo Implement virtual Method
+	 */
+	virtual void flush() override;  //NOLINT
+};

test-stream/test.cc

@@ -0,0 +1,36 @@
+#include "console_out.h"
+#include "file_out.h"
+
+ConsoleOut cout;
+FileOut foo("foo.txt");
+
+int main() {
+	cout << "Console Test  <stream result> -> <expected>" << endl;
+	cout << "	bool: " << true << " -> true" << endl;
+	cout << "	zero: " << 0 << " -> 0" << endl;
+	cout << "	binary: " << bin << 42 << dec << " -> 0b101010" << endl;
+	cout << "	octal: " << oct << 42 << dec << " -> 052" << endl;
+	cout << "	hex: " << hex << 42 << dec << " -> 0x2a" << endl;
+	cout << "	uint64_t max: " << ~((unsigned long long)0) << " -> 18446744073709551615" << endl;
+	cout << "	int64_t max: " << ~(1ll<<63) << " -> 9223372036854775807" << endl;
+	cout << "	int64_t min: " << (1ll<<63) << " -> -9223372036854775808" << endl;
+	cout << "	some int64_t: " << (-1234567890123456789) << " -> -1234567890123456789" << endl;
+	cout << "	some int64_t: " << (1234567890123456789) << " -> 1234567890123456789" << endl;
+	cout << "	pointer: " << reinterpret_cast<void*>(1994473406541717165ull) << " -> 0x1badcafefee1dead" << endl;
+	cout << endl;
+
+	cout << "File Test" << endl
+	     << "	currently open: " << FileOut::count() << endl
+	     << "	writing into '" << foo.getPath() << "'..." << endl;
+	foo << "C makes it easy to shoot yourself in the foot;" << endl;
+	foo << "C++ makes it harder, but when you do it blows your whole leg off." << endl;
+	 {
+		FileOut bar("bar.txt");
+		cout << "	opened the " << FileOut::count() << ". file, " << endl;
+		cout << "	writing into '" << bar.getPath() << "'..." << endl;
+		bar << "Anyone who claims to have the perfect programming language is either a fool or a salesman or both" << endl;
+	 }
+	cout << "	having only " << FileOut::count() << " file opened since the other is out of scope" << endl;
+
+	return 0;
+}