= Formal Grammar for UCUM =

This grammar was created from a parser project employing ANTLR as a LL(*) parser generator. Note that this is only one of many ways to express a formal Grammar for UCUM.  Alternatively the grammar could be written for LR-parser generators (e.g. yacc). Lexer rules have been omitted for clarity. The objective is to create UCUM-parsers from a declarative definition of the grammar.

{{{
ucumExpr   :  DIVIDE expr
           |  expr 
           ;
multiply   :  TIMES term
           |  DIVIDE term
           ;
expr       :  term (multiply)*  
           ;
term       :  element (exponent)? (ANN)*
           ;
element    :  simpleUnit
           |  LPAREN expr RPAREN
           |  ANN
           ;
exponent   :  (SIGN)? DIGITS	// allow zero exponent?
           ;
simpleUnit :  prefix metricAtom // prefix is token from lexer
           |  metricAtom  
           |  nonMetricAtom	// token from lexer
           |  DIGITS	// allow zero?
           ;
metricAtom :  baseUnit // token from lexer
           |  derivedMetricAtom // token from lexer
           ;
}}}

The following is an original code snippet from a working project using the ANTLR parser generator: 

{{{
//...
startRule returns [UnitExpr u=null]
    :   u=ucumExpr EOF  // or EOL 
    ;

ucumExpr returns [UnitExpr u=null]
	:	DIVIDE u=expr { u.invert(); }
	|	u=expr 
	;

multiply[UnitExpr a] returns [UnitExpr u=null]
	:	TIMES u=term { u=a.multiply(u); }
	|	DIVIDE u=term { u.invert(); u=a.multiply(u); }
	;
	
expr returns [UnitExpr u=null]
	:	u=term (u=multiply[u])*  
	;
	
term returns [UnitExpr u=null]
	{ int exp = 1; }
	:	u=element (exp=exponent)? (ANN)* { u.setExponent(exp); }
	;

element returns [UnitExpr u=null]
	:	u=simpleUnit
	|	LPAREN u=expr RPAREN
	|	ANN 				{ u = new UnitExpr();}
	;

exponent  returns [int exp=1]
	:	(s:SIGN)? e:DIGITS	// allow zero?
		{
			exp = Integer.parseInt(e.getText());
			if(s != null && s.getText().equals("-") ) exp *= -1;
		}
	;

simpleUnit returns [UnitExpr u=null]
	{ double p=0; }
	:	p=prefix u=metricAtom { u.setPrefix(p);	} 
	|	u=metricAtom  
	| 	u=nonMetricAtom	
	|	d:DIGITS { u = new UnitExpr(Integer.parseInt(d.getText())); }	// allow zero?
	;

metricAtom returns [UnitExpr u=null]
	: 	u=baseUnit 
	|	u=derivedMetricAtom 
	;
//... lexer definitions follow
}}}