src/edu/berkeley/sbp/tib/TibDoc.java

   1 // Copyright 2005 the Contributors, as shown in the revision logs.
   2 // Licensed under the Apache Public Source License 2.0 ("the License").
   3 // You may not use this file except in compliance with the License.
   4
   5 package edu.berkeley.sbp.tib;
   6 import edu.berkeley.sbp.*;
   7 import edu.berkeley.sbp.misc.*;
   8 import edu.berkeley.sbp.meta.*;
   9 import edu.berkeley.sbp.util.*;
  10 import edu.berkeley.sbp.chr.*;
  11 import edu.berkeley.sbp.bind.*;
  12 import java.util.*;
  13 import java.io.*;
  14 import static edu.berkeley.sbp.meta.MetaGrammar.*;
  15
  16 public class TibDoc {
  17     /*
  18     public static Text lf()     { Chars ret = new Chars(); ret.text = "\n"; return ret; }
  19     public static Text cr()     { Chars ret = new Chars(); ret.text = "\r"; return ret; }
  20     public static Text emdash() { return new Entity("mdash"); }
  21     public static char urlescape(int a, int b) { return (char)(10*a+b); }
  22
  23
  24     // Template Classes //////////////////////////////////////////////////////////////////////////////
  25
  26     public static abstract class Text implements ToHTML {
  27         public static final Class[] subclasses = new Class[] { Chars.class, URL.class, Email.class };
  28         public void toHTML(ToHTML.HTML sb) { }
  29         public static class TextString extends Text {
  30             public String text;
  31             public String tag() { return null; }
  32             public void toHTML(ToHTML.HTML sb) { sb.tag(tag(), text); }
  33         }
  34         public static class TextArray extends Text {
  35             public Text[] t;
  36             public String tag() { return null; }
  37             public void toHTML(ToHTML.HTML sb) { sb.tag(tag(), t); }
  38         }
  39     }
  40
  41
  42     // Structural //////////////////////////////////////////////////////////////////////////////
  43
  44     public static class Doc implements ToHTML {
  45         public Header head;
  46         public Body   body;
  47         public void toHTML(ToHTML.HTML sb) { sb.tag("html", body); }
  48         public static class Header extends HashMap<String, Text[]> {
  49             public static class KeyVal { public String key; public Text[] val; }
  50             public void attrs(KeyVal[] KeyVals) { for(int i=0; i<KeyVals.length; i++) this.put(KeyVals[i].key, KeyVals[i].val); }
  51         }
  52         public static class Body implements ToHTML {
  53             public Section[] sections;
  54             public void toHTML(ToHTML.HTML sb) { sb.append(sections); }
  55             public static class Section implements ToHTML {
  56                 public Text header;
  57                 public Paragraph[] paragraphs;
  58                 public void toHTML(ToHTML.HTML sb) {
  59                     sb.tag("h3", header);
  60                     sb.append(paragraphs);
  61                 }
  62             }
  63         }
  64     }
  65
  66
  67     // Paragraph //////////////////////////////////////////////////////////////////////////////
  68
  69     public static interface Paragraph extends ToHTML {
  70         public static final Class[] subclasses = new Class[] { Blockquote.class, P.class, HR.class };
  71         public static class HR                                implements Paragraph { public void toHTML(ToHTML.HTML sb) { sb.append("\n<hr>\n"); } }
  72         public static class P          extends Text.TextArray implements Paragraph { public String tag() { return "p"; } }
  73         public static class Blockquote extends Text.TextArray implements Paragraph { public String tag() { return "blockquote"; } }
  74     }
  75
  76     public static abstract class List extends Text {
  77         public Text[][] points;
  78         public abstract String tag();
  79         public void toHTML(ToHTML.HTML sb) {
  80             sb.append("<"+tag()+">\n");
  81             for(Text[] t : points) sb.tag("li", t);
  82             sb.append("</"+tag()+">\n");
  83         }
  84     }
  85     public static class OL extends List { public String tag() { return "ol"; } }
  86     public static class UL extends List { public String tag() { return "ul"; } }
  87
  88
  89
  90     // Tags //////////////////////////////////////////////////////////////////////////////
  91
  92     public static class Chars         extends Text.TextString { }
  93     public static class Symbol        extends Text.TextString { }
  94     public static class Keyword       extends Text.TextString { public String tag() { return "tt"; } }
  95     public static class Subscript     extends Text.TextString { public String tag() { return "sub"; } }
  96     public static class Superscript   extends Text.TextString { public String tag() { return "super"; } }
  97     public static class Bold          extends Text.TextArray  { public String tag() { return "b"; } }
  98     public static class Smallcap      extends Text.TextArray  { public String tag() { return "sc"; } }
  99     public static class Strikethrough extends Text.TextArray  { public String tag() { return "strike"; } }
 100     public static class TT            extends Text.TextArray  { public String tag() { return "tt"; } }
 101     public static class Underline     extends Text.TextArray  { public String tag() { return "u"; } }
 102     public static class Italic        extends Text.TextArray  { public String tag() { return "i"; } }
 103     public static class Citation      extends Text.TextArray  { } // FIXME
 104     public static class Footnote      extends Text.TextArray  { } // FIXME
 105     public static class LineBreak     extends Text            { public void toHTML(ToHTML.HTML sb) { sb.tag("br"); } }
 106     public static class Today         extends Text            { }
 107     public static class Euro          extends Text            { public void toHTML(ToHTML.HTML sb) { sb.entity(8364); } }
 108     public static class Link          extends Text {
 109         public Text[] text;
 110         public URI href;
 111         public void toHTML(ToHTML.HTML sb) { sb.tag("a", new Object[] { "href", href }, text); }
 112     }
 113     public static class Entity        extends Text {
 114         public final String entity;
 115         public Entity(String entity) { this.entity = entity; }
 116         public void toHTML(ToHTML.HTML sb) { sb.entity(entity); }
 117     }
 118
 119
 120     // Network //////////////////////////////////////////////////////////////////////////////
 121
 122     public static interface Host extends ToHTML {
 123         public static class DNS implements Host {
 124             public String[] part;
 125             public void toHTML(ToHTML.HTML sb) {
 126                 for(int i=0; i<part.length; i++)
 127                     sb.append((i==0 ? "" : ".")+part[i]);
 128             }
 129         }
 130         public static class IP  implements Host {
 131             public int a, b, c, d;
 132             public void toHTML(ToHTML.HTML sb) { sb.append(a+"."+b+"."+c+"."+d); }
 133         }
 134     }
 135
 136     public static interface URI extends ToHTML {
 137         public static final Class[] subclasses = new Class[] { URL.class, Email.class };
 138     }
 139     public static class URL extends Text    implements URI {
 140         public String method;
 141         public Login login;
 142         public Host host;
 143         public int port;
 144         public String path;
 145         public void toHTML(ToHTML.HTML sb) {
 146             sb.append(method);
 147             sb.append("://");
 148             // login.toHTML(sb);   FIXME
 149             host.toHTML(sb);
 150             // sb.append(":");     FIXME
 151             // sb.append(port);
 152             sb.append("/");
 153             sb.append(path);
 154         }
 155     }
 156     public static class Email extends Text  implements URI {
 157         public String user;
 158         public Host host;
 159         public void toHTML(ToHTML.HTML sb) {
 160             sb.append(user);
 161             sb.append('@');
 162             host.toHTML(sb);
 163         }
 164     }
 165
 166     public static class Login {
 167         public String username;
 168         public String password;
 169         public void toHTML(ToHTML.HTML sb) {
 170             sb.append(username);
 171             sb.append(':');
 172             sb.append(password);
 173             sb.append('@');
 174         }
 175     }
 176
 177
 178
 179
 180     */
 181     /*
 182         public static void prefix(PrintWriter p) {
 183             p.println("% generated by TIBDOC");
 184             for(int i=0; i<packages.length; i++) p.println("\\usemodule["+packages[i]+"]");
 185             p.println("\\setuppapersize[letter]");
 186             p.println("\\setuppagenumbering[location=]");
 187             p.println("\\setupcolors[state=start]");
 188             //"\\setupinteraction[title={Title},author={Me},"++
 189             //"subtitle={Deez Nutz},keywords={blargh},color=blue]\n" ++
 190             //"\\setuppublications[database={me},numbering=yes,sort=author]\n" ++
 191             p.println("\\setuphead[section][style={\\ss\\bfa},number=no,before=\\blank\\hairline\\nowhitespace]");
 192             p.println("\\definelayout[mypage][backspace=1.75in,cutspace=1.75in,width=5in]");
 193             p.println("\\setuplayout[mypage]");
 194             p.println("\\definetypeface[myface][rm][Xserif][Warnock Pro]");
 195             p.println("\\definetypeface[myface][tt][Xmono][CMU Typewriter Text Regular][default]");
 196             p.println("\\definetypeface[myface][ss][Xsans][Myriad Pro][default]");
 197             p.println("\\usesymbols[uni]");
 198             p.println("\\definesymbol[1][{\\USymbCharZapf{39}{164}}]");
 199             p.println("\\setupbodyfont[myface, 11pt]");
 200             p.println("\\setupwhitespace[7pt]");
 201             p.println("\\def\\MyDroppedCaps%");
 202             p.println("    {\\DroppedCaps");
 203             p.println("        {} {Serif} {2\\baselineskip} {2pt} {1\\baselineskip} {2}}");
 204             p.println("\\starttext");
 205             p.println("\\switchtobodyfont[16pt]\\midaligned{\\ss\\bfa{Title}}\\switchtobodyfont[10pt]");
 206             p.println("\\midaligned{Adam Megacz}\n\n\\nowhitespace\\midaligned{\\tt{adam@megacz.com}}");
 207             p.println("\\blank[1cm,force]");
 208             //p.println("\\defineparagraphs[mypar][n=2,before={\\blank},after={\\blank}");
 209             //p.println("\\setupparagraphs[mypar][1][width=.45\\textwidth");
 210             //p.println("\\setupparagraphs[mypar][2][width=.55\\textwidth");
 211             //p.println("\\startmypa");
 212             //p.println("\\switchtobodyfont[sma");
 213         }
 214
 215         public static void suffix(PrintWriter p) {
 216             p.println("\\stoptext");
 217         }
 218         static String[] packages = new String[] { "supp-fun", "bib", "href" };
 219     }
 220
 221     // ConTex
 222
 223 module Contex where
 224 import Data.Array.IArray
 225 import Data.Char
 226 import Util
 227 import Lexer
 228 import IR
 229 import Data.List
 230 import Beautify
 231
 232 toContex ll = prefix ++ (concatMap tl ll) ++ suffix
 233  where
 234   packages                         = [ "[supp-fun]",
 235                                        "[bib]",
 236                                        "[href]" ]
 237   prefix                           = (concatMap (\x -> "\\usemodule"++x++"\n") packages) ++
 238                                      "\\setuppapersize[letter]\n" ++
 239                                      "\\setuppagenumbering[location=]\n" ++
 240                                      "\\setupcolors[state=start]\n" ++
 241                                      --"\\setupinteraction[title={Title},author={Me},"++
 242                                      --"subtitle={Deez Nutz},keywords={blargh},color=blue]\n" ++
 243                                      --"\\setuppublications[database={me},numbering=yes,sort=author]\n" ++
 244                                      "\\setuphead[section][style={\\ss\\bfa},\n" ++
 245                                      "                     number=no,\n" ++
 246                                      "                     before=\\blank\\hairline\\nowhitespace,\n" ++
 247                                      "                     ]\n" ++
 248                                      "\\definelayout[mypage][\n" ++
 249                                      " backspace=1.75in, % the space for margin notes\n" ++
 250                                      " cutspace=1.75in, % the space for right margin notes\n" ++
 251                                      " width=5in" ++
 252                                      "]\n" ++
 253                                      "\\setuplayout[mypage]\n" ++
 254                                      "\\definetypeface[myface][rm][Xserif][Warnock Pro]\n" ++
 255                                      "\\definetypeface[myface][tt][Xmono][CMU Typewriter Text Regular][default]\n" ++
 256                                      "\\definetypeface[myface][ss][Xsans][Myriad Pro][default]\n" ++
 257                                      "\\usesymbols[uni]\n" ++
 258                                      "\\definesymbol[1][{\\USymbCharZapf{39}{164}}]\n" ++
 259                                      "\\setupbodyfont[myface, 11pt]\n" ++
 260                                      "\\setupwhitespace[7pt]\n" ++
 261                                      "\\def\\MyDroppedCaps%\n" ++
 262                                      "    {\\DroppedCaps\n" ++
 263                                      "        {} {Serif} {2\\baselineskip} {2pt} {1\\baselineskip} {2}}\n" ++
 264                                      "\\starttext\n" ++
 265                                      "\\switchtobodyfont[16pt]\\midaligned{\\ss\\bfa{Hi5 Replicated Server Infrastructure}}\\switchtobodyfont[10pt]\n"++
 266                                      "\\midaligned{Adam Megacz}\n\n\\nowhitespace\\midaligned{\\tt{adam@megacz.com}}\n\n"++
 267                                      "\\blank[1cm,force]\n" ++
 268                                      "\\defineparagraphs[mypar][n=2,before={\\blank},after={\\blank}]\n"++
 269                                      "\\setupparagraphs[mypar][1][width=.45\\textwidth]\n"++
 270                                      "\\setupparagraphs[mypar][2][width=.55\\textwidth]\n"++
 271                                      "\\startmypar"++
 272                                      "\\switchtobodyfont[small]\n"
 273   suffix                           = "\n\\stoptext\n"
 274   addItem i                        = "\\item " ++ (striptrail $ boost 8 $ wrap $ striplead $ tl i)
 275   escapify []                      = []
 276   escapify ('%':t)                 = '\\':'%':(escapify t)
 277   escapify ('$':t)                 = '\\':'$':(escapify t)
 278   escapify (h:t)                   = h:(escapify t)
 279   escapeMath s                     = s
 280   tl (Special _ BulletList l)      = "\\startitemize[symbol]\n" ++ (concatMap addItem l) ++ "\\stopitemize\n"
 281   tl (Special _ NumberList l)      = "\\startitemize[symbol]\n" ++ (concatMap addItem l) ++ "\\stopitemize\n"
 282   tl (Special _ Section (h:t))     = "\\section{"++(tl h)++"}\n"++(concatMap tl t)
 283   tl (Special _ NumberedSection (h:t)) = "\\section{"++(tl h)++"}\n"++(concatMap tl t)
 284   tl (Special _ (Glyph EmDash) []) = "{\\emdash}"
 285 --tl (Special _ Superscript l)     =
 286 --tl (Special _ Subscript l)       =
 287 --tl (Special _ (Image u) l)       =
 288 --tl (Special _ (Cite u) l)        =
 289   tl (Special _ BlockQuote l)      = "\n\n\\startquote\n     "++
 290                                      (striptrail $ boost 4 $ wrap $ striplead $ concatMap tl l)++"\n\\stopquote\n\n"
 291   tl (Special _ HorizontalRule []) = "\\\\\\rule{4in}{0.5pt}\\\\"
 292   tl (Special _ Italic l)          = "{\\it{"++(concatMap tl l)++"}}"
 293   tl (Special _ Bold l)            = "{\\bf{"++(concatMap tl l)++"}}"
 294   tl (Special _ DropCap (h:t))     = "\\MyDroppedCaps{"++(tl h)++"}{\\sc "++(concatMap tl t)++"}"
 295   tl (Special _ Typewriter l)      = "{\\tt{"++(concatMap tl l)++"}}"
 296   tl (Special _ StrikeThrough l)   = "" --"\\sout{"++(concatMap tl l)++"}"
 297   tl (Special _ Quotes l)          = "``"++(concatMap tl l)++"''"
 298   tl (Special _ Underline l)       = "" --"\\uline{"++(concatMap tl l)++"}"
 299   tl (Special _ Underline2 l)      = "" --"\\uuline{"++(concatMap tl l)++"}"
 300   tl (Special _ (Math s) [])       = "\\placeformula\n$$\n" ++ (escapeMath s) ++ "\n$$\n"
 301   tl (Special _ Footnote l)        = "\\footnote{"++(concatMap tl l)++"}"
 302   tl (Special _ Float l)           = "" --"\n\n\\begin{wrapfigure}{r}{0.4\\textwidth} \\framebox[0.4\\textwidth]{"++
 303                                      --(concatMap tl l)++"} \\label{x}\\end{wrapfigure}\n\n"
 304 --tl (Special _ Figure l)          = "\\placefigure[][fig:church]{}{"++(concatMap tl l)++"}"
 305   tl (Special _ Figure l)          = "\\startnarrower\n"++(concatMap tl l)++"\n\\stopnarrower\n"
 306   tl (Special _ (Link u) l)        = "\\href{"++(escapify u)++"}{"++(concatMap tl l)++"}"
 307   tl (Special _ (Verbatim s) [])   = "\\starttyping\n"++s++"\n\\stoptyping\n"
 308 --  tl (Special _ TwoColumn l)       = "\\startcolumns[n=2]\n"++(concatMap tl l)++"\\stopcolumns"
 309 --  tl (Special _ Title l)           = ""--"\\title{"++(concatMap tl l)++"}\n\\maketitle\n\n\n"
 310   tl (Special _ Abstract l) =
 311       "\\midaligned{\\ss\\bfa Abstract}\\par\n " ++
 312       "\n\n"++(concatMap tl l)++"\\mypar" ++
 313       "\\switchtobodyfont[8pt]{\\ss{\\placecontent}}\\switchtobodyfont[normal]\\stopmypar\n\n\\blank[1cm,force]"
 314   tl (Special _ (Command c) l)     = "\\"++c++"["++(concatMap tl l)++"]"
 315   tl (Special _ t l)               = error $ "formatting code "++(show t)++" not supported on {"++(concatMap show l)++"})"
 316   tl (WS _)                        = " "
 317   tl (BlankLine _)                 = "\n\n"
 318   tl (Block _ l)                   = concatMap tl l
 319   tl (Letter _ c)                  = escapify [c]
 320   tl z                             = (show z)
 321
 322
 323
 324
 325     */
 326
 327     // Main //////////////////////////////////////////////////////////////////////////////
 328
 329     public static class Dump implements Reflection.Show {
 330         public String toString() { return Reflection.show((Reflection.Show)this); }
 331     }
 332
 333     public static class TD {
 334
 335         public @bind static class Doc extends Dump implements ToHTML {
 336             public @bind.arg Header head;
 337             public @bind.arg Body body;
 338             public void toHTML(HTML h) { body.toHTML(h); }
 339         }
 340
 341         public @bind static class Header extends Dump {
 342             public @bind.arg KeyVal[] attrs;
 343             // FIXME: it would be nice to be able to
 344             // void KeyVal(String, String) { ... } imperatively
 345         }
 346
 347         public @bind static class Body extends Dump implements ToHTML {
 348             public Section[] sections;
 349             public void toHTML(HTML h) { for(Section s : sections) s.toHTML(h); }
 350         }
 351
 352         public @bind.as("Section") static class Section extends Dump implements ToHTML {
 353             public String      header;
 354             public Paragraph[] paragraphs;
 355             public void toHTML(HTML h) {
 356                 h.tag("h1", header);
 357                 for(Paragraph p : paragraphs) h.tag("p", p);
 358             }
 359         }
 360
 361         public @bind static class KeyVal extends Dump {
 362             public @bind.arg String key;
 363             public @bind.arg Object val;
 364         }
 365
 366         public abstract static class Paragraph extends Dump implements ToHTML { }
 367
 368         public @bind.as("P") static class P extends Paragraph {
 369             public Text[] text;
 370             public P() { }
 371             public P(Text[] text) { this.text = text; }
 372             public void toHTML(HTML h) { if (text != null) for (Text t : text) if (t != null) t.toHTML(h); }
 373             public String toString() {
 374                 StringBuffer sb = new StringBuffer();
 375                 ToHTML.HTML h = new ToHTML.HTML(sb);
 376                 toHTML(h);
 377                 return sb.toString();
 378             }
 379         }
 380
 381         public @bind.as("email") static Object email(@bind.arg Object a, @bind.arg Object c) { return null; }
 382         public static @bind class Login {
 383             public @bind.arg String username;
 384             public @bind.arg String password;
 385         }
 386
 387         public static @bind.as("Euro") Object euro() { return null; }
 388         public static @bind.as("Citation") Object cite(Object o) { return new Chars("*cite*"); }
 389         public static @bind.as("Symbol") Object sym(Object o) { return null; }
 390
 391         public static abstract class List extends Text {
 392             public @bind.arg Text[][] points;
 393             public abstract String tag();
 394             public void toHTML(ToHTML.HTML sb) {
 395                 sb.append("<"+tag()+">\n");
 396                 for(Text[] t : points)
 397                     sb.tag("li", t);
 398                 sb.append("</"+tag()+">\n");
 399             }
 400         }
 401         public static @bind class OL extends List { public String tag() { return "ol"; } }
 402         public static @bind class UL extends List { public String tag() { return "ul"; } }
 403
 404         public static class HR extends Paragraph {
 405             public @bind HR() { }
 406             public @bind HR(Object o) { }
 407             public void toHTML(HTML h) { h.tag("hr"); }
 408         }
 409
 410        public static class Blockquote extends Paragraph {
 411             Text[] text;
 412             public @bind Blockquote(Text[] t) { this.text = t; }
 413             public @bind Blockquote(Text[] t, Text[] t2) {
 414                 if (t2==null) {
 415                     this.text = t;
 416                 } else {
 417                     Text[] t3 = new Text[t.length + t2.length];
 418                     System.arraycopy(t,  0, t3, 0, t.length);
 419                     System.arraycopy(t2, 0, t3, t.length, t2.length);
 420                     this.text = t3;
 421                 }
 422             }
 423             public void toHTML(HTML h) { h.tag("blockquote", new P(text)); }
 424         }
 425
 426         public abstract static class Text extends Dump implements ToHTML { }
 427         public @bind static class Chars extends Text {
 428             public String text;
 429             public Chars() { }
 430             public Chars(String text) { this.text = text; }
 431             public void toHTML(HTML h) { h.appendText(" " + text + " "); }
 432             public String toString() { return text; }
 433         }
 434         public @bind static class Block extends Text {
 435             public Text[] text;
 436             public void toHTML(HTML h) { for(Text t : text) t.toHTML(h); }
 437         }
 438         public static class TextWrap extends Text {
 439             public @bind.arg Text[] text;
 440             public void toHTML(HTML h) {
 441                 if (htmlTag()!=null) {
 442                     h.openTag(htmlTag(), htmlTagParams());
 443                 }
 444                 for(Text t : text) t.toHTML(h);
 445                 if (htmlTag()!=null) {
 446                     h.closeTag(htmlTag());
 447                 }
 448             }
 449             public String   htmlTag() { return null; }
 450             public Object[] htmlTagParams() { return null; }
 451         }
 452         public static @bind class Verbatim   extends Text { public char[] c; public void toHTML(HTML h) { } }
 453         //public @bind class Blockquote extends TextWrap { }
 454         public static @bind class Underline extends TextWrap { public String htmlTag() { return "u"; } }
 455         public static @bind class Footnote extends TextWrap { public String htmlTag() { return "small"; } }
 456         public static @bind class TT extends TextWrap { public String htmlTag() { return "tt"; } }
 457         //public @bind class Citation extends Text {       "[" word "]" }
 458         public static @bind class Strikethrough extends TextWrap { public String htmlTag() { return "strike"; } }
 459         public static @bind class Superscript extends TextWrap { public String htmlTag() { return "sup"; } }
 460         public static @bind class Subscript extends TextWrap { public String htmlTag() { return "sub"; } }
 461         public static @bind class Smallcap extends TextWrap { public String htmlTag() { return "sc"; } }
 462         public static @bind class Keyword extends TextWrap { public String htmlTag() { return "sc"; } }
 463         public static @bind class Bold extends TextWrap { public String htmlTag() { return "b"; } }
 464         public static @bind class Italic extends TextWrap { public String htmlTag() { return "i"; } }
 465
 466         public abstract static class Command extends Text { }
 467         public static @bind class Today extends Command { public void toHTML(HTML h) { } }
 468         public static @bind class LineBreak extends Command { public void toHTML(HTML h) { h.tag("br"); } }
 469
 470         public abstract static class Glyph extends Text { }
 471         public static @bind.as("emdash") class Emdash extends Glyph { public void toHTML(HTML h) { h.appendLiterally("&mdash;"); } }
 472
 473         public static class Link extends Text {
 474             public Text[] t;
 475             public Url u;
 476             public @bind.as("LinkText") Link(Text[] t, Url u)  { this.t = t; this.u = u; }
 477             public @bind.as("LinkChars") Link(String s, Url u) { this(new Text[] { new Chars(s) }, u); }
 478             public void toHTML(HTML h) {
 479                 h.tag("a",
 480                       new Object[] { "href", u==null ? "" : u.toString() },
 481                       new P(t));
 482             }
 483         }
 484
 485         public static class Host {
 486             public String name;
 487             public String toString() { return name; }
 488             public @bind.as("DNS") Host(String[][] parts) {
 489                 name = "";
 490                 for(String[] s : parts) {
 491                     for(String ss : s)
 492                         name += ss;
 493                     name += ".";
 494                 }
 495             }
 496             public @bind.as("IP")  Host(int a, int b, int c, int d) { name = a+"."+b+"."+c+"."+d; }
 497         }
 498
 499         public static class Url extends Text {
 500             public String   method;
 501             public Host     host;
 502             public String   user;
 503             public String   pass;
 504             public String   port;
 505             public String   path;
 506             public @bind.as("URL") Url(String method, String[] login, Host host, String port, String path) {
 507                 this.method = method;
 508                 this.user = login==null ? null : login.length >= 1 ? login[0] : null;
 509                 this.pass = login==null ? null : login.length >= 2 ? login[1] : null;
 510                 this.host = host;
 511                 this.port = port;
 512                 this.path = path;
 513             }
 514             public @bind.as("Mailto") Url(String email) { this("mailto", null, null, "25", email); }
 515             public void toHTML(HTML h) { new Link(toString(), this).toHTML(h); }
 516             public String toString() {
 517                 return method + "://" + host + "/" + path;
 518             }
 519         }
 520         public static @bind.as("lf")        String lf() { return "\r"; }
 521         public static @bind.as("cr")        String cr() { return "\n"; }
 522         public static @bind.as("\"\"")      String empty() { return ""; }
 523         public static @bind.as("urlescape") String urlescape(char a, char b) { return ((char)((a-'0') * 16 + (b-'0')))+""; }
 524     }
 525
 526     public static void main(String[] s) throws Exception {
 527         try {
 528
 529             Tree<String> res = new CharParser(MetaGrammar.make()).parse(new FileInputStream(s[0])).expand1();
 530
 531             Union tibgram = MetaGrammar.make(res, "s", new AnnotationGrammarBindingResolver(TD.class));
 532
 533             System.err.println("parsing " + s[1]);
 534             Tree t = new CharParser(tibgram).parse(new Tib(new FileInputStream(s[1]))).expand1();
 535             System.out.println("tree:\n" + t.toPrettyString());
 536
 537             Object result = ((Functor)t.head()).invoke(t);
 538             TD.Doc doc = (TD.Doc)result;
 539             System.out.println(doc);
 540
 541             StringBuffer sb = new StringBuffer();
 542             ToHTML.HTML html = new ToHTML.HTML(sb);
 543             doc.toHTML(html);
 544             FileOutputStream fos = new FileOutputStream("out.html");
 545             PrintWriter p = new PrintWriter(new OutputStreamWriter(fos));
 546             p.println(sb);
 547             p.flush();
 548             p.close();
 549
 550
 551
 552             /*
 553             System.out.println("parsing " + s[0]);
 554             Tree<String> res = new CharParser(MetaGrammar.make()).parse(new FileInputStream(s[0])).expand1();
 555             MetaGrammar gram = new Tib.Grammar(TibDoc.class);
 556             gram = (MetaGrammar)gram.walk(res);
 557             System.out.println("\nparsing " + s[1]);
 558             Forest f = new CharParser(gram.done()).parse(new Tib(new FileInputStream(s[1])));
 559             System.out.println();
 560             System.out.println(f.expand1().toPrettyString());
 561             System.out.println();
 562
 563
 564             FileOutputStream fos = new FileOutputStream("out.html");
 565             PrintWriter p = new PrintWriter(new OutputStreamWriter(fos));
 566             p.println(sb);
 567             p.flush();
 568             p.close();
 569             */
 570         } catch (Ambiguous a) {
 571             FileOutputStream fos = new FileOutputStream("/Users/megacz/Desktop/out.dot");
 572             PrintWriter p = new PrintWriter(new OutputStreamWriter(fos));
 573             GraphViz gv = new GraphViz();
 574             a.ambiguity.toGraphViz(gv);
 575             gv.dump(p);
 576             p.flush();
 577             p.close();
 578             a.printStackTrace();
 579
 580         } catch (Exception e) {
 581             e.printStackTrace();
 582         }
 583
 584     }
 585
 586 }
 587