[LLVMdev] Google SoC Proposal Draft

[Chandler Carruth]

Hello,

I have been working on a proposal for Google's Summer of Code with LLVM. I
have pasted the proposal below, and I would welcome any feedback before I
submit it. I am very excited about the prospect of working on this with
LLVM!

-Chandler

----
# Proposal for Google Summer of Code Project

## Prototype INC Compiler

###  Abstract

This project will develop a prototype front end for a new language, INC
(INC's
Not C: http://chandlerc.net/INC/), on top of the world-class Low-Level
Virtual
Machine (LLVM: http://llvm.org/) compiler infrastructure. It will bring a
new
and valuable language to LLVM and help solidify the front end toolkit into
a
more robust solution for compiler development. Additionally, it will ground
the language's design in a concrete implementation and provide a starting
point
 for a polished and fully functional standard implementation of the it.

The INC language is a new object-oriented and low-level system programming
language. It has influences from the structural and object-oriented
programming. The language provides a modern and robust platform for
developing
performance-oriented and system-level applications and libraries.
Overarching
goals of the language include near-orthogonality, simplicity, clarity of
syntax, and avoiding implicit behaviors. My Master's thesis at Wake Forest
University includes the development and specification of INC.

###  Deliverables

*  A C++ parsing library for INC
*  A compiler combining the parsing library with LLVM for code generation
*  Accompanying documentation for the parsing library, compiler
   construction, and compiler use
*  A draft specification of the language based directly on my thesis

###  The INC Language

INC is most similar to C++ and derives much of its inspiration from the
good,
the bad, and the ugly aspects of that language. INC has a similar
object-oriented structure and procedural syntax. It begins to differentiate
itself by offering significantly improved code readability and
maintainability
to the code. The syntax is simpler and more concise than C++, avoiding
subtleties that can be easily confused. This also reduces the learning curve
of
 INC, making it less prone to programmer errors.

The language also expands on the concept of operator overloading. It does
away
with implicit operator precedence allowing operator definitions to define
completely new operators. It focuses on a safer multiple inheritance system
rather than template-driven instantiation to unify common code. Lastly, it
re-thinks and simplifies memory management, providing a more integrated view
of
 memory, pointers, and arrays. All of these features help INC address issues

with real-time applications, numerical computation, and high-performance
computing, as well as general purpose and system programming. Examples and
more
 detailed explanations of these features are available on the INC website.

###  Existing Research and Work

I have done extensive research on this language, first as an undergraduate
at
Wake Forest University, and currently as a Master's student there. The
project
grew into my thesis under the direction of Dr. Todd Torgersen, and I will
have
completed an initial draft including a full specification of the language by

the end of the academic year. I have been consulting heavily with Reid
Spencer,
 the lead developer of LLVM's front end toolkit, regarding my thesis work
since
beginning it during the summer of 2006. He has provided insight and guidance
in
ensuring the language will be a good fit for LLVM as a compiling
infrastructure. I began helping with LLVM as well in December of 2006 to
familiarize myself with the project's structure and organization.

I am also involved with several other open source projects. I am the primary

developer of several upcoming open projects for Retina Software,  a
cross-platform game technology company I co-founded. I am working with  a
student group in a class to design an open source software construction tool

called RCons. I work actively with Gentoo Linux, eINIT, and Retrospectiva
providing feedback, testing, filing and fixing bugs. I have helped with
dvd::rip, Trac, and Bitten in the past in similar roles.

###  Proposed Project for the Summer of 2007

I propose to work with the LLVM project to craft a front end to parse and
compile INC, a new language I have been developing for the past 3 years.
LLVM's
 will provide much of the semantic translation for the language through its
Abstract Syntax Tree (AST). It also has mechanisms to translate the AST into
an
 intermediate representation which can be transformed, optimized, and
lowered to
 target-specific assembler instructions. Together these form a full featured

compiler infrastructure that will make the implementation of a front end  a
reasonable and effective project for a summer.

The front end will consist of a general parsing library for the language.
This
library will be well documented and usable in other projects such as a
syntax
directed editor or code validation tools. A compiling tool will then utilize

this parsing system to generate LLVM's AST structures. This tool will be
documented both in its use and its integration into LLVM's AST and the
parsing
library. Finally, a draft specification, as implemented in the prototype
compiler, will be released as part of the deliverables.

This project's scope is limited to a prototype compiler. It is not intended
to
be feature complete or production ready. It must provide sufficient
functionality to compile non-trivial programs and demonstrate the language's

base feasibility. It must also form a good starting point for further
implementation work.

###  Schedule for Project

The first six weeks of the project will be focused on framework development,

achieving minimal functionality, and testing. The classic ``Hello World''
program will be the target for this phase, providing a baseline of
functionality, and a test for integration with all components. This will
also
form a clear metric for mid-term evaluation of the project.

Weeks 1 and 2:
    Establish a parsing framework in the library, basic   file loading, the
    most basic syntax constructs, and XML parse tree output   for testing.


Week 3:
    Integrate syntax constructs for ``Hello World'' program, and   verify
    parsing through the tree output.

Weeks 4, 5, and 6:
    Establish compilation tool using parsing library,   and connect syntax
    constructs used in ``Hello World'' to semantic   counterparts in the
LLVM
    AST, including resolving the system IO semantics   and implementation.

The second six weeks will focus on component-wise expansion of the framework
to  support the desired prototype features. Each aspect will be tested as it
is
added to the relevant framework to ensure a working final product. It will
culminate in the working prototype compiler and provide a clear benchmark
for
overall success of the project.

Weeks 7 and 8:
    Extend parsing to support prototype subset of syntax,   and verify every
    construct using XML parse tree output.

Weeks 9, 10, 11, and 12:
    Move through each syntax construct   implementing it semantically
    through LLVM, and verify generated code   through a test suite for each
    construct.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/llvm-dev/attachments/20070323/814802c4/attachment.html>