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 })
}
// 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)
}
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 =
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("")(_ + _)
mapToHtml(body)+
"</td></tr></table></div>\n"
case "br" => "\n<br/>\n"
+ case "alpha" => "α"
+ case "beta" => "β"
+ case "gamma" => "γ"
+ case "delta" => "δ"
+ case "epsilon" => "ε"
+ case "eta" => "η"
+ case "theta" => "θ"
+ case "kappa" => "κ"
+ case "lambda" => "λ"
+ case "mu" => "μ"
+ case "nu" => "ν"
+ case "pi" => "π"
+ case "rho" => "ρ"
+ // TO DO: integrate stixfonts stuff
case "cent" => "½"
case "euro" => "€"
// gross hack