projects / wix.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
update to sbp with regions in trees
[wix.git] / src / Doc.scala
diff --git a/src/Doc.scala b/src/Doc.scala
index 76e4b55..1a6d322 100644 (file)
--- a/src/Doc.scala
+++ b/src/Doc.scala
@@ -14,86 +14,86 @@ object Doc {
     s.foldLeft(Seq[A]())(_ ++ _)
 
   def docFromTree(t:Tree) : Doc =
-    t match { case Tree(_,Seq(_,Tree(_,a))) => new Doc(new Header(), a.map(sectionFromTree)) }
+    t match { case Tree(_,Seq(_,Tree(_,a,_)),_) => new Doc(new Header(), a.map(sectionFromTree)) }
 
   def sectionFromTree(t:Tree) : Section =
     t match {
-      case Tree("Section", seq) =>
+      case Tree("Section", seq,_) =>
         seq(0) match {
-          case Tree("SectionHeader", Seq(Tree("=",e),c)) =>
+          case Tree("SectionHeader", Seq(Tree("=",e,_),c),_) =>
             new Section(e.length-1, textSequenceFromTree(c), paragraphsFromTrees(seq.tail))
         }
     }
 
   def textSequenceFromTree (t:Tree) : Seq[Text] =
     t match {
-      case Tree("Word",    chars          ) => Seq(new Chars(stringFromTrees(chars)))
-      case Tree("Ordinal", x              ) => Seq(new Command("ordinal", Seq(new Chars(stringFromTrees(x)))))
-      case Tree("Fraction", Seq(n,d)      ) => Seq(new Command("fraction",Seq(new Chars(stringFromTree(n)),
+      case Tree("Word",    chars        ,_) => Seq(new Chars(stringFromTrees(chars)))
+      case Tree("Ordinal", x            ,_) => Seq(new Command("ordinal", Seq(new Chars(stringFromTrees(x)))))
+      case Tree("Fraction", Seq(n,d)    ,_) => Seq(new Command("fraction",Seq(new Chars(stringFromTree(n)),
                                                                               new Chars(stringFromTree(d)))))
-      case Tree("WS",     _               ) => Seq(WS)
-      case Tree("Quotes", Seq(x)          ) => Seq(new Quotes(textSequenceFromTree(x)))
-      case Tree("Pars", y                 ) => Seq(new SubPar(paragraphsFromTrees(y)))
-      case Tree("Command", Seq(x,y)       ) => Seq(new Command(stringFromTree(x), textSequenceFromTree(y)))
-      case Tree("Command",  Seq(x)        ) => Seq(new Command(stringFromTree(x), Seq()))
-      case Tree("Link",  Seq(text,link)   ) => Seq(new Link(urlFromTree(link), textSequenceFromTree(text)))
-      case Tree("Footnote", x             ) => Seq(new Footnote(concatMap(textSequenceFromTree,x)))
-      case Tree("Keyword", x              ) => Seq(new Keyword(concatMap(textSequenceFromTree,x)))
-      case Tree("Math", x                 ) => Seq(new Math(stringFromTrees(x)))
-      case Tree("Italic",  Seq(x)         ) => Seq(new Styled(Italic        , textSequenceFromTree(x)))
-      case Tree("Bold",  Seq(x)           ) => Seq(new Styled(Bold          , textSequenceFromTree(x)))
-      case Tree("Highlight",  Seq(x)      ) => Seq(new Styled(Highlight     , textSequenceFromTree(x)))
-      case Tree("TT", x                   ) => Seq(new Styled(TT            , concatMap(textSequenceFromTree,x)))
-      case Tree("Strikethrough", x        ) => Seq(new Styled(Strikethrough , concatMap(textSequenceFromTree,x)))
-      case Tree("Superscript", x          ) => Seq(new Styled(Superscript   , concatMap(textSequenceFromTree,x)))
-      case Tree("Subscript", x            ) => Seq(new Styled(Subscript     , concatMap(textSequenceFromTree,x)))
-      case Tree("Underline", x            ) => Seq(new Styled(Underline     , concatMap(textSequenceFromTree,x)))
-      case Tree("(e)",  _)                  => Seq(new GlyphText(Euro))
-      case Tree("(r)",  _)                  => Seq(new GlyphText(CircleR))
-      case Tree("(c)",  _)                  => Seq(new GlyphText(CircleC))
-      case Tree("(tm)",  _)                 => Seq(new GlyphText(TradeMark))
-      case Tree("--",  _)                   => Seq(new GlyphText(Emdash))
-      case Tree("<-",  _)                   => Seq(new GlyphText(LeftArrow))
-      case Tree("<=",  _)                   => Seq(new GlyphText(DoubleLeftArrow))
-      case Tree("=>",  _)                   => Seq(new GlyphText(DoubleRightArrow))
-      case Tree("<=>",  _)                  => Seq(new GlyphText(DoubleLeftRightArrow))
-      case Tree("<->",  _)                  => Seq(new GlyphText(LeftRightArrow))
-      case Tree("^o",  _)                   => Seq(new GlyphText(Degree))
-      case Tree("...",  _)                  => Seq(new GlyphText(Ellipsis))
-      case Tree("Text",   ts)               => concat(ts.map(textSequenceFromTree))
-      case Tree("",    Seq())               => Seq()
+      case Tree("WS",     _             ,_) => Seq(WS)
+      case Tree("Quotes", Seq(x)        ,_) => Seq(new Quotes(textSequenceFromTree(x)))
+      case Tree("Pars", y               ,_) => Seq(new SubPar(paragraphsFromTrees(y)))
+      case Tree("Command", Seq(x,y)     ,_) => Seq(new Command(stringFromTree(x), textSequenceFromTree(y)))
+      case Tree("Command",  Seq(x)      ,_) => Seq(new Command(stringFromTree(x), Seq()))
+      case Tree("Link",  Seq(text,link) ,_) => Seq(new Link(urlFromTree(link), textSequenceFromTree(text)))
+      case Tree("Footnote", x           ,_) => Seq(new Footnote(concatMap(textSequenceFromTree,x)))
+      case Tree("Keyword", x            ,_) => Seq(new Keyword(concatMap(textSequenceFromTree,x)))
+      case Tree("Math", x               ,_) => Seq(new Math(stringFromTrees(x)))
+      case Tree("Italic",  Seq(x)       ,_) => Seq(new Styled(Italic        , textSequenceFromTree(x)))
+      case Tree("Bold",  Seq(x)         ,_) => Seq(new Styled(Bold          , textSequenceFromTree(x)))
+      case Tree("Highlight",  Seq(x)    ,_) => Seq(new Styled(Highlight     , textSequenceFromTree(x)))
+      case Tree("TT", x                 ,_) => Seq(new Styled(TT            , concatMap(textSequenceFromTree,x)))
+      case Tree("Strikethrough", x      ,_) => Seq(new Styled(Strikethrough , concatMap(textSequenceFromTree,x)))
+      case Tree("Superscript", x        ,_) => Seq(new Styled(Superscript   , concatMap(textSequenceFromTree,x)))
+      case Tree("Subscript", x          ,_) => Seq(new Styled(Subscript     , concatMap(textSequenceFromTree,x)))
+      case Tree("Underline", x          ,_) => Seq(new Styled(Underline     , concatMap(textSequenceFromTree,x)))
+      case Tree("(e)",  _               ,_) => Seq(new GlyphText(Euro))
+      case Tree("(r)",  _               ,_) => Seq(new GlyphText(CircleR))
+      case Tree("(c)",  _               ,_) => Seq(new GlyphText(CircleC))
+      case Tree("(tm)", _               ,_) => Seq(new GlyphText(TradeMark))
+      case Tree("--",   _               ,_) => Seq(new GlyphText(Emdash))
+      case Tree("<-",   _               ,_) => Seq(new GlyphText(LeftArrow))
+      case Tree("<=",   _               ,_) => Seq(new GlyphText(DoubleLeftArrow))
+      case Tree("=>",   _               ,_) => Seq(new GlyphText(DoubleRightArrow))
+      case Tree("<=>",  _               ,_) => Seq(new GlyphText(DoubleLeftRightArrow))
+      case Tree("<->",  _               ,_) => Seq(new GlyphText(LeftRightArrow))
+      case Tree("^o",   _               ,_) => Seq(new GlyphText(Degree))
+      case Tree("...",  _               ,_) => Seq(new GlyphText(Ellipsis))
+      case Tree("Text",   ts            ,_) => concat(ts.map(textSequenceFromTree))
+      case Tree("",    Seq()            ,_) => Seq()
       case t => throw new RuntimeException("unable to create [Text] from " + t)
     }
 
   def hostFromTree(t:Tree) : Host =
     t match {
-      case Tree("IP", Seq(Tree(_,a),Tree(_,b),Tree(_,c),Tree(_,d))) =>
+      case Tree("IP", Seq(Tree(_,a,_),Tree(_,b,_),Tree(_,c,_),Tree(_,d,_)),_) =>
         new HostIP(intFromTrees(a), intFromTrees(b), intFromTrees(c), intFromTrees(d))
-      case Tree("DNS", parts) =>
-        new HostDNS(parts.map( (t:Tree) => t match { case Tree(_, c) => stringFromTrees(c) }))
+      case Tree("DNS", parts,_) =>
+        new HostDNS(parts.map( (t:Tree) => t match { case Tree(_, c,_) => stringFromTrees(c) }))
     }
 
   def urlFromTree(t:Tree) : URL =
     t match {
-      case Tree("URL", stuff)                            => urlFromTrees(stuff)
-      case Tree("Email", Seq(Tree("username", un),host)) => new URLEmail(stringFromTrees(un), hostFromTree(host))
-      case Tree("Path",stuff)                            => new URLPath(stuff.map(fromUrlChar).foldLeft("")(_ + _))
+      case Tree("URL", stuff,_)                              => urlFromTrees(stuff)
+      case Tree("Email", Seq(Tree("username", un,_),host),_) => new URLEmail(stringFromTrees(un), hostFromTree(host))
+      case Tree("Path",stuff,_)                              => new URLPath(stuff.map(fromUrlChar).foldLeft("")(_ + _))
     }
 
   def urlFromTrees(t:Seq[Tree]) : URL =
     t match {
-      case Seq(Tree(_,method), login, host, port, rest @_*) =>
+      case Seq(Tree(_,method,_), login, host, port, rest @_*) =>
         new URLNormal(stringFromTrees(method),
                       None,
                       hostFromTree(host),
-                      port match { case Tree("Port",port) => {
+                      port match { case Tree("Port",port,_) => {
                                      val q = stringFromTrees(port)
                                      if (q.equals("")) None else Some(java.lang.Integer.parseInt(q))
                                    }
                                    case _ => None },
-                      rest match { case Seq(Tree("Path",p), x@_*) => p.map(fromUrlChar).foldLeft("")(_ + _)
+                      rest match { case Seq(Tree("Path",p,_), x@_*) => p.map(fromUrlChar).foldLeft("")(_ + _)
                                    case _ => "" },
-                      rest match { case Seq(_ , Tree("Path",r), x@_*) => Some(stringFromTrees(r))
+                      rest match { case Seq(_ , Tree("Path",r,_), x@_*) => Some(stringFromTrees(r))
                                    case _ => None })
     }
 
@@ -101,8 +101,8 @@ object Doc {
   // FIXME: problem here is the "/" vs "%2F" issue, so we "leave urls urlencoded"
   def fromUrlChar(t:Tree) : String =
     t match {
-      case Tree("%", Seq(Tree(a,Seq()),Tree(b,Seq()))) => "%"+a+b
-      case Tree(x,y) =>
+      case Tree("%", Seq(Tree(a,Seq(),_),Tree(b,Seq(),_)),_) => "%"+a+b
+      case Tree(x,y,_) =>
         if (x.length==1) x
         else throw new RuntimeException("could not parse as URL char: " + t)
     }
@@ -112,29 +112,29 @@ object Doc {
 
   def paragraphsFromTree(t:Tree) : Seq[Paragraph] =
     consolidate (t match {
-      case Tree("Verbatim",       Seq(indent,v)) => Seq(new P(    Seq(new Verbatim(unindent(indent,unverbate(v))))))
-      case Tree("TextParagraph",  Seq(Tree(_,text))) => Seq(new P(concatMap(textSequenceFromTree,text)))
-      case Tree("Pars",           pars         ) => concatMap(paragraphsFromTree,pars)
-      case Tree("HR",             _            ) => Seq(HR)
-      case Tree("OL",             a            ) =>
-        Seq(new OL(a.map( (t:Tree) => t match { case Tree("LI",x) => paragraphsFromTrees(x)})))
-      case Tree("UL",             a            ) =>
-        Seq(new UL(a.map( (t:Tree) => t match { case Tree("LI",x) => paragraphsFromTrees(x)})))
-      case Tree("",               _            ) => Seq()
-      case Tree("Blockquote",     pars         ) => Seq(Blockquote(paragraphsFromTrees(pars)))
+      case Tree("Verbatim",       Seq(indent,v),_) => Seq(new P(    Seq(new Verbatim(unindent(indent,unverbate(v))))))
+      case Tree("TextParagraph",  Seq(Tree(_,text,_)),_) => Seq(new P(concatMap(textSequenceFromTree,text)))
+      case Tree("Pars",           pars       ,_) => concatMap(paragraphsFromTree,pars)
+      case Tree("HR",             _          ,_) => Seq(HR)
+      case Tree("OL",             a          ,_) =>
+        Seq(new OL(a.map( (t:Tree) => t match { case Tree("LI",x,_) => paragraphsFromTrees(x)})))
+      case Tree("UL",             a          ,_) =>
+        Seq(new UL(a.map( (t:Tree) => t match { case Tree("LI",x,_) => paragraphsFromTrees(x)})))
+      case Tree("",               _          ,_) => Seq()
+      case Tree("Blockquote",     pars       ,_) => Seq(Blockquote(paragraphsFromTrees(pars)))
       case _ => throw new RuntimeException("unable to create [Paragraph] from " + t)
     })
 
   def unverbate (t:Tree) : String =
     t match {
-      case Tree("Verbatim",x) => x.map(unverbate).foldLeft("")(_ + _)
-      case Tree("VerbatimBrace",Seq(x,y)) => unverbate(x)+" "+unverbate(y)
-      case Tree(t,Seq()) => t
+      case Tree("Verbatim",x,_) => x.map(unverbate).foldLeft("")(_ + _)
+      case Tree("VerbatimBrace",Seq(x,y),_) => unverbate(x)+" "+unverbate(y)
+      case Tree(t,Seq(),_) => t
     }
 
   def unindent (t:Tree,v:String) : String =
     t match {
-      case Tree("I", indent) => unindent_(indent.length+1, v)
+      case Tree("I", indent,_) => unindent_(indent.length+1, v)
     }
 
   private def unindent_ (i:Int,v:String) : String =
@@ -166,7 +166,7 @@ object Doc {
   def intFromTrees(t:Seq[Tree]) : Int =
     java.lang.Integer.parseInt(stringFromTrees(t))
   def stringFromTree(t:Tree) : String =
-    t match { case Tree(h,c) => h++concatMap(stringFromTree,c) }
+    t match { case Tree(h,c,_) => h++concatMap(stringFromTree,c) }
   def stringFromTrees(ts:Seq[Tree]) : String =
     ts.map(stringFromTree).foldLeft("")(_ + _)
 
@@ -277,6 +277,20 @@ abstract class Text extends ToHtml
                               mapToHtml(body)+
                               "</td></tr></table></div>\n"
         case "br"      =>     "\n<br/>\n"
+        case "alpha"   =>     "&#x03B1;"
+        case "beta"    =>     "&#x03B2;"
+        case "gamma"   =>     "&#x03B3;"
+        case "delta"   =>     "&#x03B4;"
+        case "epsilon" =>     "&#x03B5;"
+        case "eta"     =>     "&#x03B7;"
+        case "theta"   =>     "&#x03B8;"
+        case "kappa"   =>     "&#x03Ba;"
+        case "lambda"  =>     "&#x03Bb;"
+        case "mu"      =>     "&#x03Bc;"
+        case "nu"      =>     "&#x03Bd;"
+        case "pi"      =>     "&#x03c0;"
+        case "rho"     =>     "&#x03c1;"
+        // TO DO: integrate stixfonts stuff
         case "cent"    =>     "&#189;"
         case "euro"    =>     "&#8364;"
         // gross hack
WiX: a text markup format