XPS 0.2 Release Notes

1. Introduction
2. What's New?
   1. New Features
   2. Bugs Fixed
   3. Supported Platforms
3. Known Problems
   1. Experimental Features
4. Forward Looking Statements
5. Additional Information

Introduction

This document contains the release notes for the eXtensible Programming System (XPS), version 0.2. Here we describe the status of XPS, including new features and any known problems. The most recent version of this document can be found on the XPS 0.2 web site. If you are reading this significantly after the 0.2 release, you should go there because this document may be updated after the release.

For more information about LLVM, including information about the latest release, please visit the main XPS web site. If you have questions or comments, please use either the Feedback page or one of the e-mail lists.

Note that if you are reading this page from sources checked out with subversion, the websvn pages, or the main XPS web page, this document applies to the next release, not the current one. To see the release notes for the current or previous releases, please visit the releases page.

What's New?

This is the second public release of XPS.

XPS 0.2 is a pre-release of the eXtensible Programming System. It is a development milestone and provides no significant functionality at this time. XPS 0.2 is known to parse and validate XPL-core programs correctly. It has been mostly re-architected and reduced from the 0.1.9 release two years prior.

New Features in XPS 0.2

A lot has happened in the last two years since XPS 0.1.9 was released. Needless to say, that's too long between releases, but it was somewhat necessary. About 1.5 years was consumed with assisting the LLVM (Low Level Virtual Machine) project in providing features necessary for XPS. The other portion was struggling with difficulties in selecting the right framework for XML validation. Both of these major hurdles are now completed and significant and faster progress will be made on XPS.

Here are the main highlights of what has changed:

1. XPS is now hosted on its own internet server, http://x-p-s.net/. The SourceForge project is now being used simply as a referal to the XPS site and for assistance with downloading release tarballs. No development activity occurs with SourceForge any more.
2. The source code repository has been switched from CVS hosted by SourceForge to a Subversion server hosted by eXtensible Systems, Inc. You can get the latest source code using http://x-p-s.org/xps as the Subversion URL.
3. Several source code modules that were in 0.1.9 have disappeared in 0.2.0. The code is not lost, there just hasn't been a reason to add them to the new Subversion repository yet. In particular, the "mem", "space", "meta", and possibly "adt" modules are to be revived fairly soon. The tool modules ("xplec", "xpsd", and "xpsh") will not be revived until they're needed per the release plan milestones. When they are revived, they'll be placed in the "tools" directory, not "xps".
4. XPS is now based on the LLVM compiler infrastructure. While the integration with LLVM in this release is minimal, there will be much more to come. We believe the decision to use LLVM rather than GCC or some other back end framework is a huge win for XPS. Although LLVM, at 5 years old, is young by compiler standards, it is by far the best designed compiler infrastructure available. Using LLVM does several things for the XPS project:
   • Defines the low level semantics of xpl-core (base XPL language)
   • Provides high-end code optimizations that we don't have to write
   • Provides a framework for bytecode and JIT compilation
   • Speeds our development by providing the mid-level IR using an excellent C++ library interface
   • Allows us to extend the optimizations to do XPL-specific things
   • Provides the framework for building life-long optimization into XPS
   • Serves as the framework for building the XPS compiler server
