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.as static class Doc extends Dump {
 336             public @bind.arg Header head;
 337             public @bind.arg Body body;
 338         }
 339
 340         public @bind.as static class Header extends Dump {
 341             public @bind.arg KeyVal[] attrs;
 342             // FIXME: it would be nice to be able to
 343             // void KeyVal(String, String) { ... } imperatively
 344         }
 345
 346         public @bind.as static class Body extends Dump {
 347             public Section[] sections;
 348         }
 349
 350         public @bind.as("Section") static class Section extends Dump {
 351             public String      header;
 352             public Paragraph[] paragraphs;
 353         }
 354
 355         public @bind.as static class KeyVal extends Dump {
 356             public @bind.arg String key;
 357             public @bind.arg Object val;
 358         }
 359
 360         public abstract static class Paragraph extends Dump implements ToHTML { }
 361
 362         public @bind.as("P") static class P extends Paragraph {
 363             public Text[] text;
 364             public P() { }
 365             public P(Text[] text) { this.text = text; }
 366             public void toHTML(HTML h) { if (text != null) for (Text t : text) if (t != null) t.toHTML(h); }
 367             public String toString() {
 368                 StringBuffer sb = new StringBuffer();
 369                 ToHTML.HTML h = new ToHTML.HTML(sb);
 370                 toHTML(h);
 371                 return sb.toString();
 372             }
 373         }
 374
 375         public @bind.as("HR") static class HR extends Paragraph {
 376             public void toHTML(HTML h) { h.tag("hr"); }
 377         }
 378
 379         public @bind.as("Blockquote") static class Blockquote extends Paragraph {
 380             Text[] text;
 381             public void toHTML(HTML h) { h.tag("blockquote", new P(text)); }
 382         }
 383
 384         public abstract static class Text extends Dump implements ToHTML { }
 385         public @bind.as static class Chars extends Text {
 386             public String text;
 387             public Chars() { }
 388             public Chars(String text) { this.text = text; }
 389             public void toHTML(HTML h) { h.appendText(" " + text + " "); }
 390             public String toString() { return text; }
 391         }
 392         public @bind.as static class Block extends Text {
 393             public Text[] text;
 394             public void toHTML(HTML h) { for(Text t : text) t.toHTML(h); }
 395         }
 396         public static class TextWrap extends Text {
 397             public Text text;
 398             public void toHTML(HTML h) {
 399                 if (htmlTag()!=null)
 400                     h.tag(htmlTag(), htmlTagParams(), text);
 401                 else
 402                     text.toHTML(h);
 403             }
 404             public String   htmlTag() { return null; }
 405             public Object[] htmlTagParams() { return null; }
 406         }
 407         public static @bind.as class Verbatim   extends Text { public char[] c; public void toHTML(HTML h) { } }
 408         //public @bind.as class Blockquote extends TextWrap { }
 409         public static @bind.as class Underline extends TextWrap { public String htmlTag() { return "u"; } }
 410         public static @bind.as class Footnote extends TextWrap { public String htmlTag() { return "small"; } }
 411         public static @bind.as class TT extends TextWrap { public String htmlTag() { return "tt"; } }
 412         //public @bind.as class Citation extends Text {       "[" word "]" }
 413         public static @bind.as class Strikethrough extends TextWrap { public String htmlTag() { return "strikethrough"; } }
 414         public static @bind.as class Superscript extends TextWrap { public String htmlTag() { return "sup"; } }
 415         public static @bind.as class Subscript extends TextWrap { public String htmlTag() { return "sub"; } }
 416         public static @bind.as class Smallcap extends TextWrap { public String htmlTag() { return "sc"; } }
 417         public static @bind.as class Keyword extends TextWrap { public String htmlTag() { return "sc"; } }
 418         public static @bind.as class Bold extends TextWrap { public String htmlTag() { return "b"; } }
 419         public static @bind.as class Italic extends TextWrap { public String htmlTag() { return "i"; } }
 420
 421         public abstract static class Command extends Text { }
 422         public static @bind.as class Today extends Command { public void toHTML(HTML h) { } }
 423         public static @bind.as class LineBreak extends Command { public void toHTML(HTML h) { h.tag("br"); } }
 424
 425         public abstract static class Glyph extends Text { }
 426         public static @bind.as("emdash") class Emdash extends Glyph { public void toHTML(HTML h) { h.append("&emdash;"); } }
 427
 428         public static class Link extends Text {
 429             public Text[] t;
 430             public Url u;
 431             public @bind.as("LinkText") Link(Text[] t, Url u)  { this.t = t; this.u = u; }
 432             public @bind.as("LinkChars") Link(String s, Url u) { this(new Text[] { new Chars(s) }, u); }
 433             public void toHTML(HTML h) {
 434                 h.tag("a",
 435                       new Object[] { "href", u==null ? "" : u.toString() },
 436                       new P(t));
 437             }
 438         }
 439
 440         public static class Host {
 441             public String name;
 442             public String toString() { return name; }
 443             public @bind.as("DNS") Host(String[][] parts) {
 444                 name = "";
 445                 for(String[] s : parts) {
 446                     for(String ss : s)
 447                         name += ss;
 448                     name += ".";
 449                 }
 450             }
 451             public @bind.as("IP")  Host(int a, int b, int c, int d) { name = a+"."+b+"."+c+"."+d; }
 452         }
 453
 454         public static class Url extends Text {
 455             public String   method;
 456             public Host     host;
 457             public String   user;
 458             public String   pass;
 459             public String   port;
 460             public String   path;
 461             public @bind.as("URL") Url(String method, String[] login, Host host, String port, String path) {
 462                 this.method = method;
 463                 this.user = login==null ? null : login.length >= 1 ? login[0] : null;
 464                 this.pass = login==null ? null : login.length >= 2 ? login[1] : null;
 465                 this.host = host;
 466                 this.port = port;
 467                 this.path = path;
 468             }
 469             public @bind.as("Mailto") Url(String email) { this("mailto", null, null, "25", email); }
 470             public void toHTML(HTML h) { new Link(toString(), this).toHTML(h); }
 471             public String toString() {
 472                 return method + "://" + host + "/" + path;
 473             }
 474         }
 475         public static @bind.as("lf")        String lf() { return "\r"; }
 476         public static @bind.as("cr")        String cr() { return "\n"; }
 477         public static @bind.as("\"\"")      String empty() { return ""; }
 478         public static @bind.as("urlescape") String urlescape(char a, char b) { return ((char)((a-'0') * 16 + (b-'0')))+""; }
 479     }
 480
 481     public static void main(String[] s) throws Exception {
 482             /*
 483         try {
 484
 485                FIXME FIXME
 486
 487             MetaGrammar.ReflectiveMeta m =
 488                 new MetaGrammar.ReflectiveMeta(TibDoc.TD.class);
 489             Tree<String> res = new CharParser(MetaGrammar.make()).parse(new FileInputStream(s[0])).expand1();
 490             MetaGrammar.Meta.MetaGrammarFile mgf = m.new MetaGrammarFile(res);
 491             MetaGrammar.BuildContext bc = new MetaGrammar.BuildContext(mgf);
 492
 493             Union tibgram = mgf.get("s").build(bc);
 494
 495             System.err.println("parsing " + s[1]);
 496             Tree t = new CharParser(tibgram).parse(new Tib(new FileInputStream(s[1]))).expand1();
 497             System.out.println("tree:\n" + t.toPrettyString());
 498
 499             Object result = ((Functor)t.head()).invoke(t);
 500             System.out.println((TD.Doc)result);
 501             */
 502
 503
 504             /*
 505             System.out.println("parsing " + s[0]);
 506             Tree<String> res = new CharParser(MetaGrammar.make()).parse(new FileInputStream(s[0])).expand1();
 507             MetaGrammar gram = new Tib.Grammar(TibDoc.class);
 508             gram = (MetaGrammar)gram.walk(res);
 509             System.out.println("\nparsing " + s[1]);
 510             Forest f = new CharParser(gram.done()).parse(new Tib(new FileInputStream(s[1])));
 511             System.out.println();
 512             System.out.println(f.expand1().toPrettyString());
 513             System.out.println();
 514
 515
 516             FileOutputStream fos = new FileOutputStream("out.html");
 517             PrintWriter p = new PrintWriter(new OutputStreamWriter(fos));
 518             p.println(sb);
 519             p.flush();
 520             p.close();
 521
 522         } catch (Ambiguous a) {
 523             FileOutputStream fos = new FileOutputStream("/Users/megacz/Desktop/out.dot");
 524             PrintWriter p = new PrintWriter(new OutputStreamWriter(fos));
 525             GraphViz gv = new GraphViz();
 526             a.ambiguity.toGraphViz(gv);
 527             gv.dump(p);
 528             p.flush();
 529             p.close();
 530             a.printStackTrace();
 531
 532         } catch (Exception e) {
 533             e.printStackTrace();
 534         }
 535             */
 536     }
 537
 538 }
 539