From 6e589b21b58d3542fafad7927c0605a77a9cc068 Mon Sep 17 00:00:00 2001 From: Dominique Unruh Date: Mon, 22 Aug 2016 11:02:36 +0300 Subject: [PATCH] Popcorn parser works, but is excruciatingly slow! --- ...rg_scala_lang_scala_library_2_11_8_jar.xml | 9 +- .idea/modules/proof-editor-build.iml | 2 +- .idea/modules/proof-editor.iml | 8 +- project/Downloads.scala | 2 +- sbt | 2 +- src/cmathml/CMathML.scala | 35 ++- src/cmathml/PopcornGrammar.g4 | 268 +++++++----------- 7 files changed, 155 insertions(+), 171 deletions(-) diff --git a/.idea/libraries/SBT__org_scala_lang_scala_library_2_11_8_jar.xml b/.idea/libraries/SBT__org_scala_lang_scala_library_2_11_8_jar.xml index 366709d..4a0c325 100644 --- a/.idea/libraries/SBT__org_scala_lang_scala_library_2_11_8_jar.xml +++ b/.idea/libraries/SBT__org_scala_lang_scala_library_2_11_8_jar.xml @@ -1,5 +1,12 @@ - + + + + + + + + diff --git a/.idea/modules/proof-editor-build.iml b/.idea/modules/proof-editor-build.iml index 78e422d..aab5566 100644 --- a/.idea/modules/proof-editor-build.iml +++ b/.idea/modules/proof-editor-build.iml @@ -1,5 +1,5 @@ - + diff --git a/.idea/modules/proof-editor.iml b/.idea/modules/proof-editor.iml index 8dd2f5e..ebf92c7 100644 --- a/.idea/modules/proof-editor.iml +++ b/.idea/modules/proof-editor.iml @@ -27,10 +27,6 @@ - - - - @@ -41,6 +37,10 @@ + + + + diff --git a/project/Downloads.scala b/project/Downloads.scala index e7a0357..1e9178f 100644 --- a/project/Downloads.scala +++ b/project/Downloads.scala @@ -23,7 +23,7 @@ object Downloads extends AutoPlugin { lazy val installSymcompOpenmath = TaskKey[Unit]("Download Symcomp's openmath.jar") lazy val enableDownloads = Seq( - installResources := recursiveFiles(installJQuery.value,installMathQuill.value), + installResources := recursiveFiles(/*installJQuery.value,*/installMathQuill.value), installJars := { installZ3Linux64.value diff --git a/sbt b/sbt index 55b5485..fba8425 100755 --- a/sbt +++ b/sbt @@ -1,2 +1,2 @@ export JAVA_HOME=/usr/java/jdk1.8.0_92 -"$JAVA_HOME/bin/java" -jar /home/unruh/.IdeaIC2016.1/config/plugins/Scala/launcher/sbt-launch.jar "$@" +"$JAVA_HOME/bin/java" -jar /home/unruh/.IdeaIC2016.2/config/plugins/Scala/launcher/sbt-launch.jar "$@" diff --git a/src/cmathml/CMathML.scala b/src/cmathml/CMathML.scala index d4ff029..aab6420 100644 --- a/src/cmathml/CMathML.scala +++ b/src/cmathml/CMathML.scala @@ -1,6 +1,7 @@ package cmathml import java.math.{BigInteger, MathContext} +import java.util.stream.Stream import cmathml.CMathML._ import com.sun.org.apache.xerces.internal.util.XMLChar @@ -9,6 +10,7 @@ import org.symcomp.openmath.{OMSymbol, _} import _root_.z3.Z3 import com.sun.glass.events.KeyEvent import misc.Utils.Typed +import org.antlr.v4.runtime.{ANTLRInputStream, BailErrorStrategy, CommonTokenStream} import scala.collection.mutable import scala.reflect.internal.JavaAccFlags @@ -166,7 +168,20 @@ object CMathML { private lazy val z3 = new Z3() - def fromPopcorn(str: String) = { + + @Pure + def fromPopcorn(popcorn:String) : CMathML = { + val stream = new ANTLRInputStream(popcorn) + val lexer = new PopcornGrammarLexer(stream) + val tokens = new CommonTokenStream(lexer) + val parser = new PopcornGrammarParser(tokens) + parser.setErrorHandler(new BailErrorStrategy) + val tree = parser.expr_eof() + tree.cmathml + } + + @deprecated("use fromPopcorn","Aug 21, 2016") + def fromPopcornSYMCOMP(str: String) = { val om = OpenMathBase.parsePopcorn(str.trim) fromSymcomp(om) } @@ -260,7 +275,7 @@ object CMathML { def sum(x:CMathML, y:CMathML) : Apply = Apply(sum,x,y) val product = CSymbol(cd,"product") def product(x:CMathML, y:CMathML) : Apply = Apply(product,x,y) - val uminus = CSymbol(cd,"unary_minus") + val uminus = CSymbol(cd,"unary_minus") // TODO rename def uminus(x:CMathML) : Apply = Apply(uminus,x) } @@ -807,6 +822,9 @@ final case class CError(attributes : Attributes, cd: String, name: String, args: for (Typed(m:CMathML) <- args) m.freeVariables$(acc,hidden) } } +object CError { + def apply(cd: String, name: String, args: Any*) = new CError(NoAttr, cd, name, args :_*) +} /** An addition to the Content MathML standard. Represents a missing node. * Not valid Content MathML, cannot be exported to valid XML @@ -865,6 +883,15 @@ final case class PathRev(path : List[Int]) extends AnyVal { /** Various convenience methods to ease access to CMathML objects from Java */ object JavaHelpers { - @annotation.varargs - def apply(hd:CMathML, args:CMathML*) = Apply(hd,args:_*) + import scala.collection.JavaConverters._ + @annotation.varargs def apply(cd:String, name:String, args:CMathML*) = Apply(CSymbol(cd,name), args:_*) + def apply(cd:String, name:String, args:Stream[CMathML]) = Apply(CSymbol(cd,name), args.iterator.asScala.toSeq :_*) + def apply(hd: CMathML, args:Stream[CMathML]) = Apply(hd, args.iterator.asScala.toSeq :_*) + def addAttributes(math: CMathML, attrs:Stream[org.antlr.v4.runtime.misc.Pair[CSymbol,CMathML]]) : CMathML = ??? + def bind(hd:CMathML, vars:Stream[CILike], body:CMathML) = Bind(hd, vars.iterator.asScala.toSeq, body) + def error(hd:CSymbol, args:Stream[CMathML]) = CError(hd.cd,hd.name, args.iterator.asScala.toSeq) + def cn(i:String) = CN(i) + def ci(i:String) = CI(i) + def cs(i:String) = CS(i) + def csymbol(cd:String, name:String) = CSymbol(cd,name) } \ No newline at end of file diff --git a/src/cmathml/PopcornGrammar.g4 b/src/cmathml/PopcornGrammar.g4 index 8085fb7..40a4043 100644 --- a/src/cmathml/PopcornGrammar.g4 +++ b/src/cmathml/PopcornGrammar.g4 @@ -3,9 +3,22 @@ grammar PopcornGrammar; @header { import cmathml.*; import cmathml.CMathML.*; -import cmathml.JavaHelpers.*; +import static cmathml.JavaHelpers.*; +import java.util.stream.Stream; +import scala.NotImplementedError; +import scala.StringContext; } +@parser::members { + static String stripID(Token token) { + String txt = token.getText(); + if (txt.charAt(0)!='"') return txt; + txt = txt.substring(1,txt.length()-1); + return StringContext.treatEscapes(txt); + } +} + + expr_eof returns [CMathML cmathml]: x=expr EOF { $cmathml = $x.m; }; @@ -13,126 +26,65 @@ expr returns [CMathML m]: x=blockExpr { $m = $x.m; }; blockExpr returns [CMathML m]: - bs+=assignExpr (';' bs+=assignExpr)+ { $m = apply(prog1.block(),bs); } + bs+=assignExpr (';' bs+=assignExpr)+ { $m = apply("prog1", "block", $bs.stream().map(x->x.m)); } | x=assignExpr { $m = $x.m; }; assignExpr returns [CMathML m]: - x=implExpr ':=' y=implExpr { $m = apply(prog1.assign(),$x.m,$y.m); } + x=implExpr ':=' y=implExpr { $m = apply("prog1", "assign", $x.m, $y.m); } | x=implExpr { $m = $x.m; }; implExpr returns [CMathML m]: - x=orExpr '==>' y=orExpr { $m = apply(logic1.implies(),$x.m,$y.m); } - | x=orExpr '<=>' y=orExpr { $m = apply(logic1.equivalent(),$x.m,$y.m); } + x=orExpr '==>' y=orExpr { $m = apply("logic1", "implies", $x.m, $y.m); } + | x=orExpr '<=>' y=orExpr { $m = apply("logic1", "equivalent", $x.m, $y.m); } | x=orExpr { $m = $x.m; }; orExpr returns [CMathML m]: - x=andExpr 'or' y=andExpr { $m = apply(logic1.or(),$x.m,$y.m); } + x=andExpr 'or' y=andExpr { $m = apply("logic1", "or", $x.m, $y.m); } | x=andExpr { $m = $x.m; }; andExpr returns [CMathML m]: - x=relExpr 'and' y=relExpr { $m = apply(logic1.and(),$x.m,$y.m); } + x=relExpr 'and' y=relExpr { $m = apply("logic1", "and", $x.m, $y.m); } | x=relExpr { $m = $x.m; }; relExpr returns [CMathML m]: - x=intervalExpr '=' y=intervalExpr { $m = apply(relation1.eq(),$x.m,$y.m); } - | x=intervalExpr '<' y=intervalExpr { $m = apply(relation1.lt(),$x.m,$y.m); } - | x=intervalExpr '<=' y=intervalExpr { $m = apply(relation1.le(),$x.m,$y.m); } - | x=intervalExpr '>' y=intervalExpr { $m = apply(relation1.gt(),$x.m,$y.m); } - | x=intervalExpr '>=' y=intervalExpr { $m = apply(relation1.ge(),$x.m,$y.m); } - | x=intervalExpr '!=' y=intervalExpr { $m = apply(relation1.neq(),$x.m,$y.m); } - | x=intervalExpr '<>' y=intervalExpr { $m = apply(relation1.neq(),$x.m,$y.m); } + x=intervalExpr '=' y=intervalExpr { $m = apply("relation1", "eq", $x.m, $y.m); } + | x=intervalExpr '<' y=intervalExpr { $m = apply("relation1", "lt", $x.m, $y.m); } + | x=intervalExpr '<=' y=intervalExpr { $m = apply("relation1", "leq", $x.m, $y.m); } + | x=intervalExpr '>' y=intervalExpr { $m = apply("relation1", "gt", $x.m, $y.m); } + | x=intervalExpr '>=' y=intervalExpr { $m = apply("relation1", "geq", $x.m, $y.m); } + | x=intervalExpr '!=' y=intervalExpr { $m = apply("relation1", "neq", $x.m, $y.m); } + | x=intervalExpr '<>' y=intervalExpr { $m = apply("relation1", "neq", $x.m, $y.m); } | x=intervalExpr { $m = $x.m; }; intervalExpr returns [CMathML m]: - x=addExpr '..' y=addExpr { $m = apply(interval1.interval(),$x.m,$y.m); } + x=addExpr '..' y=addExpr { $m = apply("interval1", "interval", $x.m, $y.m); } | x=addExpr { $m = $x.m; }; addExpr returns [CMathML m]: - x=multExpr '-' y=multExpr { $m = apply(arith1.minus(),$x.m,$y.m); } - | x=multExpr '+' y=multExpr { $m = apply(arith1.plus(),$x.m,$y.m); } + x=multExpr '-' y=multExpr { $m = apply("arith1", "minus", $x.m, $y.m); } + | x=multExpr '+' y=multExpr { $m = apply("arith1", "plus", $x.m, $y.m); } | x=multExpr { $m = $x.m; }; multExpr returns [CMathML m]: - x=powerExpr '/' y=powerExpr { $m = apply(arith1.divide(),$x.m,$y.m); } - | x=powerExpr '*' y=powerExpr { $m = apply(arith1.times(),$x.m,$y.m); } + x=powerExpr '/' y=powerExpr { $m = apply("arith1", "divide", $x.m, $y.m); } + | x=powerExpr '*' y=powerExpr { $m = apply("arith1", "times", $x.m, $y.m); } | x=powerExpr { $m = $x.m; }; powerExpr returns [CMathML m]: - x=complexExpr '^' y=complexExpr { $m = apply(arith1.power(),$x.m,$y.m); } + x=complexExpr '^' y=complexExpr { $m = apply("arith1", "power", $x.m, $y.m); } | x=complexExpr { $m = $x.m; }; complexExpr returns [CMathML m]: - x=rationalExpr '|' y=rationalExpr { $m = apply(complex1.complex_cartesian(),$x.m,$y.m); } + x=rationalExpr '|' y=rationalExpr { $m = apply("complex1", "complex_cartesian", $x.m, $y.m); } | x=rationalExpr { $m = $x.m; }; rationalExpr returns [CMathML m]: - x=negExpr '//' y=negExpr { $m = apply(num1.rational(),$x.m,$y.m); } + x=negExpr '//' y=negExpr { $m = apply("num1", "rational", $x.m, $y.m); } | x=negExpr { $m = $x.m; }; negExpr returns [CMathML m]: - '-' x=compExpr { $m = apply(arith1.uminus(),$x.m); } - | 'not' x=compExpr { $m = apply(logic1.not(),$x.m); } -======= - bs+=assignExpr (';' bs+=assignExpr)+ { $m = apply(prog1.block,bs); } - | x=assignExpr { $m = $x.m; }; - -assignExpr returns [CMathML m]: - x=implExpr ':=' y=implExpr { $m = apply(prog1.assign,$x.m,$y.m); } - | x=implExpr { $m = $x.m; }; - -implExpr returns [CMathML m]: - x=orExpr '==>' y=orExpr { $m = apply(logic1.implies,$x.m,$y.m); } - | x=orExpr '<=>' y=orExpr { $m = apply(logic1.equivalent,$x.m,$y.m); } - | x=orExpr { $m = $x.m; }; - -orExpr returns [CMathML m]: - x=andExpr 'or' y=andExpr { $m = apply(logic1.or,$x.m,$y.m); } - | x=andExpr { $m = $x.m; }; - -andExpr returns [CMathML m]: - x=relExpr 'and' y=relExpr { $m = apply(logic1.and,$x.m,$y.m); } - | x=relExpr { $m = $x.m; }; - -relExpr returns [CMathML m]: - x=intervalExpr '=' y=intervalExpr { $m = apply(relation1.eq,$x.m,$y.m); } - | x=intervalExpr '<' y=intervalExpr { $m = apply(relation1.lt,$x.m,$y.m); } - | x=intervalExpr '<=' y=intervalExpr { $m = apply(relation1.le,$x.m,$y.m); } - | x=intervalExpr '>' y=intervalExpr { $m = apply(relation1.gt,$x.m,$y.m); } - | x=intervalExpr '>=' y=intervalExpr { $m = apply(relation1.ge,$x.m,$y.m); } - | x=intervalExpr '!=' y=intervalExpr { $m = apply(relation1.neq,$x.m,$y.m); } - | x=intervalExpr '<>' y=intervalExpr { $m = apply(relation1.neq,$x.m,$y.m); } - | x=intervalExpr { $m = $x.m; }; - -intervalExpr returns [CMathML m]: - x=addExpr '..' y=addExpr { $m = apply(interval1.interval,$x.m,$y.m); } - | x=addExpr { $m = $x.m; }; - -addExpr returns [CMathML m]: - x=multExpr '-' y=multExpr { $m = apply(arith1.minus,$x.m,$y.m); } - | x=multExpr '+' y=multExpr { $m = apply(arith1.plus,$x.m,$y.m); } - | x=multExpr { $m = $x.m; }; - -multExpr returns [CMathML m]: - x=powerExpr '/' y=powerExpr { $m = apply(arith1.divide,$x.m,$y.m); } - | x=powerExpr '*' y=powerExpr { $m = apply(arith1.times,$x.m,$y.m); } - | x=powerExpr { $m = $x.m; }; - -powerExpr returns [CMathML m]: - x=complexExpr '^' y=complexExpr { $m = apply(arith1.power,$x.m,$y.m); } - | x=complexExpr { $m = $x.m; }; - -complexExpr returns [CMathML m]: - x=rationalExpr '|' y=rationalExpr { $m = apply(complex1.complex_cartesian,$x.m,$y.m); } - | x=rationalExpr { $m = $x.m; }; - -rationalExpr returns [CMathML m]: - x=negExpr '//' y=negExpr { $m = apply(num1.rational,$x.m,$y.m); } - | x=negExpr { $m = $x.m; }; - -negExpr returns [CMathML m]: - '-' x=compExpr { $m = apply(arith1.uminus,$x.m); } - | 'not' x=compExpr { $m = apply(logic1.not,$x.m); } ->>>>>>> 4bfd5acbad4b4e497c7455ce24dd22bcbadbcf31 + '-' x=compExpr { $m = apply("arith1", "unary_minus", $x.m); } + | 'not' x=compExpr { $m = apply("logic1", "not", $x.m); } | x=compExpr { $m = $x.m; }; compExpr returns [CMathML m]: @@ -144,116 +96,114 @@ compExpr returns [CMathML m]: | s=setExpr { $m = $s.m; } | an=anchor { $m = $an.m; }; -commaList returns [List ms]: - | (xs+=expr (',' xs+=expr)*)? { $ms = $xs.map(x -> x.m); }; +commaList returns [Stream ms]: + | (xs+=expr (',' xs+=expr)*)? { $ms = $xs.stream().map(x -> x.m); }; -varCommaList returns [List ms]: - | (xs+=var (',' xs+=var)*)? { $ms = $xs.map(x -> x.m); }; +varCommaList returns [Stream ms]: + | (xs+=var (',' xs+=var)*)? { $ms = $xs.stream().map(x -> x.m); }; call returns [CMathML m]: - hd=anchor '(' args=commaList ')' { apply(hd,args); }; + hd=anchor '(' args=commaList ')' { apply($hd.m, $args.ms); }; -ecall returns [CMathML m]: - hd=anchor '!' '(' args=commaList ')' { error(hd,args); }; +ecall returns [CMathML m]: + hd=anchor '!' '(' args=commaList ')' { error((CSymbol)$hd.m, $args.ms); }; -listExpr returns [CMathML m]: - '[' args=commaList ']' { apply(list1.list,args); }; +listExpr returns [CMathML m]: + '[' args=commaList ']' { apply("list1", "list", $args.ms); }; -setExpr returns [CMathML m]: - '{' args=commaList '}' { apply(set1.set,args); }; +setExpr returns [CMathML m]: + '{' args=commaList '}' { apply("set1", "set", $args.ms); }; /* foreignExpr returns [CMathML m]: '`' FOREIGN '`' { TODO; }; */ -attribution returns [CMathML m]: +attribution returns [CMathML m]: x=anchor '{' attr=attributionList '}' { $m = addAttributes($x.m, $attr.attrs); }; -attributionList returns [List> attrs]: - x+=attributionPair (',' x+=attributionPair)* { $attrs = $x; }; +attributionList returns [Stream> attrs]: + x+=attributionPair (',' x+=attributionPair)* { $attrs = $x.stream().map(x->x.attr); }; attributionPair returns [Pair attr]: - x=symbol '->' y=expr { $attr = Pair($x.m,$y.m); }; + x=symbol '->' y=expr { $attr = new Pair($x.m,$y.m); }; -binding returns [CMathML m]: - x=anchor '[' v=varCommaList '->' b=expr ']' { $m = bind(x,v,b); }; +binding returns [CMathML m]: + x=anchor '[' v=varCommaList '->' b=expr ']' { $m = bind($x.m, $v.ms, $b.m); }; -anchor returns [CMathML m]: +anchor returns [CMathML m]: x=atom (':' ID)? { $m = $x.m; }; // Ignoring ID (can't be represented) atom returns [CMathML m]: - x=paraExpr { $m = $x.m; } - | x=shortSymbol { $m = $x.m; } - | x=var { $m = $x.m; } - | x=intt { $m = $x.m; } - | x=floatt { $m = $x.m; } - | x=ref { $m = $x.m; } - | b=OMB { throw new NotSupportedException("not yet implemented"); } + p=paraExpr { $m = $p.m; } + | s=symbol { $m = $s.m; } + | ss=shortSymbol { $m = $ss.m; } + | v=var { $m = $v.m; } + | i=intt { $m = $i.m; } + | f=floatt { $m = $f.m; } + | r=ref { $m = $r.m; } + | b=OMB { if (true) throw new NotImplementedError("not yet implemented"); } // | fo=FOREIGN { TODO; } // Not implemented - | str=STRING { throw new NotSupportedException("not yet implemented"); } - | x=ifExpr { $m = $x.m; } - | x=whileExpr { $m = $x.m; }; + | str=STRING { $m = cs(stripID($str); } + | ie=ifExpr { $m = $ie.m; } + | w=whileExpr { $m = $w.m; }; shortSymbol returns [CSymbol m]: - 'cos' { $m = transc1.cos; } - | 'cosh' { $m = transc1.cosh; } - | 'cot' { $m = transc1.cot; } - | 'coth' { $m = transc1.coth; } - | 'csc' { $m = transc1.csc; } - | 'csch' { $m = transc1.csch; } - | 'exp' { $m = transc1.exp; } - | 'sec' { $m = transc1.sec; } - | 'sech' { $m = transc1.sech; } - | 'sin' { $m = transc1.sin; } - | 'sinh' { $m = transc1.sinh; } - | 'tan' { $m = transc1.tan; } - | 'tanh' { $m = transc1.tanh; } - | 'abs' { $m = arith1.abs; } - | 'root' { $m = arith1.root; } - | 'sum' { $m = arith1.sum; } - | 'product' { $m = arith1.product; } - | 'diff' { $m = calculus1.diff; } - | 'int' { $m = calculus1.integral; } - | 'defint' { $m = calculus1.defint; } - | 'pi' { $m = nums1.pi; } - | 'e' { $m = nums1.e; } - | 'i' { $m = nums1.i; } - | 'infinity' { $m = nums1.infinity; } - | 'min' { $m = minmax1.min; } - | 'max' { $m = minmax1.max; } - | 'lambda' { $m = fns1.lambda; } - | 'true' { $m = logic1.trueSym; } - | 'false' { $m = logic1.falseSym; } - | 'binomial' { $m = combinat1.binomial; } - | 'factorial' { $m = integer1.factorial; }; - -paraExpr returns [CMathML m]: + 'cos' { $m = csymbol("transc1", "cos"); } + | 'cosh' { $m = csymbol("transc1", "cosh"); } + | 'cot' { $m = csymbol("transc1", "cot"); } + | 'coth' { $m = csymbol("transc1", "coth"); } + | 'csc' { $m = csymbol("transc1", "csc"); } + | 'csch' { $m = csymbol("transc1", "csch"); } + | 'exp' { $m = csymbol("transc1", "exp"); } + | 'sec' { $m = csymbol("transc1", "sec"); } + | 'sech' { $m = csymbol("transc1", "sech"); } + | 'sin' { $m = csymbol("transc1", "sin"); } + | 'sinh' { $m = csymbol("transc1", "sinh"); } + | 'tan' { $m = csymbol("transc1", "tan"); } + | 'tanh' { $m = csymbol("transc1", "tanh"); } + | 'abs' { $m = csymbol("arith1", "abs"); } + | 'root' { $m = csymbol("arith1", "root"); } + | 'sum' { $m = csymbol("arith1", "sum"); } + | 'product' { $m = csymbol("arith1", "product"); } + | 'diff' { $m = csymbol("calculus1", "diff"); } + | 'int' { $m = csymbol("calculus1", "int"); } + | 'defint' { $m = csymbol("calculus1", "defint"); } + | 'pi' { $m = csymbol("nums1", "pi"); } + | 'e' { $m = csymbol("nums1", "e"); } + | 'i' { $m = csymbol("nums1", "i"); } + | 'infinity' { $m = csymbol("nums1", "infinity"); } + | 'min' { $m = csymbol("minmax1", "min"); } + | 'max' { $m = csymbol("minmax1", "max"); } + | 'lambda' { $m = csymbol("fns1", "lambda"); } + | 'true' { $m = csymbol("logic1", "true"); } + | 'false' { $m = csymbol("logic1", "false"); } + | 'binomial' { $m = csymbol("combinat1", "binomial"); } + | 'factorial' { $m = csymbol("integer1", "factorial"); }; + +paraExpr returns [CMathML m]: '(' x=expr ')' { $m = $x.m; }; -ifExpr returns [CMathML m]: - 'if' x=expr 'then' y=expr 'else' z=expr 'endif' { $m = apply(prog1.if,x,y,z); }; +ifExpr returns [CMathML m]: + 'if' x=expr 'then' y=expr 'else' z=expr 'endif' { $m = apply("prog1", "if", $x.m, $y.m, $z.m); }; whileExpr returns [CMathML m]: - 'while' x=expr 'do' y=expr 'endwhile' { $m = apply(prog1.while,x,y); }; + 'while' x=expr 'do' y=expr 'endwhile' { $m = apply("prog1", "while", $x.m, $y.m); }; symbol returns [CSymbol m]: - cd=ID '.' name=ID { $m = new CSymbol($cd,$name); }; + cd=ID '.' name=ID { $m = csymbol(stripID($cd),stripID($name)); }; var returns [CILike m]: - '$' x=ID { $m = new CI($x); }; + '$' x=ID { $m = ci(stripID($x)); }; ref returns [CMathML m]: - ('#' | '##') ID { throw new SyntaxError("references not supported"); }; + ('#' | '##') ID { if (true) throw new NotImplementedError("references not supported"); }; intt returns [CN m]: - x=HEXINT { throw new NotSupportedException("not yet implemented"); } - | x=DECINT { $m = new CN($x); }; + x=HEXINT { if (true) throw new NotImplementedError("not yet implemented"); } + | x=DECINT { $m = cn($x.getText()); }; floatt returns [CN m]: - x=HEXFLOAT { throw new NotSupportedException("not yet implemented"); } - | x=DECFLOAT { $m = new CN($x); }; - -ref: - ('#' | '##') ID { throw new SyntaxError("references not supported"); }; + x=HEXFLOAT { if (true) throw new NotImplementedError("not yet implemented"); } + | x=DECFLOAT { $m = cn($x.getText()); }; OMB: '%' [a-zA-Z0-9=]+ '%';