5. Since XPS has its own makefile system, we adopted it in XPS too. This is one of the significant integrations betwen XPS and LLVM that occurred in this release. The decision to move away from automake was not difficult as automake tended to complicate things. The LLVM makefile system is pretty clean and reasonably well documented.
6. A major shift in XML validation from XML Schema to Relax NG has occurred. Relax NG was chosen because it is, in Reid's opinion, vastly superior to the XML Schema even though the latter is the "official" standard for XML. This is, unfortunately, a pity. Relax NG provides a simpler and more convenient syntax for schema specification and it also allows you to specify things that XML Schema can't (like schema rules that say you can have an attribute or an element but not both). Unfortunately, the decision to go with Relax NG led to a significant delay in the XPS 0.2 release due to the lack of reliable implementations of Relax NG in C++. For more details on Relax NG, you should visit Thai Open Source
7. The major accomplishment in this release is the inclusion of JING into the XPL source base. JING is an XML validator using Relax NG written by James Clark, the author of the original Relax NG specification and a well known XML guru. Although written in Java, JING is a competent implementation of the Relax NG specification and compilation to native code via GCJ has given us a way to integrate it with C++ and not be penalized for execution speed or require the use of a JVM. The original JING source code was imported into XPS in the xps/jing directory. Several modifications were necessary to get it to compile and work correctly with GCJ (Gnu Java Compiler).
8. The XML and XPL parsing interfaces were completed in this release. These two interfaces, xps/xml/Handler.h and xps/xpl/Handler.h, define the set of events that are generated as a result of parsing XML documents and XPL programs, respectively. The XPL interface make it much easier to deal with XPL programs since the low level XML parsing events are hidden and the events generated on the interface are more aligned with the semantic constructs of the XPL language.
9. A new backend for LLVM that generates valid XPL programs has been added in the xps/xplbe directory. This "back end" can be used with the LLVM llc tool to generate XPL from any LLVM input. This means it is entirely possible to convert a C, C++, or Stacker program into XPL via LLVM's intermediate representation. Using the backend should be done like this:

   
     llc -load /path/to/lib/libXPSxplbe.so -march=xpl input.ll -o output.xpl
     

   This instructs the llc program to generate XPL output into the file named output.xpl from the input named input.ll which must be valid LLVM assembly code. See the LLVM documentation for more details on this.
10. A significant test suite was imported from LLVM 1.5. Importation was done via the XPL Back End for LLVM (see previous item). This test suite has over 1000 test cases that test every semantic aspect of XPL. A simple target in the test/Makefile (update-from-llvm) allows the test suite to be updated whenever the XPLBE or the LLVM test suite changes. The test suite simply uses XPS 0.2's ability to generate XPL source from XPL source to ensure the input and the output match. This verifies the parsing, validation, and generation of XPL code.

Significant Bugs Fixed in XPS 0.2

No official bugs were fixed in this release. However, this is the first release that actually does something, which has been a long-standing bug on its own. :)

Supported Platforms

XPS is known to work on the following platforms:

• Fedora Core 3
• SUSE Linux 8
• FreeBSD

Additional platforms will be tested in future releases

Known Problems

This section contains all known problems with XPS, listed by component. As new problems are discovered, they will be added to these sections. If you run into a problem, please let us know so we can add it here.

Experimental Features

None. However, this is a very early release of XPS so the whole release could be considered to be experimental.

Problems With xplc

xplc is the XPL compiler.

• Most of the options don't work right now. These are features that were either disabled to get the release out or placeholders for future functionality.

Problems With xvm

xvm is the eXtensible Virtual Machine (runtime)

• This program simply prints out a line saying that "xvm still needs to be written". This program probably won't get much attention until the 0.4 or 0.5 release.

Problems With xplbe

xplbe is the XPL Back End. It generates XPL from LLVM

• None known.

Forward Looking Statements

Take this with a grain of salt, but here's what we plan to do next with XPS.

1. Complete the xps/xpl/LLVMGenerator.cpp implementation. This will give us an XPL compiler that can generate executable code.
2. Beef up the test harness so we can start testing real
3. Make sufficient modifications to LLVM's llvmc and llvm-ld tools so that XPS can use them as the basis for compiling XPL programs.
4. Extend the XPL compilation framework to handle language extensions. This will be done by permitting new handlers to be installed during the parsing process to handle "foreign" elements (those not defined by xpl-core language).

Additional Information

Much additional information about XPS is available on the web:

• Main XPS Web Site
• XPS Documentation
• Source Code Browsing
• LLVM Compiler Infrastructure

If you have any questions or comments about LLVM, please feel free to leave a note on the Feedback Page or drop us an e-mail message on one of the E-Mail Lists.