Changes between Initial Version and Version 1 of CommentsFormalGrammar

Timestamp:

10/22/08 15:28:02 (17 years ago)

Author:

christof

Comment:

--

CommentsFormalGrammar

@@ +1 @@
+= 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
+}}}