EDAN70: Project in Computer Science

LR conflict demonstrator
Daniel Eliasson and Christian Olsson
Abstract:
It can be difficult to resolve conflicts in a LR grammar. This tool hopes to help alleviate this problem. The tool finds a string of symbols leading up to a conflict in order to give an example of something that is ambigous to the parser. We do this by building a graph from the output dumped by the CUP parser generator and doing a search from the start node of the graph to the conflict state, generating a string of symbols.
(paper) (code)

Object-oriented metrics for Java programs
Olle Tervalampi-Olsson and Marcus Lacerda
Abstract:
A key aspect of software metrics, are dependencies. That is, how different classes and packages make use of each other to construct a program. Object-oriented metrics allow these dependencies to be analyzed and give an overview of how stable and healthy the program is for some aspects. We introduce a new tool that is an extension of the JastAddJ compiler and calculates these metrics on java source code, similar in functionality to JDepend and some functions that exist in CodePro Analytix.
(paper) (code)

Package metrics on Java projects
Joel Lindholm and Johan Thorsberg
Abstract:
A tool for calculating metric suits over both java source code and its belonging libraries has been implemented. As of this report the tool is able to use the Chidamber & Kemerer object-oriented metrics suite and the Martin Metric suite. A configuration file exist and is used to change the behavior of the calculations and its output. There also is an ignore file that can be used to ignore specific packages, these will not be included in the calculations.
The tool has been implemented as extension to the JastAddJ compiler, and is therefore easily extended or modified.
Evaluation proved that the tool have an acceptable evaluation time.
(paper) (code)

JastAdd library for name analysis
Daniel Forsman and Jakub Gorski
Abstract:
During the process of constructing a compiler there are several steps that are crucial to the analysis of code. This paper will stage one of these steps, namely the development of a name analysis library. This will allow programmers to easily modify the name analysis, which will enable more versatile prototyping of compilers at the name analysis stage. By exploring the possibility for a name analysis library for JastAdd, an attempt to implement a generic name analysis library will be made, such that it supports several languages.
(paper) (code)

A SimpliC compiler in Scala and Kiama
Johan Andersson
Abstract:
JastAdd and Kiama are both tools that support working with attribute grammars in compiler construction. JastAdd is a tool that generates Java code, while Kiama is a Scala library.
In this project, a compiler was created for a simple C-like language, using Kiama and Scala. A compiler for this language has previously been implemented, but instead using JastAdd.
These two compilers were then evaluated in terms of code size and performance, to see how well they performed. The goal of this project was to compare Kiama with the more widespread tool JastAdd.
(paper)

Compiler in Scala and Kiama in comparison with JastAdd
Andree Ekroth and Felix Mulder
Abstract:
This paper examines the main differences in usability and performance between Kiama, a Scala library for language processing, and the combination of tools used in course Compilers EDAN65 offered at Lund Institute of Technology. Specifically the focus of the paper is how well Kiama can perform with the aid of Scala compared to JastAdd which generates Java code. The Scala language is considered a more advanced, and by some an experimental language when compared to Java. As such there will also be a focus on how feasible the usage of Kiama is versus using JastAdd or alternatively a compiler implemented by hand for production.
(paper)