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>