Intellectual Cramps

I've been trying the Athena Common Builder on the XQuery incubator project with some odd ball dependencies on and off over the last few months.

1. Tried the XQuery Incubator project in WTP-Incubator with Maps. Fail.
2. Tried the XQuery Incubator project building from local workspace. Fail.

The problem with the XQuery project is that it has a Binary only bundle that it needs to jar up. However Athena is expecting there to be source code for it to compile so it gets confused. There are open bugs for this and you can see the conversation I had with Nick in the XQuery bug in the Dash project.

So this brings me around to another issue. Webtools current build can only be run on the Build machine. It used to be able to run outside of that machine but over the years it lost that ability. One of the items in Continuous Integration is that a developer should be able to run a build on any machine with minimum setup. Also Developers should run a local build before they check in code just to make sure everything works. In order for this to happen, the builds have to meet the following criteria:

1. Be Insanely simple to setup and execute.
2. Be Super FAST. (i.e. 10 minutes or less).

So as an experiment I decided to try and take Athena Common Builder and run it against a more traditional eclipse project and not try to do anything that deviates from the eclipse norm. I've been wanting a local build for XSL Tools for a while, so I figured that would be a good project to go with. Here is what I found out:

1. XSL Tools builds successfully with Athena!!!!
2. There are some gotchas though to getting it going.

The main thing with XSL Tools is that it is now also bundled with the standard WST download zip that comes from eclipse. So in order to get a successful build, I had to remove the XSL, XPath 2, and XPath jars from the zip. The other gotcha I ran into was a mistyping of where my Java Runtime environment resided. The last gotcha is that I need to figure out how to configure for a local build, and that is Jar signing. I don't need it for a local build, and would rather skip it altogether for commit related builds.

Total runtime though was less than 5 minutes for compilation and checkout. So this is in the acceptable range. I know that the XSL Tools unit tests take less than 3 minutes to run (actually about 2 minutes total, running over 3000 unit tests). So even with unit testing completed, the build easily falls under the 10 minute time limit.

Update: To avoid signing of jars, in your build.properties file add: skipSign=true

