Commit 88d9a29e authored by Christian Dietrich's avatar Christian Dietrich
Browse files

Skeleton

parents
# 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-x86
script:
- if [ -f Makefile ] ; then make clean ; make ; fi
# Optional: Use Clang 10
#Clang-Build:
# image: inf4/stubs:clang-x86
# variables:
# CXX: "clang++-10"
# script:
# - make clean ; make
# Check style guide using cpplint
linter:
image: inf4/stubs:cpplint
script:
- if [ -f Makefile ] ; then make clean ; make lint ; fi
# 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,-build/include,-whitespace/end_of_line
linelength=120
Copyright 1998-2002 Institut für Verteilte Systeme (IVS), Otto-von-Guericke-Universität Magdeburg
Copyright 2002-2019 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.
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
#include "outputstream.h"
/*! \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);
#include "stringbuffer.h"
/*! \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()
// TODO: Complete code.
{ }
/*! \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() { }
};
VERBOSE = @
OBJDIR = build
CXX = g++
MKDIR = mkdir
CC_SOURCES = ../test-stream/test.cc ../test-stream/console_out.cc ../test-stream/file_out.cc \
../object/outputstream.cc ../object/stringbuffer.cc
CXXFLAGS := -std=c++11 -I../object -I.
CXXFLAGS += -m32
TARGET = $(OBJDIR)/test
all: run
run: $(TARGET)
@./$<
$(TARGET): $(CC_SOURCES)
@echo "CXX $@"
$(VERBOSE) $(MKDIR) -p $(OBJDIR)
$(VERBOSE) $(CXX) -o $@ $(CXXFLAGS) $^
clean:
@echo "RM $(OBJDIR)"
$(VERBOSE) rm -rf $(OBJDIR)
.PHONY: all run clean
// vim: set noet ts=4 sw=4:
#include "console_out.h"
// vim: set noet ts=4 sw=4:
/*! \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
};
// vim: set noet ts=4 sw=4:
#include "file_out.h"
// vim: set noet ts=4 sw=4:
/*! \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
};
#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 << " uint32_t max: " << ~((unsigned int)0) << " -> 4294967295" << endl;
cout << " int32_t max: " << ~(1<<31) << " -> 2147483647" << endl;
cout << " int32_t min: " << (1<<31) << " -> -2147483648" << endl;
cout << " some int32_t: " << (-123456789) << " -> -123456789" << endl;
cout << " some int32_t: " << (123456789) << " -> 123456789" << endl;
cout << " pointer: " << reinterpret_cast<void*>(3735928559u) << " -> 0xdeadbeef" << 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;
}
all: help
help:
@echo "Create and manage BSB virtual machine"
@echo
@echo " make update - Update the local machine with ansible configuration (playbook.yml)"
@echo
update:
sudo ansible-playbook \
--connection=local \
--inventory 127.0.0.1,\
--limit 127.0.0.1 \
playbook.yml
.PHONY: help
# This guide is optimized for Vagrant 1.8 and above.
# Older versions of Vagrant put less info in the inventory they generate.
Vagrant.require_version ">= 1.8.0"
Vagrant.configure(2) do |config|