Klang - The Kaiser language

This is the project for Klang - the Kaiser language.

Authors

This code was in equal parts developed by Dennis Kaiser and Marvin Kaiser at the RheinMain University of Applied Sciences for the Compilers course.

Usage

Pass source code via stdin

example call to print help java -cp target/klang-1.0-jar-with-dependencies.jar de.hsrm.compiler.Klang.Klang -h

Arguments:

• -h Print this help
• --evaluate: Evaluates the given source code
• --pretty: Pretty print the given source code
• --no-compile: Do not compile the source code
• --no-main: Do not generate main function, will be generated as 'start'. Useful for testing

The makefile can be used to perform various functions more easily:

• make build simply builds the compiler
• make clean cleans up all generated output
• make generates code.s from code.k in root folder
• make pretty prettifies code.k and writes to pretty.k
• make eval evaluates code.k
• make test runs tests from src/test/
• make cleanTests cleans files generated from tests

Functionality

The KLang compiler supports generation of AMD64 assembly code, as well as prettifying and evaluating the KLang code.

Simple Expressions

The following simple expressions are supported. Expressions need to be put in paranthesis. When using comparison operators, the expressions evaluate to 0 for false and 1 for true.

• Addition (+)
• Subtraction (-)
• Multiplication (*)
• Division (/)
• Modulo (%)
• Equality (==)
• Less Than (<)
• Less Than Or Equal (<=)
• Greater Than (>)
• Greater Than Or Equal (>=)
• Number Negation (-)

Examples:

(5 + 4)
(8 % 2)
(8 == 0)

Functions

Functions can be defined and called. A function call can be used like any other expression. Recursion is supported

Examples

function fun(x: int, y: int, z: bool): int {
  return x;
}

fun(1, 2, 3);

Statements

Several statements are supported:

• if
• variable declaration
• variable assignment
• return
• while
• do while
• for

Examples

function example(x: int, y: int, z: int): int {
  let a: int;
  let b: int = 0;
  if (x == y) {
    a = y;
  } else if (x == z) {
    a = z;
  } else {
    return b;
  } 
  return a;
}

function whileExample(end: int): int {
  let x: int = 0;
  while (x < end) {
    x = x + 1;
  }
  return x;
}

function doWhileExample(end: int): int {
  let x: int = 0;
  do {
    x = x + 1;
  } while(x < end);
  return x;
}

function forExample(end: int): int {
  let x: int = 0;
  for (let i: int = 0; i < end; i = i + 1) {
    x = x + 1;
  }
  return x;
}

Statically typed

KLang statically verifies the integrity of your code. These checks include:

• Type checking
• Ensuring that variables and functions in use are declared
• Ensuring that the arguments of a function call match the function definition
• Ensuring that a function returns something
• Ensuring that a function only returns data of the correct type

Data Types

• Integer "int"
• Boolean "bool"

Examples

You can declare types for parameters, return values and variables

function foo(start: int): boolean {
  let threshold: int = 10;
  return threshold < start;
}

Type annotations are required as per our parsing rules, so this will result in an error while parsing

function bar() {
  return 0;
}

This will throw an error since a boolean is returned, but int is declared as the return type

function baz(): int {
  return false;
}

This will throw an error since the function "bam" expects one argument but the call to this function provided none

function bam(a: int): int {
  return a;
}
bam();

This will throw an error since the first parameter of function "boo" has to be of type bool

function boo(a: bool): bool {
  return a;
}
boo(100);