Joomla and other CMS systems like Drupal have grown to rival many of the commercial offerings for a "free as in beer" price. However, like most open source, you get what you pay for in the way of support and feature enhancements. I've been using DocMan for document management. It works well but has a few kinks in access control. One is that if a document is restricted and the user is not logged in it doesn't show a login screen, just a message saying that you need to login or aren't authorized for the document. I've seen many questions on the net asking how to handle this and get a login redirection (particularly if you don't display the login module on all screens). The following bit of code should work, if you add it to your DocMan.php file in the components folder.

Around line 60 in docman.php add the following:

  $app =& JFactory::getApplication();
  // Redirect to login
  $uri        = JFactory::getURI();
  $return     = $uri->toString();

  $url  = 'index.php';
  $url .= '?return='.base64_encode($return);
  $app->redirect($url, "Your error message here.");

Make sure to comment out the showMsgBox(_DML_NOLOG); function call. This has been tested to work with Joomla 1.5 and the latest version of DocMan. As with all code from the Internet, use at your own risk, and I'm not responsible if your site does not work after using it.

Okay, I've got a cramp that needs to be dealt with. Continuous Integration specifies that builds can happen in stages, and should happen in stages. I typically see four types of builds, eclipse projects tend to only follow three of the four at most.

1. Commit Build - Code is checked in, and built from head. Fast builds, that provide feedback early. Most eclipse projects don't have this type of build.
   
2. Integration Build - If you have multiple components and multiple projects, you check out and build them all and test. This is what Eclipse Projects have as their builds.
3. Nightly Builds - happen once a day maybe late at night early in the morning. Should occur with a particular tag or from a head snapshot. Eclipse projects may or maynot have this.
4. Milestone/Release Builds - A build based off a particular tag or set of code to be consumed by the general public. Some projects will promote a nightly build or Integration Build as their release.

In honor of Nick Boldt, I'll keep this short. You need all four build types as they provide different levels of verification. Ideally Commit builds should be less than 20 minutes total run time. You should also be able to release at any given time if you keep your builds green.

I'm a big proponent that documentation should be singled sourced. The same information should be generated into multiple formats from one common source. I personally don't think ODT, Word, or some of the more traditional tools used for writing documentation do this very well. Style and formatting get to tied into the document itself. However one of the features these tools do well is showing what has changed from multiple people working on a document.

I happen to use DocBook for my single sourcing of documentation. We use it at work for generating all of our documentation in HTML and PDF formats. However one of the difficulties is knowing what has changed easily between versions of a document. DocBook has a revision flag but this is a pain to maintain manually. Enter a nice utility (though still beta) from Norman Walsh called diffmk. It will take two XML documents and mark it up with the differences between them. It also includes a docbook.xsl stylsheet to then generate the appropriate revision flags to indicate Add, Change, Delete.

Here is a document before the diffmk run.


Here is one after using diffmk to compare versions of a merged DocBook XML file.


The process will highlight every change, addition, or deletion that has occurred between the two versions.

If you are using Eclipse WikiText to single source, you can leverage diffmk and it's stylesheets as well. Just include a step in there to generate the differences, and then follow the instructions provided by Robert Stayton's DocBookXSL: The Complete Guide to generate the appropriate output.

I've interacted with a wide variety of standards organizations over the years. Many of whom are trying to survive within the current economic recovery. It's hard to survive when your sole source of funding is on membership dues. It's also hard to recruit members when the perception is that it will take years for any changes to be made available to them.

Standard organizations in general are rightfully criticized for being slow moving organizations that by the time they react to change, the world has changed again, and business needs have changed. Implementers of standards can't wait for them to get changes out to them, so they go and extend the standard. Causing a splinter in implementations and possibly more harm than good.

The W3C is still a slow moving organization. It can take five to eight years before a specification finally makes it as a Recommendation. However, I will give kudos to the organization for one thing they are doing right. Change/Modification request tracking. More importantly it's Public! The W3C has made available to their workgroups, Bugzilla for tracking their work.

Unfortunately not all the workgroups take advantage of it. There are a handful of organizations, STAR being one, that make use of issue tracking systems to track the work and when it was completed. Visibility either to the public or at least to their membership can be key for helping adopters know what is coming and when it might be coming. Having the visibility into their process is a good thing, and should be encouraged.

Standard organizations to keep relevant need to do a better job of communicating with their community as a whole, not just their paying membership. Membership should have it's privileges but the community that adopts and uses the standard should have some clue as to what is coming down the pipeline. Communication is key. Knowing where something is and when it will be available can help in keeping a standard uniformed and might help lesson the one off implementations that adopters currently have to deal with.

RelaxNG Tooling:

The RelaxNG Tools (unofficial title), is in the process of getting started at the WTP Incubator. Currently we are in the middle of committer elections, and once this is done, we'll be submitting code to the Eclipse IP process for review. This has been a big hole in the XML portion of eclipse and I'm glad to see the individuals in the community step up to address this need.

XQuery:

There is some more movement on the XQuery incubator front. There are some promising signs that this project will really get a good kick in the pants in the coming months. Stay tuned for more information as it fleshes out.

JAXP and Cast Exceptions:

One of the things I hate about JAXP is the way that factories are identified and implementations are instantiated. When you are running in a container like OSGI or a Web Application Server, depending on where and when a particular XML Parser was configured and by who, can cause unexpected class cast exceptions. A couple of ways to avoid this are:

• Make sure that plugin dependencies are checked before JRE dependencies. So this way you have a better shot of getting a compatible configuration.
• Use a XML Parser Pool. Currently in eclipse I know of at least four different plugin projects that implement their own parser pool. OSGI also has it's own parser pool. What would be nice is if everybody could agree on one parser pool, and then specify the filters for the type of Parser they want.
• Don't use the Factories to instantiate your classes, if you always want to use a Xerces implementation of SAX, instantiate the SAXParserImpl from Xerces directly.

XMLParserActivator:

Is this really used anywhere in OSGI? How do you contribute a configuration to it? I've read that it has implementation bugs and isn't recommended to be used because it uses class.forName to instantiate the class instead of the standard OSGI mechanism. Seems like it might satisfy the XML Parser pool need and address some other interoperability issues and casting exceptions that can occur if it works.

Chris has started discussion on ways to make it easier for eclipse documentation to be updated. He has rightly stated that the state of eclipse documentation leads a lot to be desired. The docs are stored in a variety of formats and in a variety of locations. WikiText is a good contender for helping to help reduce the barrier to entry for the community to contribute. I also agree that single sourcing should occur as well. However it is going to take time to get all the necessary pieces in order, and honestly I'm not sure it's going to happen quickly. Converting documents can be a time consuming thing as well. However, how can we make it easier for users to continue to contribute to the existing documentation during the transition period that may occur?

If the documentation was originally created by IBM and the original code was contributed from IBM, then more than likely that existing documentation resides in DITA xml files. Using the DITA open source toolkit one can generate the eclipse help and toc.xml files. However, for most people working at the XML tag level is not enjoyable. Just as for some working with some of the cryptic Wiki markup isn't enjoyable as well. Some projects also store their help format in DocBook format. This is a popular format on many open source projects within the linux community. Both DocBook and DITA allow for single sourcing of the content. So how can one make editing and creating these files easier with an open source solution?



Syntex has recently announced they are open sourcing their XML Editor. It provides a WYSIWYG editor for DocBook and DITA files. Eclipse also has the VEX editor, which is in the WTP Incubator. However, the status of VEX is that it needs lots of work to get it to the point that it can be competitive with Syntex or other commercially available options.

For now, those that need to work with existing eclipse documentation, that is stored in DocBook or DITA formats, you may want to consider the free XML editor provided by Syntex. It may help lower that barrier to entry for both the contributor and or the committer that has to maintain the documents.

A few weeks ago I blogged about a RelaxNG Compact Syntax editor and how I was trying to use XText to generate the editor. Since that time, with the help of the XText folks, I've worked around a few of the big hurdles. First thing to note is that there isn't a one-to-one relationship mapping between EBNF and XText. This can make getting an existing grammar implemented trickier than it needs to be. With a little hand holding of XText, and lots of cursing later, I have a mostly working editor.


Most of the various grammars and patterns validate correctly, expect one.

If there are multiple levels the attributes end tag "}" is being flagged in error. I haven't worked out yet why this is happening, but every other grammar example I can toss at the editor seems to be validating correctly now. XText in some ways is being pushed to it's limits with the RelaxNG DSL. It's being very picky on how the grammar has to be setup. One major limitation in my opinion is not being able to handle the following with out compilation errors:

Pattern "&"
Pattern "+" Pattern

This makes for some ugly work arounds in the XText language to get it to generate the desired syntax and error handling.

With this said, I'm still impressed by the ability of generated Editor, and look forward to future versions of XText. It's a tool that can be useful, depending on the need.

One of the remaining issues that the PsychoPath parser has is not a PsychoPath issue itself, but due to the Cup based parser. Cup is getting confused somewhere along the line in parsing IF THEN ELSE statements. In particular it is complaining about the "then" statement as if it wasn't expecting it. Bug 283214 is currently tracking this bug. So if there any Cup experts out there, some advice would be appreciated on what is happening and why.

Update 2009-07-14:

Ask and you shall receive. Jesper S Moller has contributed patches to the Cup generated grammar to fix the issue with IF ( ... ) THEN . ELSE being treated as if it was a function after the IF statement. This has been committed and will be available when WTP 3.2M1 is available. Early adopters can check the code out from HEAD if you need it sooner.

Okay it's probably only a must have if you are an Eclipse XML Markup Geek like myself.

For my Eclipse Galileo XML focused article, I got some eclipse swag. Lynn was all out of Polo Shirts so I got to design my own Eclipse T-Shirt. The results are what you see above. Now everybody will want one...I can see you filling Lynn's email box already.

Thanks to Lynn and the Foundation for the swag. I'll make sure to try and wear it when doing eclipse XML presentations and promotion.

There are a couple of XQuery Editors that are available for eclipse. Three open source projects, and one commercial.

• Oxygen XML - provides a XQuery Editing and Debugging support. With built in support for eXist-DB, Saxon 9, and MarkLogic. License Commercial.
  
• Eclipse XQDT - an incubating project in the WTP Incubator. Provides XML Content Assistance within XQuery scripts, XML Catalog Support, and Namespace Awarness. Provides XQuery syntax coloring. Based on a google summer of code project. License EPL
  
• XQIDE - Hosted on Sourceforge. Provides ability to execute XQuery scripts on MarkLogic, and provides Syntax Coloring.
• XQDT 2.0 - provides a XQuery Editor and Debugger. Built on the DLTK Framework, supports XQuery 1.0, and 1.1. XQuery Updates. Content assistance and template support. License EPL.
  

Oxygen XML is probably the most advanced version, but for some the cost of the IDE is prohibitive for what they need. The Eclipse XQDT project has not progressed as much as I would have liked, but is still the only code base that has gone through Eclipse IP and also the only one that leverages the existing features and functionality of the WTP XML tools and frameworks. XQIDE is getting ready for a new release, but it will probably be it's last according to a recent conversation with the maintainer.

So this brings us to XQDT 2.0. As of right now, if you are looking for an open source based solution for Eclipse and XQuery, XQDT 2.0 is probably your best option. I like the direction they are taking. More information about their project can be found at their website.

Ultimately, I would love to see all three open source projects combine as an Incubating project under Eclipse.

For those of you that want a basic set of tools for working with XML, but don't want to download the full Java EE package. I've created a XML IDE profile on Yoxos. It provides the following features:

• WTP XML Support including, XML Catalogs, DTD Editor, XSL Tools, WSDL, and XML Schema.
• Mylyn with the Bugzilla connector.
• Subclipse 1.6.3 and Eclipse CVS client.

Anybody that needs a basic set of tooling should give this a try. Since it is built on Eclipse you can customize it further for your particular needs. There is also the XMLOpts profile on Yoxos which provides similar functionality.

Elliotte Rusty Harold recently described what he wants or needs in an xml editor:

I still prefer using plain vanilla text editors and the command line myself. At the end of the day, XML is just text; and an excellent text editor does a better job of it than a a text editor that's an afterthought in a product designed to shield users from raw XML. At most, I want some extra features on the side that don't get in my way when I'm just typing; for instance, a menu item to check the document for well-formedness or a spell checker that's smart enough to ignore tags. I don't want anything that gets in the way of my typing like auto-tag closing or tree views.

Let's address some of these.

Validation/Well-Formedness:

During editing using any of the XML based editors, right mouse click and then select Validate. This validates for grammar constraints as well as well-formedness. You can turn off as you type validation in the Preferences->Validation menu.

Tag Aware Spell Checker:

This is built into the WTP XML editor, items in tags are not checked for spelling. WTP comes with a built in spellchecker. Spell Checking can be enabled or disabled through Preferences->General->Editor->Spelling.

Auto Content Assistance:

This is on by default but can be turned to manual mode by changing the option in Preferences->XML->XML Files->Editor. Turn off "Automatically Make Suggestions". If you need content assistance you can still activate it by hitting CMD-Space or Ctrl-Space.

Auto Completion of Tags:

Don't like auto completion of end tags while typing. Yep there is a preference for that. Preferences->XML->XML Files->Editor->Typing. Turn off any features you don't like.

Turn off Code Folding:

Don't want to have Code Folding. Turn this off in Preferences->General->Editors->Structured Text Editor.

Tree Views and Hierarchy Views:

Don't want to see tree views or hierarchy view of the XML. In WTP switch to the editors Source Tab. When you reopen the file it'll open in source tab mode. Don't want to see an outline view being updated. Close the Outline view.

There you go, you know have an XML Editor that is Grammar Aware, XML Catalog Aware, with Validation, Well-Formedness Checking, and Spell Checking, that does not intrude in typing. Granted most of these options are turned on by default because the vast majority of people want them turned on, however, how you configure these options for your own way of working is entirely up to the user.

So..every few years it seems we have to come up with a new HOT or Cool buzzword in the tech community. It seems that DSL is now that term. For those that have been hiding underneath a rock for the last year, DSL = Domain Specific Language. Think of this as a custom programming language designed to handle a very specific task. Wikipedia has a decent definition. DSLs aren't knew, they've been around since the age of 1s and 0s.

We in the programming world seem to invent new DSLs everytime we touch the keyboard. Existing items aren't good enough or may be too wordy. DSLs give me cramps. I think in many cases they are over used and for the wrong reasons. Now that isn't to say that I don't think there is a need for them, when they are done for the right reasons. However, it seems that everybody's answer to a problem now is to create a DSL.

The problem with DSLs is that it's yet another language one has to learn to maintain software. My head is already cramped full of various utility languages and I'm sure it will be cramped with some more over time, but many of these languages don't provide the convience that they try to provide. Ask yourself before coming up with another language:

1. Is there a currently supported standard that works?
2. Can I extend this existing standard DSL?
3. If not, why not?
4. Will creating yet another DSL really solve the problem and make it easier to maintain going forward.

I work with XML which itself is a DSL for creating other Markup Languages, and its simplicity of implementation and power has also been its bane as well. XML is over used in many situations because it is too convient to use. With this said, there are a hand full of programming DSLs with in the XML world. Some are better than others, and several are starting to evolve into general purpose languages in their own right. Some examples.

1. XSLT - functional language used for transformations. Comes in two flavors XSLT 1.0 and XSLT 2.0. It itself is written using XML.
2. XPath 1.0 and XPath 2.0 - A DSL for querying information from a XML Tree, usually a DOM.
3. XML Schema - a DSL for describing XML Validation. Written using XML.
4. RelaxNG - Another DSL for describing XML Validation and content. Comes in both an XML based syntax and a Human Readable Compact Syntax.
5. XPointer - a XML DSL for specifying the location of information with a document.
6. XInclude - a XML DSL for specifying how to include or import information into existing XML documents.
7. Web Services - A whole family of DSLs describing how to create web service implementations.
8. SchemaTron - Yet another XML Validation DSL for validating XML files.

XML has made creating a DSL very simple and straight forward. It however is often used for the wrong reasons.

Which brings me to XText. I've been experimenting with it for a couple of days, and like XML it provides great power at little upfront cost. However, I also think like XML it can run into being applied way to often just because it is easy to create and deploy. XText itself has it's own DSL for describing the languages, however, I wish it would have just leveraged an existing established standard language like the ISO EBNF.

So how many more DSLs will we create? More than we really need.

It's been a little while since I gave an update on where the PsychoPath XPath 2.0 processor stands from a W3C Test Suite compliance point. Mukul Gandhi (note: nudge him to get his blog on Planet Eclipse since he is an Eclipse committer now) and I have been working our way steadily through the entire test suite. Here are the current results:

Tests: 8137
Failures: 988
Errors: 42

Code Coverage according to ECLEmma:

The test suite now covers about 76% of the PsychoPath. I suspect that we will be close to 80% to 85% code coverage by the time we complete the test suite. When we started we had about 30 or 40 tests that covered about 20% of the code. Unless you run the coverage analysis with a tool like ECLEmma you really do not know how much of your code is actually being executed by your tests. Trying to get to 100% coverage is not worth doing, getting to above 75% is worth doing and should be worked toward.

XPath 2.0 Castable, Durations, and Date/Times:

This has been the bane of my existance for the last several weeks. Reading the W3C specifications on when something can be cast and when something shouldn't be cast can give one a headache pretty quickly. Luckily the XPath 2.0 and XQuery 1.0 Functions Specification has this nice handy table:


The SeqCastableTest test suite covers about 648 test cases for the core specification. PschyoPath now passes all of these tests. With out the above table, trying to figure out the wording of the specification can be difficult at best, and just plain maddening at worst.

The Natives Will Byte You!

One thing that constantly was biting me was the imprecision that the Java primitive types have. PsychoPath in it's original implementation used the Integer, Double, and Float classes exclusively. The problem was that in many cases, especially during IntegerLiteral and DecimalLiteral parsing or creation, these were either too small to hold the numbers the tests wanted, or their precision was not accurate enough. A good explanation of the reason can be found in "Double Precision Numbers". Switching where need to BigInteger and BigDecimal solved many of these issues.

Dates are still another pain to deal with especially calculations. Again you start to run into a precision issue, where some numbers are stored too low. I did some experimentation and both the com.ibm.icu.util.GregorianCalendar and the built in Java GregorianCalendar have precision issues, some in the same place others not. I had thought about trying to leverage Joda Time but that was previously turned down by Eclipse IP team due to pedigree concerns.

I dread debugging these issues. Dates and Time calculations give me a headache.

What's left:

Lots. There are several core functions that are not working or are missing. Some logic expression errors to correct, and a few more lexer/parser issues to address. Overall though, PsychoPath passes about 88% of the W3C Test Suite, so is much more compliant than it started out. Credit still has to be given to Andrea Bittau, the original author, for a well designed implementation, and some very clean and easy to maintain code. Compared to some of the code I've worked on at Eclipse, this is just a pleasure to work with.

All current changes are in the WTP Source Editing CVS Repository.

Peter Friese spent some time with me this afternoon to help work around some of the issues I had with the EBNF grammar and Xtext. The results are very encouraging.

The above is the editor, and outline view that is generated from the XText grammar. We even have some very basic content assistance that comes with it.


The hope is to p0lish this up over the next week or so, and contribute the source to the RelaxNG Editor and Validator enhacement in WTP. A code contribution has already been attached to the bug that provides Grammar aware content assistance and validation for XML files backed by a RelaxNG grammar. Hopefully we can get this project quickly into the WTP Incubator so that RelaxNG support can be added by Helios in some form.

Thanks again for the help Peter.

While working on the PsychoPath XPath 2.0 processor in the eclipse WTP project, I ran across the following situation. According the the W3C XPath 2.0 test suite test case CastableAs030 the following test should fail:

xs:untypedAtomic("-P1Y1M1DT1H1M1.123S") castable as xs:yearMonthDuration

The result should be false, however, we are returning true. As far as my understanding of the specification, the xs:untypedAtomic value should be treated as a string value, and when casting to xs:yearMonthDuration only the form of "-P1Y1M1" is processed ignoring the rest. It also appears that this is a validation duration describing:
a negative 1 year, 1 month, 1 day, 1 hour, 1 minute, and 1.123 seconds

At least that is my interpretation of section 17.1.4 of Casting from primitive types to primitive types. Am I missing something or is this a known bug in the W3C Test Suite?

So, I decided to try and create an XText Grammar for the RelaxNG Compact Syntax. Mixed results so far, mainly having to do with my lack of knowledge on the XText grammar and it's mapping to EBNF.

Here is what I have so far:

grammar org.oasisopen.relaxng with org.eclipse.xtext.common.Terminals

generate relaxng "http://www.oasis-open.org/relaxng"

terminal Letter:
   ID;

terminal CHAR:
   '#x9' | '#xA' | '#xD' | ('#x20'..'#xD7FF') | ('#xE000'..'#xFFFD') | ('#x10000'..'#x10FFFF');  

terminal NewLine:
   '#xA' | '#xD' | ('#xA' '#xD');
 
terminal NameStartChar:
   ":" |
   ('A'..'Z') |
   "_" | 
   ('a'..'z') |
   ('#xC0'..'#xD6') | 
   ('#xD8'..'#xF6') | 
   ('#xF8'..'#x2FF') | 
   ('#x370'..'#x37D') | 
   ('#x37F'..'#x1FFF') | 
   ('#x200C'..'#x200D') |
   ('#x2070'..'#x218F') | 
   ('#x2C00'..'#x2FEF') |
   ('#x3001'..'#xD7FF') |
   ('#xF900'..'#xFDCF') |
   ('[#xFDF0'..'-#xFFFD') |
   ('#x10000'..'#xEFFFF');

terminal NameChar:
   NameStartChar | "-" | "." | ('0'..'9') | '#xB7' | ('#x0300'..'#x036F') | ('#x203F'..'#x2040');

Model :
   (elements += TopLevel);

TopLevel:
   Decl* (Pattern | GrammarContent*);
    
Decl:
   'namespace' (IdentifierOrKeyWord '=' NamespaceURILiteral) |
   'default' 'namespace' (IdentifierOrKeyWord) '=' NamespaceURILiteral |
   'datatypes' IdentifierOrKeyWord '=' Literal;

Pattern:
   'element' NameClass '{' Pattern '}' |
   'attribute' NameClass '{' Pattern '}' |
   Pattern (',' Pattern)+ |
   Pattern ('&' Pattern)+ |
   Pattern ('|' Pattern)+ |
   Pattern '?' |
   Pattern '*' |
   Pattern '+' |
   'list' '{' Pattern '}' |
   'mixed' '{' Pattern '}' |
   Identifier |
   'parent' Identifier |
   'empty' |
   'text' |
   (DataTypeName) DataTypeValue |
   DataTypeName ('{' Param* '}') (ExceptPattern) |
   'notAllowed' |
   'external' AnyURILiteral (Inherit) |
   'grammar' '{' GrammarContent* '}' |
   '(' Pattern ')';
   
Param:
   IdentifierOrKeyWord '=' Literal;

ExceptPattern:
   '-' Pattern;

GrammarContent:
   Start | Define |
   'div' '{' GrammarContent* '}' |
   'include' AnyURILiteral (Inherit) ('{' IncludeContent* '}');

IncludeContent:
   Define | Start |
   'div' '{' GrammarContent* '}';

Start:
   'start' AssignedMethod Pattern;

Define:
   Identifier AssignedMethod Pattern;

AssignMethod:
   '=' |
   '|=' |
   '&=';

NameClass:
   Name |
   NsName (ExceptClassName) |
   AnyName (ExceptClassName) |
   NameClass '|' NameClass |
   '(' NameClass ')';

Name:
   IdentiferOrKeyWord | CName;

ExceptNameClass:
   '-' NameClass;

DataTypeName:
   CName |
   'string' |
   'token';

DataTypeValue:
   Literal;

AnyURILiteral:
   Literal;

NamespaceURILiteral:
   Literal | 'inherit';

Inherit:
   'inherit' '=' IdentifierOrKeyWord;

IdentifierOrKeyWord:
   Identifier | KeyWord;


Identifier:
   (NCName .. KeyWord) |
   QuotedIdentifier;


CName:
   NCName ':' NCName;

NsName:
   NCName ':*';

AnyName:
   '*';

Literal:
   LiteralSegment ('~' LiteralSegment)+;

LiteralSegment:
   '"' (CHAR .. ('"' | NewLine))* '"' |
   "'" (CHAR .. ("'" | Newline))* "'" |
   '"""' (('"') ('"') (CHAR .. '"'))* '"""';

KeyWord:
   "attribute"
   | "default"
   | "datatypes"
   | "div"
   | "element"
   | "empty"
   | "external"
   | "grammar"
   | "include"
   | "inherit"
   | "list"
   | "mixed"
   | "namespace"
   | "notAllowed"
   | "parent"
   | "start"
   | "string"
   | "text"
   | "token";

NCName:
   NCNameStartChar NCNameChar*; /* An XML Name, minus the ":" */
    
NCNameChar:
   NameChar - ':';
    
NCNameStartChar:
   Letter | '_';
    
Name:
   NameStartChar (NameChar)*;
    
Names:
   Name ('#x20' Name)*;
    
Nmtoken:
   (NameChar)+;
    
Nmtokens:
   Nmtoken ('#x20' Nmtoken)*;

QuotedIdentifier:
    '\' NCName;

Some of the errors I can figure out...others are just baffling. Particular the ones where it can't find the Rule even though it's been editted. Help from the XText gurus out their would be appreciated.

Typically when working on PHP files I don't have much of a need to setup a debugger. However, I've recently had to go through some really nasty PHP 4 code. It was one big massive mess of nested if then else statements no functions, and a crap load of global variables. PHP is a good utility language, but some of the people writing the code need to read Uncle Bob's Clean Code book.

My development machine is a Ubuntu box and I have eclipse Galileo Java EE package installed with PDT 2.1 added as well. There is a decent blog entry at Hodge title
Debugging PHP Applications with Xdebug and Eclipse PDT. However you can simplify some of the steps.

1. Use apt-get or Synaptic to install apache2, php5, php5-cli, and the php5-xdebug module.
   
2. Go to the terminal and restart apache2: sudo /etc/init.d/apache2 restart
3. Follow the rest of the steps outline in Hodge's article for making sure XDeubg is turned on and enabled.

There is no need to download and compile xdebug yourself, as it's already in the Ubuntu apt repository. If you follow the rest of his steps for setting up PDT for XDebug, you should be ready to debug.